tools/fidl/fidlgen_hlcpp/goldens/union.h.golden

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

// fidl_experiment = output_index_json

#pragma once

#include "lib/fidl/cpp/internal/header.h"

namespace test {
namespace union_ {

//
// Domain objects declarations
//

class Pizza;

class Pasta;

class PizzaOrPasta;

class ExplicitPizzaOrPasta;

class FlexiblePizzaOrPasta;

class StrictPizzaOrPasta;

class Union;

class FlexibleUnion;

class StrictUnion;

class FieldCollision;

class ExplicitUnion;

class ReverseOrdinalUnion;

class NullableUnionStruct;

class FlexibleFoo;

class StrictFoo;

class ExplicitFoo;

class ExplicitStrictFoo;

class OlderSimpleUnion;

class NewerSimpleUnion;

class StrictSimpleUnion;

class Empty;

class UnionContainingEmptyStruct;

class StrictBoundedUnion;

class TestProtocolStrictUnionHenceResponseMayBeStackAllocatedResponse;

class TestProtocolFlexibleUnionHenceResponseMustBeHeapAllocatedResponse;

#ifdef __Fuchsia__

class TestProtocol;
using TestProtocolHandle = ::fidl::InterfaceHandle<TestProtocol>;

#endif  // __Fuchsia__

class StructWithNullableUnion;

class ExplicitFlexibleUnion;

class UnionSandwich;

class UnionWithAttributes;

class EmptyFlexibleUnion;

class Pizza final {
 public:
  static const fidl_type_t* FidlType;

  ::std::vector<::std::string> toppings;

  static inline ::std::unique_ptr<Pizza> New() { return ::std::make_unique<Pizza>(); }

  void Encode(::fidl::Encoder* _encoder, size_t _offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, Pizza* value, size_t _offset);
  zx_status_t Clone(Pizza* result) const;
};

inline zx_status_t Clone(const ::test::union_::Pizza& _value,
                         ::test::union_::Pizza* _result) {
  return _value.Clone(_result);
}

using PizzaPtr = ::std::unique_ptr<Pizza>;

class Pasta final {
 public:
  static const fidl_type_t* FidlType;

  ::std::string sauce;

  static inline ::std::unique_ptr<Pasta> New() { return ::std::make_unique<Pasta>(); }

  void Encode(::fidl::Encoder* _encoder, size_t _offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, Pasta* value, size_t _offset);
  zx_status_t Clone(Pasta* result) const;
};

inline zx_status_t Clone(const ::test::union_::Pasta& _value,
                         ::test::union_::Pasta* _result) {
  return _value.Clone(_result);
}

using PastaPtr = ::std::unique_ptr<Pasta>;

class PizzaOrPasta final {
 public:
  static const fidl_type_t* FidlType;

  PizzaOrPasta();
  ~PizzaOrPasta();

  PizzaOrPasta(PizzaOrPasta&&);
  PizzaOrPasta& operator=(PizzaOrPasta&&);

  static PizzaOrPasta WithPizza(::test::union_::Pizza&&);
  static PizzaOrPasta WithPasta(::test::union_::Pasta&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {

    kPizza = 1,  // 0x1
    kPasta = 2,  // 0x2
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

  static inline ::std::unique_ptr<PizzaOrPasta> New() { return ::std::make_unique<PizzaOrPasta>(); }

  void Encode(::fidl::Encoder* encoder, size_t offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, PizzaOrPasta* value, size_t offset);
  zx_status_t Clone(PizzaOrPasta* result) const;

  bool has_invalid_tag() const {
    return tag_ == Invalid;
  }

  bool is_pizza() const { return tag_ == ::test::union_::PizzaOrPasta::Tag::kPizza; }

  ::test::union_::Pizza& pizza() {
    EnsureStorageInitialized(::test::union_::PizzaOrPasta::Tag::kPizza);
    return pizza_;
  }

  const ::test::union_::Pizza& pizza() const {
    ZX_ASSERT(is_pizza());
    return pizza_;
  }
  PizzaOrPasta& set_pizza(::test::union_::Pizza value);

  bool is_pasta() const { return tag_ == ::test::union_::PizzaOrPasta::Tag::kPasta; }

  ::test::union_::Pasta& pasta() {
    EnsureStorageInitialized(::test::union_::PizzaOrPasta::Tag::kPasta);
    return pasta_;
  }

  const ::test::union_::Pasta& pasta() const {
    ZX_ASSERT(is_pasta());
    return pasta_;
  }
  PizzaOrPasta& set_pasta(::test::union_::Pasta value);

  ::test::union_::PizzaOrPasta::Tag Which() const {
    return ::test::union_::PizzaOrPasta::Tag(tag_);
  }

  // You probably want to use Which() method instead of Ordinal(). Use Ordinal() only when you need
  // access to the raw integral ordinal value.
  fidl_xunion_tag_t Ordinal() const {
    return tag_;
  }

  friend ::fidl::Equality<::test::union_::PizzaOrPasta>;

 private:
  void Destroy();
  void EnsureStorageInitialized(::fidl_xunion_tag_t tag);

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::union_::PizzaOrPasta::Tag::Invalid);
  union {
    ::test::union_::Pizza pizza_;
    ::test::union_::Pasta pasta_;
  };
};

inline zx_status_t Clone(const ::test::union_::PizzaOrPasta& value,
                         ::test::union_::PizzaOrPasta* result) {
  return value.Clone(result);
}

using PizzaOrPastaPtr = ::std::unique_ptr<PizzaOrPasta>;

class ExplicitPizzaOrPasta final {
 public:
  static const fidl_type_t* FidlType;

  ExplicitPizzaOrPasta();
  ~ExplicitPizzaOrPasta();

  ExplicitPizzaOrPasta(ExplicitPizzaOrPasta&&);
  ExplicitPizzaOrPasta& operator=(ExplicitPizzaOrPasta&&);

  static ExplicitPizzaOrPasta WithPizza(::test::union_::Pizza&&);
  static ExplicitPizzaOrPasta WithPasta(::test::union_::Pasta&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {

    kPizza = 1,  // 0x1
    kPasta = 4,  // 0x4
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

  static inline ::std::unique_ptr<ExplicitPizzaOrPasta> New() { return ::std::make_unique<ExplicitPizzaOrPasta>(); }

  void Encode(::fidl::Encoder* encoder, size_t offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, ExplicitPizzaOrPasta* value, size_t offset);
  zx_status_t Clone(ExplicitPizzaOrPasta* result) const;

  bool has_invalid_tag() const {
    return tag_ == Invalid;
  }

  bool is_pizza() const { return tag_ == ::test::union_::ExplicitPizzaOrPasta::Tag::kPizza; }

  ::test::union_::Pizza& pizza() {
    EnsureStorageInitialized(::test::union_::ExplicitPizzaOrPasta::Tag::kPizza);
    return pizza_;
  }

  const ::test::union_::Pizza& pizza() const {
    ZX_ASSERT(is_pizza());
    return pizza_;
  }
  ExplicitPizzaOrPasta& set_pizza(::test::union_::Pizza value);

  bool is_pasta() const { return tag_ == ::test::union_::ExplicitPizzaOrPasta::Tag::kPasta; }

  ::test::union_::Pasta& pasta() {
    EnsureStorageInitialized(::test::union_::ExplicitPizzaOrPasta::Tag::kPasta);
    return pasta_;
  }

  const ::test::union_::Pasta& pasta() const {
    ZX_ASSERT(is_pasta());
    return pasta_;
  }
  ExplicitPizzaOrPasta& set_pasta(::test::union_::Pasta value);

  ::test::union_::ExplicitPizzaOrPasta::Tag Which() const {
    return ::test::union_::ExplicitPizzaOrPasta::Tag(tag_);
  }

  // You probably want to use Which() method instead of Ordinal(). Use Ordinal() only when you need
  // access to the raw integral ordinal value.
  fidl_xunion_tag_t Ordinal() const {
    return tag_;
  }

  friend ::fidl::Equality<::test::union_::ExplicitPizzaOrPasta>;

 private:
  void Destroy();
  void EnsureStorageInitialized(::fidl_xunion_tag_t tag);

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::union_::ExplicitPizzaOrPasta::Tag::Invalid);
  union {
    ::test::union_::Pizza pizza_;
    ::test::union_::Pasta pasta_;
  };
};

inline zx_status_t Clone(const ::test::union_::ExplicitPizzaOrPasta& value,
                         ::test::union_::ExplicitPizzaOrPasta* result) {
  return value.Clone(result);
}

using ExplicitPizzaOrPastaPtr = ::std::unique_ptr<ExplicitPizzaOrPasta>;

class FlexiblePizzaOrPasta final {
 public:
  static const fidl_type_t* FidlType;

  FlexiblePizzaOrPasta();
  ~FlexiblePizzaOrPasta();

  FlexiblePizzaOrPasta(FlexiblePizzaOrPasta&&);
  FlexiblePizzaOrPasta& operator=(FlexiblePizzaOrPasta&&);

  static FlexiblePizzaOrPasta WithPizza(::test::union_::Pizza&&);
  static FlexiblePizzaOrPasta WithPasta(::test::union_::Pasta&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {
    kUnknown = 0,

    kPizza = 1,  // 0x1
    kPasta = 2,  // 0x2
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

  static inline ::std::unique_ptr<FlexiblePizzaOrPasta> New() { return ::std::make_unique<FlexiblePizzaOrPasta>(); }

  void Encode(::fidl::Encoder* encoder, size_t offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, FlexiblePizzaOrPasta* value, size_t offset);
  zx_status_t Clone(FlexiblePizzaOrPasta* result) const;

  bool has_invalid_tag() const {
    return tag_ == Invalid;
  }

  bool is_pizza() const { return tag_ == ::test::union_::FlexiblePizzaOrPasta::Tag::kPizza; }

  ::test::union_::Pizza& pizza() {
    EnsureStorageInitialized(::test::union_::FlexiblePizzaOrPasta::Tag::kPizza);
    return pizza_;
  }

  const ::test::union_::Pizza& pizza() const {
    ZX_ASSERT(is_pizza());
    return pizza_;
  }
  FlexiblePizzaOrPasta& set_pizza(::test::union_::Pizza value);

  bool is_pasta() const { return tag_ == ::test::union_::FlexiblePizzaOrPasta::Tag::kPasta; }

  ::test::union_::Pasta& pasta() {
    EnsureStorageInitialized(::test::union_::FlexiblePizzaOrPasta::Tag::kPasta);
    return pasta_;
  }

  const ::test::union_::Pasta& pasta() const {
    ZX_ASSERT(is_pasta());
    return pasta_;
  }
  FlexiblePizzaOrPasta& set_pasta(::test::union_::Pasta value);
  FlexiblePizzaOrPasta& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes);

  ::test::union_::FlexiblePizzaOrPasta::Tag Which() const {
    switch (tag_) {
      case ::test::union_::FlexiblePizzaOrPasta::Tag::Invalid:
      case ::test::union_::FlexiblePizzaOrPasta::Tag::kPizza:
      case ::test::union_::FlexiblePizzaOrPasta::Tag::kPasta:
        return ::test::union_::FlexiblePizzaOrPasta::Tag(tag_);
      default:
        return ::test::union_::FlexiblePizzaOrPasta::Tag::kUnknown;
    }
  }

  // You probably want to use Which() method instead of Ordinal(). Use Ordinal() only when you need
  // access to the raw integral ordinal value.
  fidl_xunion_tag_t Ordinal() const {
    return tag_;
  }
  const std::vector<uint8_t>* UnknownBytes() const {
    if (Which() != ::test::union_::FlexiblePizzaOrPasta::Tag::kUnknown) {
      return nullptr;
    }
    return &unknown_data_;
  }

  friend ::fidl::Equality<::test::union_::FlexiblePizzaOrPasta>;

 private:
  void Destroy();
  void EnsureStorageInitialized(::fidl_xunion_tag_t tag);

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::union_::FlexiblePizzaOrPasta::Tag::Invalid);
  union {
    ::test::union_::Pizza pizza_;
    ::test::union_::Pasta pasta_;
    std::vector<uint8_t> unknown_data_;
  };
};

inline zx_status_t Clone(const ::test::union_::FlexiblePizzaOrPasta& value,
                         ::test::union_::FlexiblePizzaOrPasta* result) {
  return value.Clone(result);
}

using FlexiblePizzaOrPastaPtr = ::std::unique_ptr<FlexiblePizzaOrPasta>;

class StrictPizzaOrPasta final {
 public:
  static const fidl_type_t* FidlType;

  StrictPizzaOrPasta();
  ~StrictPizzaOrPasta();

  StrictPizzaOrPasta(StrictPizzaOrPasta&&);
  StrictPizzaOrPasta& operator=(StrictPizzaOrPasta&&);

  static StrictPizzaOrPasta WithPizza(::test::union_::Pizza&&);
  static StrictPizzaOrPasta WithPasta(::test::union_::Pasta&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {

    kPizza = 1,  // 0x1
    kPasta = 2,  // 0x2
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

  static inline ::std::unique_ptr<StrictPizzaOrPasta> New() { return ::std::make_unique<StrictPizzaOrPasta>(); }

  void Encode(::fidl::Encoder* encoder, size_t offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, StrictPizzaOrPasta* value, size_t offset);
  zx_status_t Clone(StrictPizzaOrPasta* result) const;

  bool has_invalid_tag() const {
    return tag_ == Invalid;
  }

  bool is_pizza() const { return tag_ == ::test::union_::StrictPizzaOrPasta::Tag::kPizza; }

  ::test::union_::Pizza& pizza() {
    EnsureStorageInitialized(::test::union_::StrictPizzaOrPasta::Tag::kPizza);
    return pizza_;
  }

  const ::test::union_::Pizza& pizza() const {
    ZX_ASSERT(is_pizza());
    return pizza_;
  }
  StrictPizzaOrPasta& set_pizza(::test::union_::Pizza value);

  bool is_pasta() const { return tag_ == ::test::union_::StrictPizzaOrPasta::Tag::kPasta; }

  ::test::union_::Pasta& pasta() {
    EnsureStorageInitialized(::test::union_::StrictPizzaOrPasta::Tag::kPasta);
    return pasta_;
  }

  const ::test::union_::Pasta& pasta() const {
    ZX_ASSERT(is_pasta());
    return pasta_;
  }
  StrictPizzaOrPasta& set_pasta(::test::union_::Pasta value);

  ::test::union_::StrictPizzaOrPasta::Tag Which() const {
    return ::test::union_::StrictPizzaOrPasta::Tag(tag_);
  }

  // You probably want to use Which() method instead of Ordinal(). Use Ordinal() only when you need
  // access to the raw integral ordinal value.
  fidl_xunion_tag_t Ordinal() const {
    return tag_;
  }

  friend ::fidl::Equality<::test::union_::StrictPizzaOrPasta>;

 private:
  void Destroy();
  void EnsureStorageInitialized(::fidl_xunion_tag_t tag);

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::union_::StrictPizzaOrPasta::Tag::Invalid);
  union {
    ::test::union_::Pizza pizza_;
    ::test::union_::Pasta pasta_;
  };
};

inline zx_status_t Clone(const ::test::union_::StrictPizzaOrPasta& value,
                         ::test::union_::StrictPizzaOrPasta* result) {
  return value.Clone(result);
}

using StrictPizzaOrPastaPtr = ::std::unique_ptr<StrictPizzaOrPasta>;

class Union final {
 public:
  static const fidl_type_t* FidlType;

  Union();
  ~Union();

  Union(Union&&);
  Union& operator=(Union&&);

  static Union WithPrimitive(int32_t&&);
  static Union WithStringNeedsConstructor(::std::string&&);
  static Union WithVectorStringAlsoNeedsConstructor(::std::vector<::std::string>&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {

    kPrimitive = 1,                         // 0x1
    kStringNeedsConstructor = 2,            // 0x2
    kVectorStringAlsoNeedsConstructor = 3,  // 0x3
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

  static inline ::std::unique_ptr<Union> New() { return ::std::make_unique<Union>(); }

  void Encode(::fidl::Encoder* encoder, size_t offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, Union* value, size_t offset);
  zx_status_t Clone(Union* result) const;

  bool has_invalid_tag() const {
    return tag_ == Invalid;
  }

  bool is_Primitive() const { return tag_ == ::test::union_::Union::Tag::kPrimitive; }

  int32_t& Primitive() {
    EnsureStorageInitialized(::test::union_::Union::Tag::kPrimitive);
    return Primitive_;
  }

  const int32_t& Primitive() const {
    ZX_ASSERT(is_Primitive());
    return Primitive_;
  }
  Union& set_Primitive(int32_t value);

  bool is_StringNeedsConstructor() const { return tag_ == ::test::union_::Union::Tag::kStringNeedsConstructor; }

  ::std::string& StringNeedsConstructor() {
    EnsureStorageInitialized(::test::union_::Union::Tag::kStringNeedsConstructor);
    return StringNeedsConstructor_;
  }

  const ::std::string& StringNeedsConstructor() const {
    ZX_ASSERT(is_StringNeedsConstructor());
    return StringNeedsConstructor_;
  }
  Union& set_StringNeedsConstructor(::std::string value);

  bool is_VectorStringAlsoNeedsConstructor() const { return tag_ == ::test::union_::Union::Tag::kVectorStringAlsoNeedsConstructor; }

  ::std::vector<::std::string>& VectorStringAlsoNeedsConstructor() {
    EnsureStorageInitialized(::test::union_::Union::Tag::kVectorStringAlsoNeedsConstructor);
    return VectorStringAlsoNeedsConstructor_;
  }

  const ::std::vector<::std::string>& VectorStringAlsoNeedsConstructor() const {
    ZX_ASSERT(is_VectorStringAlsoNeedsConstructor());
    return VectorStringAlsoNeedsConstructor_;
  }
  Union& set_VectorStringAlsoNeedsConstructor(::std::vector<::std::string> value);

  ::test::union_::Union::Tag Which() const {
    return ::test::union_::Union::Tag(tag_);
  }

  // You probably want to use Which() method instead of Ordinal(). Use Ordinal() only when you need
  // access to the raw integral ordinal value.
  fidl_xunion_tag_t Ordinal() const {
    return tag_;
  }

  friend ::fidl::Equality<::test::union_::Union>;

 private:
  void Destroy();
  void EnsureStorageInitialized(::fidl_xunion_tag_t tag);

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::union_::Union::Tag::Invalid);
  union {
    int32_t Primitive_;
    ::std::string StringNeedsConstructor_;
    ::std::vector<::std::string> VectorStringAlsoNeedsConstructor_;
  };
};

inline zx_status_t Clone(const ::test::union_::Union& value,
                         ::test::union_::Union* result) {
  return value.Clone(result);
}

using UnionPtr = ::std::unique_ptr<Union>;

class FlexibleUnion final {
 public:
  static const fidl_type_t* FidlType;

  FlexibleUnion();
  ~FlexibleUnion();

  FlexibleUnion(FlexibleUnion&&);
  FlexibleUnion& operator=(FlexibleUnion&&);

  static FlexibleUnion WithPrimitive(int32_t&&);
  static FlexibleUnion WithStringNeedsConstructor(::std::string&&);
  static FlexibleUnion WithVectorStringAlsoNeedsConstructor(::std::vector<::std::string>&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {
    kUnknown = 0,

    kPrimitive = 1,                         // 0x1
    kStringNeedsConstructor = 2,            // 0x2
    kVectorStringAlsoNeedsConstructor = 3,  // 0x3
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

  static inline ::std::unique_ptr<FlexibleUnion> New() { return ::std::make_unique<FlexibleUnion>(); }

  void Encode(::fidl::Encoder* encoder, size_t offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, FlexibleUnion* value, size_t offset);
  zx_status_t Clone(FlexibleUnion* result) const;

  bool has_invalid_tag() const {
    return tag_ == Invalid;
  }

  bool is_Primitive() const { return tag_ == ::test::union_::FlexibleUnion::Tag::kPrimitive; }

  int32_t& Primitive() {
    EnsureStorageInitialized(::test::union_::FlexibleUnion::Tag::kPrimitive);
    return Primitive_;
  }

  const int32_t& Primitive() const {
    ZX_ASSERT(is_Primitive());
    return Primitive_;
  }
  FlexibleUnion& set_Primitive(int32_t value);

  bool is_StringNeedsConstructor() const { return tag_ == ::test::union_::FlexibleUnion::Tag::kStringNeedsConstructor; }

  ::std::string& StringNeedsConstructor() {
    EnsureStorageInitialized(::test::union_::FlexibleUnion::Tag::kStringNeedsConstructor);
    return StringNeedsConstructor_;
  }

  const ::std::string& StringNeedsConstructor() const {
    ZX_ASSERT(is_StringNeedsConstructor());
    return StringNeedsConstructor_;
  }
  FlexibleUnion& set_StringNeedsConstructor(::std::string value);

  bool is_VectorStringAlsoNeedsConstructor() const { return tag_ == ::test::union_::FlexibleUnion::Tag::kVectorStringAlsoNeedsConstructor; }

  ::std::vector<::std::string>& VectorStringAlsoNeedsConstructor() {
    EnsureStorageInitialized(::test::union_::FlexibleUnion::Tag::kVectorStringAlsoNeedsConstructor);
    return VectorStringAlsoNeedsConstructor_;
  }

  const ::std::vector<::std::string>& VectorStringAlsoNeedsConstructor() const {
    ZX_ASSERT(is_VectorStringAlsoNeedsConstructor());
    return VectorStringAlsoNeedsConstructor_;
  }
  FlexibleUnion& set_VectorStringAlsoNeedsConstructor(::std::vector<::std::string> value);
  FlexibleUnion& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes);

  ::test::union_::FlexibleUnion::Tag Which() const {
    switch (tag_) {
      case ::test::union_::FlexibleUnion::Tag::Invalid:
      case ::test::union_::FlexibleUnion::Tag::kPrimitive:
      case ::test::union_::FlexibleUnion::Tag::kStringNeedsConstructor:
      case ::test::union_::FlexibleUnion::Tag::kVectorStringAlsoNeedsConstructor:
        return ::test::union_::FlexibleUnion::Tag(tag_);
      default:
        return ::test::union_::FlexibleUnion::Tag::kUnknown;
    }
  }

  // You probably want to use Which() method instead of Ordinal(). Use Ordinal() only when you need
  // access to the raw integral ordinal value.
  fidl_xunion_tag_t Ordinal() const {
    return tag_;
  }
  const std::vector<uint8_t>* UnknownBytes() const {
    if (Which() != ::test::union_::FlexibleUnion::Tag::kUnknown) {
      return nullptr;
    }
    return &unknown_data_;
  }

  friend ::fidl::Equality<::test::union_::FlexibleUnion>;

 private:
  void Destroy();
  void EnsureStorageInitialized(::fidl_xunion_tag_t tag);

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::union_::FlexibleUnion::Tag::Invalid);
  union {
    int32_t Primitive_;
    ::std::string StringNeedsConstructor_;
    ::std::vector<::std::string> VectorStringAlsoNeedsConstructor_;
    std::vector<uint8_t> unknown_data_;
  };
};

inline zx_status_t Clone(const ::test::union_::FlexibleUnion& value,
                         ::test::union_::FlexibleUnion* result) {
  return value.Clone(result);
}

using FlexibleUnionPtr = ::std::unique_ptr<FlexibleUnion>;

class StrictUnion final {
 public:
  static const fidl_type_t* FidlType;

  StrictUnion();
  ~StrictUnion();

  StrictUnion(StrictUnion&&);
  StrictUnion& operator=(StrictUnion&&);

  static StrictUnion WithPrimitive(int32_t&&);
  static StrictUnion WithStringNeedsConstructor(::std::string&&);
  static StrictUnion WithVectorStringAlsoNeedsConstructor(::std::vector<::std::string>&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {

    kPrimitive = 1,                         // 0x1
    kStringNeedsConstructor = 2,            // 0x2
    kVectorStringAlsoNeedsConstructor = 3,  // 0x3
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

  static inline ::std::unique_ptr<StrictUnion> New() { return ::std::make_unique<StrictUnion>(); }

  void Encode(::fidl::Encoder* encoder, size_t offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, StrictUnion* value, size_t offset);
  zx_status_t Clone(StrictUnion* result) const;

  bool has_invalid_tag() const {
    return tag_ == Invalid;
  }

  bool is_Primitive() const { return tag_ == ::test::union_::StrictUnion::Tag::kPrimitive; }

  int32_t& Primitive() {
    EnsureStorageInitialized(::test::union_::StrictUnion::Tag::kPrimitive);
    return Primitive_;
  }

  const int32_t& Primitive() const {
    ZX_ASSERT(is_Primitive());
    return Primitive_;
  }
  StrictUnion& set_Primitive(int32_t value);

  bool is_StringNeedsConstructor() const { return tag_ == ::test::union_::StrictUnion::Tag::kStringNeedsConstructor; }

  ::std::string& StringNeedsConstructor() {
    EnsureStorageInitialized(::test::union_::StrictUnion::Tag::kStringNeedsConstructor);
    return StringNeedsConstructor_;
  }

  const ::std::string& StringNeedsConstructor() const {
    ZX_ASSERT(is_StringNeedsConstructor());
    return StringNeedsConstructor_;
  }
  StrictUnion& set_StringNeedsConstructor(::std::string value);

  bool is_VectorStringAlsoNeedsConstructor() const { return tag_ == ::test::union_::StrictUnion::Tag::kVectorStringAlsoNeedsConstructor; }

  ::std::vector<::std::string>& VectorStringAlsoNeedsConstructor() {
    EnsureStorageInitialized(::test::union_::StrictUnion::Tag::kVectorStringAlsoNeedsConstructor);
    return VectorStringAlsoNeedsConstructor_;
  }

  const ::std::vector<::std::string>& VectorStringAlsoNeedsConstructor() const {
    ZX_ASSERT(is_VectorStringAlsoNeedsConstructor());
    return VectorStringAlsoNeedsConstructor_;
  }
  StrictUnion& set_VectorStringAlsoNeedsConstructor(::std::vector<::std::string> value);

  ::test::union_::StrictUnion::Tag Which() const {
    return ::test::union_::StrictUnion::Tag(tag_);
  }

  // You probably want to use Which() method instead of Ordinal(). Use Ordinal() only when you need
  // access to the raw integral ordinal value.
  fidl_xunion_tag_t Ordinal() const {
    return tag_;
  }

  friend ::fidl::Equality<::test::union_::StrictUnion>;

 private:
  void Destroy();
  void EnsureStorageInitialized(::fidl_xunion_tag_t tag);

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::union_::StrictUnion::Tag::Invalid);
  union {
    int32_t Primitive_;
    ::std::string StringNeedsConstructor_;
    ::std::vector<::std::string> VectorStringAlsoNeedsConstructor_;
  };
};

inline zx_status_t Clone(const ::test::union_::StrictUnion& value,
                         ::test::union_::StrictUnion* result) {
  return value.Clone(result);
}

using StrictUnionPtr = ::std::unique_ptr<StrictUnion>;

class FieldCollision final {
 public:
  static const fidl_type_t* FidlType;

  FieldCollision();
  ~FieldCollision();

  FieldCollision(FieldCollision&&);
  FieldCollision& operator=(FieldCollision&&);

  static FieldCollision WithFieldCollisionTag(int32_t&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {

    kFieldCollisionTag = 1,  // 0x1
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

  static inline ::std::unique_ptr<FieldCollision> New() { return ::std::make_unique<FieldCollision>(); }

  void Encode(::fidl::Encoder* encoder, size_t offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, FieldCollision* value, size_t offset);
  zx_status_t Clone(FieldCollision* result) const;

  bool has_invalid_tag() const {
    return tag_ == Invalid;
  }

  bool is_field_collision_tag() const { return tag_ == ::test::union_::FieldCollision::Tag::kFieldCollisionTag; }

  int32_t& field_collision_tag() {
    EnsureStorageInitialized(::test::union_::FieldCollision::Tag::kFieldCollisionTag);
    return field_collision_tag_;
  }

  const int32_t& field_collision_tag() const {
    ZX_ASSERT(is_field_collision_tag());
    return field_collision_tag_;
  }
  FieldCollision& set_field_collision_tag(int32_t value);

  ::test::union_::FieldCollision::Tag Which() const {
    return ::test::union_::FieldCollision::Tag(tag_);
  }

  // You probably want to use Which() method instead of Ordinal(). Use Ordinal() only when you need
  // access to the raw integral ordinal value.
  fidl_xunion_tag_t Ordinal() const {
    return tag_;
  }

  friend ::fidl::Equality<::test::union_::FieldCollision>;

 private:
  void Destroy();
  void EnsureStorageInitialized(::fidl_xunion_tag_t tag);

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::union_::FieldCollision::Tag::Invalid);
  union {
    int32_t field_collision_tag_;
  };
};

inline zx_status_t Clone(const ::test::union_::FieldCollision& value,
                         ::test::union_::FieldCollision* result) {
  return value.Clone(result);
}

using FieldCollisionPtr = ::std::unique_ptr<FieldCollision>;

class ExplicitUnion final {
 public:
  static const fidl_type_t* FidlType;

  ExplicitUnion();
  ~ExplicitUnion();

  ExplicitUnion(ExplicitUnion&&);
  ExplicitUnion& operator=(ExplicitUnion&&);

  static ExplicitUnion WithPrimitive(int32_t&&);
  static ExplicitUnion WithStringNeedsConstructor(::std::string&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {

    kPrimitive = 1,               // 0x1
    kStringNeedsConstructor = 3,  // 0x3
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

  static inline ::std::unique_ptr<ExplicitUnion> New() { return ::std::make_unique<ExplicitUnion>(); }

  void Encode(::fidl::Encoder* encoder, size_t offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, ExplicitUnion* value, size_t offset);
  zx_status_t Clone(ExplicitUnion* result) const;

  bool has_invalid_tag() const {
    return tag_ == Invalid;
  }

  bool is_Primitive() const { return tag_ == ::test::union_::ExplicitUnion::Tag::kPrimitive; }

  int32_t& Primitive() {
    EnsureStorageInitialized(::test::union_::ExplicitUnion::Tag::kPrimitive);
    return Primitive_;
  }

  const int32_t& Primitive() const {
    ZX_ASSERT(is_Primitive());
    return Primitive_;
  }
  ExplicitUnion& set_Primitive(int32_t value);

  bool is_StringNeedsConstructor() const { return tag_ == ::test::union_::ExplicitUnion::Tag::kStringNeedsConstructor; }

  ::std::string& StringNeedsConstructor() {
    EnsureStorageInitialized(::test::union_::ExplicitUnion::Tag::kStringNeedsConstructor);
    return StringNeedsConstructor_;
  }

  const ::std::string& StringNeedsConstructor() const {
    ZX_ASSERT(is_StringNeedsConstructor());
    return StringNeedsConstructor_;
  }
  ExplicitUnion& set_StringNeedsConstructor(::std::string value);

  ::test::union_::ExplicitUnion::Tag Which() const {
    return ::test::union_::ExplicitUnion::Tag(tag_);
  }

  // You probably want to use Which() method instead of Ordinal(). Use Ordinal() only when you need
  // access to the raw integral ordinal value.
  fidl_xunion_tag_t Ordinal() const {
    return tag_;
  }

  friend ::fidl::Equality<::test::union_::ExplicitUnion>;

 private:
  void Destroy();
  void EnsureStorageInitialized(::fidl_xunion_tag_t tag);

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::union_::ExplicitUnion::Tag::Invalid);
  union {
    int32_t Primitive_;
    ::std::string StringNeedsConstructor_;
  };
};

inline zx_status_t Clone(const ::test::union_::ExplicitUnion& value,
                         ::test::union_::ExplicitUnion* result) {
  return value.Clone(result);
}

using ExplicitUnionPtr = ::std::unique_ptr<ExplicitUnion>;

class ReverseOrdinalUnion final {
 public:
  static const fidl_type_t* FidlType;

  ReverseOrdinalUnion();
  ~ReverseOrdinalUnion();

  ReverseOrdinalUnion(ReverseOrdinalUnion&&);
  ReverseOrdinalUnion& operator=(ReverseOrdinalUnion&&);

  static ReverseOrdinalUnion WithFirst(uint32_t&&);
  static ReverseOrdinalUnion WithSecond(uint32_t&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {

    kFirst = 1,   // 0x1
    kSecond = 2,  // 0x2
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

  static inline ::std::unique_ptr<ReverseOrdinalUnion> New() { return ::std::make_unique<ReverseOrdinalUnion>(); }

  void Encode(::fidl::Encoder* encoder, size_t offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, ReverseOrdinalUnion* value, size_t offset);
  zx_status_t Clone(ReverseOrdinalUnion* result) const;

  bool has_invalid_tag() const {
    return tag_ == Invalid;
  }

  bool is_first() const { return tag_ == ::test::union_::ReverseOrdinalUnion::Tag::kFirst; }

  uint32_t& first() {
    EnsureStorageInitialized(::test::union_::ReverseOrdinalUnion::Tag::kFirst);
    return first_;
  }

  const uint32_t& first() const {
    ZX_ASSERT(is_first());
    return first_;
  }
  ReverseOrdinalUnion& set_first(uint32_t value);

  bool is_second() const { return tag_ == ::test::union_::ReverseOrdinalUnion::Tag::kSecond; }

  uint32_t& second() {
    EnsureStorageInitialized(::test::union_::ReverseOrdinalUnion::Tag::kSecond);
    return second_;
  }

  const uint32_t& second() const {
    ZX_ASSERT(is_second());
    return second_;
  }
  ReverseOrdinalUnion& set_second(uint32_t value);

  ::test::union_::ReverseOrdinalUnion::Tag Which() const {
    return ::test::union_::ReverseOrdinalUnion::Tag(tag_);
  }

  // You probably want to use Which() method instead of Ordinal(). Use Ordinal() only when you need
  // access to the raw integral ordinal value.
  fidl_xunion_tag_t Ordinal() const {
    return tag_;
  }

  friend ::fidl::Equality<::test::union_::ReverseOrdinalUnion>;

 private:
  void Destroy();
  void EnsureStorageInitialized(::fidl_xunion_tag_t tag);

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::union_::ReverseOrdinalUnion::Tag::Invalid);
  union {
    uint32_t first_;
    uint32_t second_;
  };
};

inline zx_status_t Clone(const ::test::union_::ReverseOrdinalUnion& value,
                         ::test::union_::ReverseOrdinalUnion* result) {
  return value.Clone(result);
}

using ReverseOrdinalUnionPtr = ::std::unique_ptr<ReverseOrdinalUnion>;

class NullableUnionStruct final {
 public:
  static const fidl_type_t* FidlType;

  ::std::unique_ptr<::test::union_::Union> the_union;

  static inline ::std::unique_ptr<NullableUnionStruct> New() { return ::std::make_unique<NullableUnionStruct>(); }

  void Encode(::fidl::Encoder* _encoder, size_t _offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, NullableUnionStruct* value, size_t _offset);
  zx_status_t Clone(NullableUnionStruct* result) const;
};

inline zx_status_t Clone(const ::test::union_::NullableUnionStruct& _value,
                         ::test::union_::NullableUnionStruct* _result) {
  return _value.Clone(_result);
}

using NullableUnionStructPtr = ::std::unique_ptr<NullableUnionStruct>;

class FlexibleFoo final {
 public:
  static const fidl_type_t* FidlType;

  FlexibleFoo();
  ~FlexibleFoo();

  FlexibleFoo(FlexibleFoo&&);
  FlexibleFoo& operator=(FlexibleFoo&&);

  static FlexibleFoo WithS(::std::string&&);
  static FlexibleFoo WithI(int32_t&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {
    kUnknown = 0,

    kS = 1,  // 0x1
    kI = 2,  // 0x2
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

  static inline ::std::unique_ptr<FlexibleFoo> New() { return ::std::make_unique<FlexibleFoo>(); }

  void Encode(::fidl::Encoder* encoder, size_t offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, FlexibleFoo* value, size_t offset);
  zx_status_t Clone(FlexibleFoo* result) const;

  bool has_invalid_tag() const {
    return tag_ == Invalid;
  }

  bool is_s() const { return tag_ == ::test::union_::FlexibleFoo::Tag::kS; }

  ::std::string& s() {
    EnsureStorageInitialized(::test::union_::FlexibleFoo::Tag::kS);
    return s_;
  }

  const ::std::string& s() const {
    ZX_ASSERT(is_s());
    return s_;
  }
  FlexibleFoo& set_s(::std::string value);

  bool is_i() const { return tag_ == ::test::union_::FlexibleFoo::Tag::kI; }

  int32_t& i() {
    EnsureStorageInitialized(::test::union_::FlexibleFoo::Tag::kI);
    return i_;
  }

  const int32_t& i() const {
    ZX_ASSERT(is_i());
    return i_;
  }
  FlexibleFoo& set_i(int32_t value);
  FlexibleFoo& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes);

  ::test::union_::FlexibleFoo::Tag Which() const {
    switch (tag_) {
      case ::test::union_::FlexibleFoo::Tag::Invalid:
      case ::test::union_::FlexibleFoo::Tag::kS:
      case ::test::union_::FlexibleFoo::Tag::kI:
        return ::test::union_::FlexibleFoo::Tag(tag_);
      default:
        return ::test::union_::FlexibleFoo::Tag::kUnknown;
    }
  }

  // You probably want to use Which() method instead of Ordinal(). Use Ordinal() only when you need
  // access to the raw integral ordinal value.
  fidl_xunion_tag_t Ordinal() const {
    return tag_;
  }
  const std::vector<uint8_t>* UnknownBytes() const {
    if (Which() != ::test::union_::FlexibleFoo::Tag::kUnknown) {
      return nullptr;
    }
    return &unknown_data_;
  }

  friend ::fidl::Equality<::test::union_::FlexibleFoo>;

 private:
  void Destroy();
  void EnsureStorageInitialized(::fidl_xunion_tag_t tag);

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::union_::FlexibleFoo::Tag::Invalid);
  union {
    ::std::string s_;
    int32_t i_;
    std::vector<uint8_t> unknown_data_;
  };
};

inline zx_status_t Clone(const ::test::union_::FlexibleFoo& value,
                         ::test::union_::FlexibleFoo* result) {
  return value.Clone(result);
}

using FlexibleFooPtr = ::std::unique_ptr<FlexibleFoo>;

class StrictFoo final {
 public:
  static const fidl_type_t* FidlType;

  StrictFoo();
  ~StrictFoo();

  StrictFoo(StrictFoo&&);
  StrictFoo& operator=(StrictFoo&&);

  static StrictFoo WithS(::std::string&&);
  static StrictFoo WithI(int32_t&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {

    kS = 1,  // 0x1
    kI = 2,  // 0x2
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

  static inline ::std::unique_ptr<StrictFoo> New() { return ::std::make_unique<StrictFoo>(); }

  void Encode(::fidl::Encoder* encoder, size_t offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, StrictFoo* value, size_t offset);
  zx_status_t Clone(StrictFoo* result) const;

  bool has_invalid_tag() const {
    return tag_ == Invalid;
  }

  bool is_s() const { return tag_ == ::test::union_::StrictFoo::Tag::kS; }

  ::std::string& s() {
    EnsureStorageInitialized(::test::union_::StrictFoo::Tag::kS);
    return s_;
  }

  const ::std::string& s() const {
    ZX_ASSERT(is_s());
    return s_;
  }
  StrictFoo& set_s(::std::string value);

  bool is_i() const { return tag_ == ::test::union_::StrictFoo::Tag::kI; }

  int32_t& i() {
    EnsureStorageInitialized(::test::union_::StrictFoo::Tag::kI);
    return i_;
  }

  const int32_t& i() const {
    ZX_ASSERT(is_i());
    return i_;
  }
  StrictFoo& set_i(int32_t value);

  ::test::union_::StrictFoo::Tag Which() const {
    return ::test::union_::StrictFoo::Tag(tag_);
  }

  // You probably want to use Which() method instead of Ordinal(). Use Ordinal() only when you need
  // access to the raw integral ordinal value.
  fidl_xunion_tag_t Ordinal() const {
    return tag_;
  }

  friend ::fidl::Equality<::test::union_::StrictFoo>;

 private:
  void Destroy();
  void EnsureStorageInitialized(::fidl_xunion_tag_t tag);

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::union_::StrictFoo::Tag::Invalid);
  union {
    ::std::string s_;
    int32_t i_;
  };
};

inline zx_status_t Clone(const ::test::union_::StrictFoo& value,
                         ::test::union_::StrictFoo* result) {
  return value.Clone(result);
}

using StrictFooPtr = ::std::unique_ptr<StrictFoo>;

class ExplicitFoo final {
 public:
  static const fidl_type_t* FidlType;

  ExplicitFoo();
  ~ExplicitFoo();

  ExplicitFoo(ExplicitFoo&&);
  ExplicitFoo& operator=(ExplicitFoo&&);

  static ExplicitFoo WithI(int32_t&&);
  static ExplicitFoo WithS(::std::string&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {
    kUnknown = 0,

    kI = 1,  // 0x1
    kS = 2,  // 0x2
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

  static inline ::std::unique_ptr<ExplicitFoo> New() { return ::std::make_unique<ExplicitFoo>(); }

  void Encode(::fidl::Encoder* encoder, size_t offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, ExplicitFoo* value, size_t offset);
  zx_status_t Clone(ExplicitFoo* result) const;

  bool has_invalid_tag() const {
    return tag_ == Invalid;
  }

  bool is_i() const { return tag_ == ::test::union_::ExplicitFoo::Tag::kI; }

  int32_t& i() {
    EnsureStorageInitialized(::test::union_::ExplicitFoo::Tag::kI);
    return i_;
  }

  const int32_t& i() const {
    ZX_ASSERT(is_i());
    return i_;
  }
  ExplicitFoo& set_i(int32_t value);

  bool is_s() const { return tag_ == ::test::union_::ExplicitFoo::Tag::kS; }

  ::std::string& s() {
    EnsureStorageInitialized(::test::union_::ExplicitFoo::Tag::kS);
    return s_;
  }

  const ::std::string& s() const {
    ZX_ASSERT(is_s());
    return s_;
  }
  ExplicitFoo& set_s(::std::string value);
  ExplicitFoo& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes);

  ::test::union_::ExplicitFoo::Tag Which() const {
    switch (tag_) {
      case ::test::union_::ExplicitFoo::Tag::Invalid:
      case ::test::union_::ExplicitFoo::Tag::kI:
      case ::test::union_::ExplicitFoo::Tag::kS:
        return ::test::union_::ExplicitFoo::Tag(tag_);
      default:
        return ::test::union_::ExplicitFoo::Tag::kUnknown;
    }
  }

  // You probably want to use Which() method instead of Ordinal(). Use Ordinal() only when you need
  // access to the raw integral ordinal value.
  fidl_xunion_tag_t Ordinal() const {
    return tag_;
  }
  const std::vector<uint8_t>* UnknownBytes() const {
    if (Which() != ::test::union_::ExplicitFoo::Tag::kUnknown) {
      return nullptr;
    }
    return &unknown_data_;
  }

  friend ::fidl::Equality<::test::union_::ExplicitFoo>;

 private:
  void Destroy();
  void EnsureStorageInitialized(::fidl_xunion_tag_t tag);

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::union_::ExplicitFoo::Tag::Invalid);
  union {
    int32_t i_;
    ::std::string s_;
    std::vector<uint8_t> unknown_data_;
  };
};

inline zx_status_t Clone(const ::test::union_::ExplicitFoo& value,
                         ::test::union_::ExplicitFoo* result) {
  return value.Clone(result);
}

using ExplicitFooPtr = ::std::unique_ptr<ExplicitFoo>;

class ExplicitStrictFoo final {
 public:
  static const fidl_type_t* FidlType;

  ExplicitStrictFoo();
  ~ExplicitStrictFoo();

  ExplicitStrictFoo(ExplicitStrictFoo&&);
  ExplicitStrictFoo& operator=(ExplicitStrictFoo&&);

  static ExplicitStrictFoo WithI(int32_t&&);
  static ExplicitStrictFoo WithS(::std::string&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {

    kI = 2,  // 0x2
    kS = 3,  // 0x3
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

  static inline ::std::unique_ptr<ExplicitStrictFoo> New() { return ::std::make_unique<ExplicitStrictFoo>(); }

  void Encode(::fidl::Encoder* encoder, size_t offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, ExplicitStrictFoo* value, size_t offset);
  zx_status_t Clone(ExplicitStrictFoo* result) const;

  bool has_invalid_tag() const {
    return tag_ == Invalid;
  }

  bool is_i() const { return tag_ == ::test::union_::ExplicitStrictFoo::Tag::kI; }

  int32_t& i() {
    EnsureStorageInitialized(::test::union_::ExplicitStrictFoo::Tag::kI);
    return i_;
  }

  const int32_t& i() const {
    ZX_ASSERT(is_i());
    return i_;
  }
  ExplicitStrictFoo& set_i(int32_t value);

  bool is_s() const { return tag_ == ::test::union_::ExplicitStrictFoo::Tag::kS; }

  ::std::string& s() {
    EnsureStorageInitialized(::test::union_::ExplicitStrictFoo::Tag::kS);
    return s_;
  }

  const ::std::string& s() const {
    ZX_ASSERT(is_s());
    return s_;
  }
  ExplicitStrictFoo& set_s(::std::string value);

  ::test::union_::ExplicitStrictFoo::Tag Which() const {
    return ::test::union_::ExplicitStrictFoo::Tag(tag_);
  }

  // You probably want to use Which() method instead of Ordinal(). Use Ordinal() only when you need
  // access to the raw integral ordinal value.
  fidl_xunion_tag_t Ordinal() const {
    return tag_;
  }

  friend ::fidl::Equality<::test::union_::ExplicitStrictFoo>;

 private:
  void Destroy();
  void EnsureStorageInitialized(::fidl_xunion_tag_t tag);

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::union_::ExplicitStrictFoo::Tag::Invalid);
  union {
    int32_t i_;
    ::std::string s_;
  };
};

inline zx_status_t Clone(const ::test::union_::ExplicitStrictFoo& value,
                         ::test::union_::ExplicitStrictFoo* result) {
  return value.Clone(result);
}

using ExplicitStrictFooPtr = ::std::unique_ptr<ExplicitStrictFoo>;

class OlderSimpleUnion final {
 public:
  static const fidl_type_t* FidlType;

  OlderSimpleUnion();
  ~OlderSimpleUnion();

  OlderSimpleUnion(OlderSimpleUnion&&);
  OlderSimpleUnion& operator=(OlderSimpleUnion&&);

  static OlderSimpleUnion WithI(int64_t&&);
  static OlderSimpleUnion WithF(float&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {
    kUnknown = 0,

    kI = 1,  // 0x1
    kF = 2,  // 0x2
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

  static inline ::std::unique_ptr<OlderSimpleUnion> New() { return ::std::make_unique<OlderSimpleUnion>(); }

  void Encode(::fidl::Encoder* encoder, size_t offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, OlderSimpleUnion* value, size_t offset);
  zx_status_t Clone(OlderSimpleUnion* result) const;

  bool has_invalid_tag() const {
    return tag_ == Invalid;
  }

  bool is_i() const { return tag_ == ::test::union_::OlderSimpleUnion::Tag::kI; }

  int64_t& i() {
    EnsureStorageInitialized(::test::union_::OlderSimpleUnion::Tag::kI);
    return i_;
  }

  const int64_t& i() const {
    ZX_ASSERT(is_i());
    return i_;
  }
  OlderSimpleUnion& set_i(int64_t value);

  bool is_f() const { return tag_ == ::test::union_::OlderSimpleUnion::Tag::kF; }

  float& f() {
    EnsureStorageInitialized(::test::union_::OlderSimpleUnion::Tag::kF);
    return f_;
  }

  const float& f() const {
    ZX_ASSERT(is_f());
    return f_;
  }
  OlderSimpleUnion& set_f(float value);
  OlderSimpleUnion& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes);

  ::test::union_::OlderSimpleUnion::Tag Which() const {
    switch (tag_) {
      case ::test::union_::OlderSimpleUnion::Tag::Invalid:
      case ::test::union_::OlderSimpleUnion::Tag::kI:
      case ::test::union_::OlderSimpleUnion::Tag::kF:
        return ::test::union_::OlderSimpleUnion::Tag(tag_);
      default:
        return ::test::union_::OlderSimpleUnion::Tag::kUnknown;
    }
  }

  // You probably want to use Which() method instead of Ordinal(). Use Ordinal() only when you need
  // access to the raw integral ordinal value.
  fidl_xunion_tag_t Ordinal() const {
    return tag_;
  }
  const std::vector<uint8_t>* UnknownBytes() const {
    if (Which() != ::test::union_::OlderSimpleUnion::Tag::kUnknown) {
      return nullptr;
    }
    return &unknown_data_;
  }

  friend ::fidl::Equality<::test::union_::OlderSimpleUnion>;

 private:
  void Destroy();
  void EnsureStorageInitialized(::fidl_xunion_tag_t tag);

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::union_::OlderSimpleUnion::Tag::Invalid);
  union {
    int64_t i_;
    float f_;
    std::vector<uint8_t> unknown_data_;
  };
};

inline zx_status_t Clone(const ::test::union_::OlderSimpleUnion& value,
                         ::test::union_::OlderSimpleUnion* result) {
  return value.Clone(result);
}

using OlderSimpleUnionPtr = ::std::unique_ptr<OlderSimpleUnion>;

class NewerSimpleUnion final {
 public:
  static const fidl_type_t* FidlType;

  NewerSimpleUnion();
  ~NewerSimpleUnion();

  NewerSimpleUnion(NewerSimpleUnion&&);
  NewerSimpleUnion& operator=(NewerSimpleUnion&&);

  static NewerSimpleUnion WithI(int64_t&&);
  static NewerSimpleUnion WithS(::std::string&&);
  static NewerSimpleUnion WithV(::std::vector<::std::string>&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {
    kUnknown = 0,

    kI = 1,  // 0x1
    kS = 2,  // 0x2
    kV = 3,  // 0x3
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

  static inline ::std::unique_ptr<NewerSimpleUnion> New() { return ::std::make_unique<NewerSimpleUnion>(); }

  void Encode(::fidl::Encoder* encoder, size_t offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, NewerSimpleUnion* value, size_t offset);
  zx_status_t Clone(NewerSimpleUnion* result) const;

  bool has_invalid_tag() const {
    return tag_ == Invalid;
  }

  bool is_i() const { return tag_ == ::test::union_::NewerSimpleUnion::Tag::kI; }

  int64_t& i() {
    EnsureStorageInitialized(::test::union_::NewerSimpleUnion::Tag::kI);
    return i_;
  }

  const int64_t& i() const {
    ZX_ASSERT(is_i());
    return i_;
  }
  NewerSimpleUnion& set_i(int64_t value);

  bool is_s() const { return tag_ == ::test::union_::NewerSimpleUnion::Tag::kS; }

  ::std::string& s() {
    EnsureStorageInitialized(::test::union_::NewerSimpleUnion::Tag::kS);
    return s_;
  }

  const ::std::string& s() const {
    ZX_ASSERT(is_s());
    return s_;
  }
  NewerSimpleUnion& set_s(::std::string value);

  bool is_v() const { return tag_ == ::test::union_::NewerSimpleUnion::Tag::kV; }

  ::std::vector<::std::string>& v() {
    EnsureStorageInitialized(::test::union_::NewerSimpleUnion::Tag::kV);
    return v_;
  }

  const ::std::vector<::std::string>& v() const {
    ZX_ASSERT(is_v());
    return v_;
  }
  NewerSimpleUnion& set_v(::std::vector<::std::string> value);
  NewerSimpleUnion& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes);

  ::test::union_::NewerSimpleUnion::Tag Which() const {
    switch (tag_) {
      case ::test::union_::NewerSimpleUnion::Tag::Invalid:
      case ::test::union_::NewerSimpleUnion::Tag::kI:
      case ::test::union_::NewerSimpleUnion::Tag::kS:
      case ::test::union_::NewerSimpleUnion::Tag::kV:
        return ::test::union_::NewerSimpleUnion::Tag(tag_);
      default:
        return ::test::union_::NewerSimpleUnion::Tag::kUnknown;
    }
  }

  // You probably want to use Which() method instead of Ordinal(). Use Ordinal() only when you need
  // access to the raw integral ordinal value.
  fidl_xunion_tag_t Ordinal() const {
    return tag_;
  }
  const std::vector<uint8_t>* UnknownBytes() const {
    if (Which() != ::test::union_::NewerSimpleUnion::Tag::kUnknown) {
      return nullptr;
    }
    return &unknown_data_;
  }

  friend ::fidl::Equality<::test::union_::NewerSimpleUnion>;

 private:
  void Destroy();
  void EnsureStorageInitialized(::fidl_xunion_tag_t tag);

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::union_::NewerSimpleUnion::Tag::Invalid);
  union {
    int64_t i_;
    ::std::string s_;
    ::std::vector<::std::string> v_;
    std::vector<uint8_t> unknown_data_;
  };
};

inline zx_status_t Clone(const ::test::union_::NewerSimpleUnion& value,
                         ::test::union_::NewerSimpleUnion* result) {
  return value.Clone(result);
}

using NewerSimpleUnionPtr = ::std::unique_ptr<NewerSimpleUnion>;

class StrictSimpleUnion final {
 public:
  static const fidl_type_t* FidlType;

  StrictSimpleUnion();
  ~StrictSimpleUnion();

  StrictSimpleUnion(StrictSimpleUnion&&);
  StrictSimpleUnion& operator=(StrictSimpleUnion&&);

  static StrictSimpleUnion WithI(int32_t&&);
  static StrictSimpleUnion WithF(float&&);
  static StrictSimpleUnion WithS(::std::string&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {

    kI = 1,  // 0x1
    kF = 2,  // 0x2
    kS = 3,  // 0x3
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

  static inline ::std::unique_ptr<StrictSimpleUnion> New() { return ::std::make_unique<StrictSimpleUnion>(); }

  void Encode(::fidl::Encoder* encoder, size_t offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, StrictSimpleUnion* value, size_t offset);
  zx_status_t Clone(StrictSimpleUnion* result) const;

  bool has_invalid_tag() const {
    return tag_ == Invalid;
  }

  bool is_i() const { return tag_ == ::test::union_::StrictSimpleUnion::Tag::kI; }

  int32_t& i() {
    EnsureStorageInitialized(::test::union_::StrictSimpleUnion::Tag::kI);
    return i_;
  }

  const int32_t& i() const {
    ZX_ASSERT(is_i());
    return i_;
  }
  StrictSimpleUnion& set_i(int32_t value);

  bool is_f() const { return tag_ == ::test::union_::StrictSimpleUnion::Tag::kF; }

  float& f() {
    EnsureStorageInitialized(::test::union_::StrictSimpleUnion::Tag::kF);
    return f_;
  }

  const float& f() const {
    ZX_ASSERT(is_f());
    return f_;
  }
  StrictSimpleUnion& set_f(float value);

  bool is_s() const { return tag_ == ::test::union_::StrictSimpleUnion::Tag::kS; }

  ::std::string& s() {
    EnsureStorageInitialized(::test::union_::StrictSimpleUnion::Tag::kS);
    return s_;
  }

  const ::std::string& s() const {
    ZX_ASSERT(is_s());
    return s_;
  }
  StrictSimpleUnion& set_s(::std::string value);

  ::test::union_::StrictSimpleUnion::Tag Which() const {
    return ::test::union_::StrictSimpleUnion::Tag(tag_);
  }

  // You probably want to use Which() method instead of Ordinal(). Use Ordinal() only when you need
  // access to the raw integral ordinal value.
  fidl_xunion_tag_t Ordinal() const {
    return tag_;
  }

  friend ::fidl::Equality<::test::union_::StrictSimpleUnion>;

 private:
  void Destroy();
  void EnsureStorageInitialized(::fidl_xunion_tag_t tag);

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::union_::StrictSimpleUnion::Tag::Invalid);
  union {
    int32_t i_;
    float f_;
    ::std::string s_;
  };
};

inline zx_status_t Clone(const ::test::union_::StrictSimpleUnion& value,
                         ::test::union_::StrictSimpleUnion* result) {
  return value.Clone(result);
}

using StrictSimpleUnionPtr = ::std::unique_ptr<StrictSimpleUnion>;

class Empty final {
 public:
  static const fidl_type_t* FidlType;

  uint8_t __reserved = 0u;

  static inline ::std::unique_ptr<Empty> New() { return ::std::make_unique<Empty>(); }

  void Encode(::fidl::Encoder* _encoder, size_t _offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, Empty* value, size_t _offset);
  zx_status_t Clone(Empty* result) const;
};

inline zx_status_t Clone(const ::test::union_::Empty& _value,
                         ::test::union_::Empty* _result) {
  return _value.Clone(_result);
}

using EmptyPtr = ::std::unique_ptr<Empty>;

class UnionContainingEmptyStruct final {
 public:
  static const fidl_type_t* FidlType;

  UnionContainingEmptyStruct();
  ~UnionContainingEmptyStruct();

  UnionContainingEmptyStruct(UnionContainingEmptyStruct&&);
  UnionContainingEmptyStruct& operator=(UnionContainingEmptyStruct&&);

  static UnionContainingEmptyStruct WithEmpty(::test::union_::Empty&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {
    kUnknown = 0,

    kEmpty = 1,  // 0x1
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

  static inline ::std::unique_ptr<UnionContainingEmptyStruct> New() { return ::std::make_unique<UnionContainingEmptyStruct>(); }

  void Encode(::fidl::Encoder* encoder, size_t offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, UnionContainingEmptyStruct* value, size_t offset);
  zx_status_t Clone(UnionContainingEmptyStruct* result) const;

  bool has_invalid_tag() const {
    return tag_ == Invalid;
  }

  bool is_empty() const { return tag_ == ::test::union_::UnionContainingEmptyStruct::Tag::kEmpty; }

  ::test::union_::Empty& empty() {
    EnsureStorageInitialized(::test::union_::UnionContainingEmptyStruct::Tag::kEmpty);
    return empty_;
  }

  const ::test::union_::Empty& empty() const {
    ZX_ASSERT(is_empty());
    return empty_;
  }
  UnionContainingEmptyStruct& set_empty(::test::union_::Empty value);
  UnionContainingEmptyStruct& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes);

  ::test::union_::UnionContainingEmptyStruct::Tag Which() const {
    switch (tag_) {
      case ::test::union_::UnionContainingEmptyStruct::Tag::Invalid:
      case ::test::union_::UnionContainingEmptyStruct::Tag::kEmpty:
        return ::test::union_::UnionContainingEmptyStruct::Tag(tag_);
      default:
        return ::test::union_::UnionContainingEmptyStruct::Tag::kUnknown;
    }
  }

  // You probably want to use Which() method instead of Ordinal(). Use Ordinal() only when you need
  // access to the raw integral ordinal value.
  fidl_xunion_tag_t Ordinal() const {
    return tag_;
  }
  const std::vector<uint8_t>* UnknownBytes() const {
    if (Which() != ::test::union_::UnionContainingEmptyStruct::Tag::kUnknown) {
      return nullptr;
    }
    return &unknown_data_;
  }

  friend ::fidl::Equality<::test::union_::UnionContainingEmptyStruct>;

 private:
  void Destroy();
  void EnsureStorageInitialized(::fidl_xunion_tag_t tag);

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::union_::UnionContainingEmptyStruct::Tag::Invalid);
  union {
    ::test::union_::Empty empty_;
    std::vector<uint8_t> unknown_data_;
  };
};

inline zx_status_t Clone(const ::test::union_::UnionContainingEmptyStruct& value,
                         ::test::union_::UnionContainingEmptyStruct* result) {
  return value.Clone(result);
}

using UnionContainingEmptyStructPtr = ::std::unique_ptr<UnionContainingEmptyStruct>;

class StrictBoundedUnion final {
 public:
  static const fidl_type_t* FidlType;

  StrictBoundedUnion();
  ~StrictBoundedUnion();

  StrictBoundedUnion(StrictBoundedUnion&&);
  StrictBoundedUnion& operator=(StrictBoundedUnion&&);

  static StrictBoundedUnion WithV(::std::vector<uint8_t>&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {

    kV = 1,  // 0x1
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

  static inline ::std::unique_ptr<StrictBoundedUnion> New() { return ::std::make_unique<StrictBoundedUnion>(); }

  void Encode(::fidl::Encoder* encoder, size_t offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, StrictBoundedUnion* value, size_t offset);
  zx_status_t Clone(StrictBoundedUnion* result) const;

  bool has_invalid_tag() const {
    return tag_ == Invalid;
  }

  bool is_v() const { return tag_ == ::test::union_::StrictBoundedUnion::Tag::kV; }

  ::std::vector<uint8_t>& v() {
    EnsureStorageInitialized(::test::union_::StrictBoundedUnion::Tag::kV);
    return v_;
  }

  const ::std::vector<uint8_t>& v() const {
    ZX_ASSERT(is_v());
    return v_;
  }
  StrictBoundedUnion& set_v(::std::vector<uint8_t> value);

  ::test::union_::StrictBoundedUnion::Tag Which() const {
    return ::test::union_::StrictBoundedUnion::Tag(tag_);
  }

  // You probably want to use Which() method instead of Ordinal(). Use Ordinal() only when you need
  // access to the raw integral ordinal value.
  fidl_xunion_tag_t Ordinal() const {
    return tag_;
  }

  friend ::fidl::Equality<::test::union_::StrictBoundedUnion>;

 private:
  void Destroy();
  void EnsureStorageInitialized(::fidl_xunion_tag_t tag);

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::union_::StrictBoundedUnion::Tag::Invalid);
  union {
    ::std::vector<uint8_t> v_;
  };
};

inline zx_status_t Clone(const ::test::union_::StrictBoundedUnion& value,
                         ::test::union_::StrictBoundedUnion* result) {
  return value.Clone(result);
}

using StrictBoundedUnionPtr = ::std::unique_ptr<StrictBoundedUnion>;

class TestProtocolStrictUnionHenceResponseMayBeStackAllocatedResponse final {
 public:
  static const fidl_type_t* FidlType;

  ::test::union_::StrictBoundedUnion xu;

  static inline ::std::unique_ptr<TestProtocolStrictUnionHenceResponseMayBeStackAllocatedResponse> New() { return ::std::make_unique<TestProtocolStrictUnionHenceResponseMayBeStackAllocatedResponse>(); }

  void Encode(::fidl::Encoder* _encoder, size_t _offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, TestProtocolStrictUnionHenceResponseMayBeStackAllocatedResponse* value, size_t _offset);
  zx_status_t Clone(TestProtocolStrictUnionHenceResponseMayBeStackAllocatedResponse* result) const;
};

inline zx_status_t Clone(const ::test::union_::TestProtocolStrictUnionHenceResponseMayBeStackAllocatedResponse& _value,
                         ::test::union_::TestProtocolStrictUnionHenceResponseMayBeStackAllocatedResponse* _result) {
  return _value.Clone(_result);
}

using TestProtocolStrictUnionHenceResponseMayBeStackAllocatedResponsePtr = ::std::unique_ptr<TestProtocolStrictUnionHenceResponseMayBeStackAllocatedResponse>;

class TestProtocolFlexibleUnionHenceResponseMustBeHeapAllocatedResponse final {
 public:
  static const fidl_type_t* FidlType;

  ::test::union_::OlderSimpleUnion xu;

  static inline ::std::unique_ptr<TestProtocolFlexibleUnionHenceResponseMustBeHeapAllocatedResponse> New() { return ::std::make_unique<TestProtocolFlexibleUnionHenceResponseMustBeHeapAllocatedResponse>(); }

  void Encode(::fidl::Encoder* _encoder, size_t _offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, TestProtocolFlexibleUnionHenceResponseMustBeHeapAllocatedResponse* value, size_t _offset);
  zx_status_t Clone(TestProtocolFlexibleUnionHenceResponseMustBeHeapAllocatedResponse* result) const;
};

inline zx_status_t Clone(const ::test::union_::TestProtocolFlexibleUnionHenceResponseMustBeHeapAllocatedResponse& _value,
                         ::test::union_::TestProtocolFlexibleUnionHenceResponseMustBeHeapAllocatedResponse* _result) {
  return _value.Clone(_result);
}

using TestProtocolFlexibleUnionHenceResponseMustBeHeapAllocatedResponsePtr = ::std::unique_ptr<TestProtocolFlexibleUnionHenceResponseMustBeHeapAllocatedResponse>;

#ifdef __Fuchsia__

class TestProtocol_RequestEncoder {
 public:
  static ::fidl::HLCPPOutgoingMessage StrictUnionHenceResponseMayBeStackAllocated(::fidl::MessageEncoder* _encoder) {
    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage FlexibleUnionHenceResponseMustBeHeapAllocated(::fidl::MessageEncoder* _encoder) {
    return _encoder->GetMessage();
  }
};
namespace _internal {
__LOCAL extern "C" const fidl_type_t test_union_TestProtocolStrictUnionHenceResponseMayBeStackAllocatedResponseTable;

__LOCAL extern "C" const fidl_type_t test_union_TestProtocolFlexibleUnionHenceResponseMustBeHeapAllocatedResponseTable;

}  // namespace _internal

class TestProtocol_ResponseEncoder {
 public:
  static ::fidl::HLCPPOutgoingMessage StrictUnionHenceResponseMayBeStackAllocated(::fidl::MessageEncoder* _encoder, ::test::union_::StrictBoundedUnion* xu) {
    _encoder->Alloc(16);
    ::fidl::Encode(_encoder, xu, 0 + sizeof(fidl_message_header_t));

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage FlexibleUnionHenceResponseMustBeHeapAllocated(::fidl::MessageEncoder* _encoder, ::test::union_::OlderSimpleUnion* xu) {
    _encoder->Alloc(16);
    ::fidl::Encode(_encoder, xu, 0 + sizeof(fidl_message_header_t));

    return _encoder->GetMessage();
  }
};

#endif  // __Fuchsia__

class StructWithNullableUnion final {
 public:
  static const fidl_type_t* FidlType;

  ::std::unique_ptr<::test::union_::OlderSimpleUnion> x1;

  static inline ::std::unique_ptr<StructWithNullableUnion> New() { return ::std::make_unique<StructWithNullableUnion>(); }

  void Encode(::fidl::Encoder* _encoder, size_t _offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, StructWithNullableUnion* value, size_t _offset);
  zx_status_t Clone(StructWithNullableUnion* result) const;
};

inline zx_status_t Clone(const ::test::union_::StructWithNullableUnion& _value,
                         ::test::union_::StructWithNullableUnion* _result) {
  return _value.Clone(_result);
}

using StructWithNullableUnionPtr = ::std::unique_ptr<StructWithNullableUnion>;

class ExplicitFlexibleUnion final {
 public:
  static const fidl_type_t* FidlType;

  ExplicitFlexibleUnion();
  ~ExplicitFlexibleUnion();

  ExplicitFlexibleUnion(ExplicitFlexibleUnion&&);
  ExplicitFlexibleUnion& operator=(ExplicitFlexibleUnion&&);

  static ExplicitFlexibleUnion WithI(int64_t&&);
  static ExplicitFlexibleUnion WithF(float&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {
    kUnknown = 0,

    kI = 1,  // 0x1
    kF = 4,  // 0x4
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

  static inline ::std::unique_ptr<ExplicitFlexibleUnion> New() { return ::std::make_unique<ExplicitFlexibleUnion>(); }

  void Encode(::fidl::Encoder* encoder, size_t offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, ExplicitFlexibleUnion* value, size_t offset);
  zx_status_t Clone(ExplicitFlexibleUnion* result) const;

  bool has_invalid_tag() const {
    return tag_ == Invalid;
  }

  bool is_i() const { return tag_ == ::test::union_::ExplicitFlexibleUnion::Tag::kI; }

  int64_t& i() {
    EnsureStorageInitialized(::test::union_::ExplicitFlexibleUnion::Tag::kI);
    return i_;
  }

  const int64_t& i() const {
    ZX_ASSERT(is_i());
    return i_;
  }
  ExplicitFlexibleUnion& set_i(int64_t value);

  bool is_f() const { return tag_ == ::test::union_::ExplicitFlexibleUnion::Tag::kF; }

  float& f() {
    EnsureStorageInitialized(::test::union_::ExplicitFlexibleUnion::Tag::kF);
    return f_;
  }

  const float& f() const {
    ZX_ASSERT(is_f());
    return f_;
  }
  ExplicitFlexibleUnion& set_f(float value);
  ExplicitFlexibleUnion& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes);

  ::test::union_::ExplicitFlexibleUnion::Tag Which() const {
    switch (tag_) {
      case ::test::union_::ExplicitFlexibleUnion::Tag::Invalid:
      case ::test::union_::ExplicitFlexibleUnion::Tag::kI:
      case ::test::union_::ExplicitFlexibleUnion::Tag::kF:
        return ::test::union_::ExplicitFlexibleUnion::Tag(tag_);
      default:
        return ::test::union_::ExplicitFlexibleUnion::Tag::kUnknown;
    }
  }

  // You probably want to use Which() method instead of Ordinal(). Use Ordinal() only when you need
  // access to the raw integral ordinal value.
  fidl_xunion_tag_t Ordinal() const {
    return tag_;
  }
  const std::vector<uint8_t>* UnknownBytes() const {
    if (Which() != ::test::union_::ExplicitFlexibleUnion::Tag::kUnknown) {
      return nullptr;
    }
    return &unknown_data_;
  }

  friend ::fidl::Equality<::test::union_::ExplicitFlexibleUnion>;

 private:
  void Destroy();
  void EnsureStorageInitialized(::fidl_xunion_tag_t tag);

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::union_::ExplicitFlexibleUnion::Tag::Invalid);
  union {
    int64_t i_;
    float f_;
    std::vector<uint8_t> unknown_data_;
  };
};

inline zx_status_t Clone(const ::test::union_::ExplicitFlexibleUnion& value,
                         ::test::union_::ExplicitFlexibleUnion* result) {
  return value.Clone(result);
}

using ExplicitFlexibleUnionPtr = ::std::unique_ptr<ExplicitFlexibleUnion>;

class UnionSandwich final {
 public:
  static const fidl_type_t* FidlType;

  uint32_t a{};

  ::test::union_::ExplicitFlexibleUnion u;

  uint32_t b{};

  static inline ::std::unique_ptr<UnionSandwich> New() { return ::std::make_unique<UnionSandwich>(); }

  void Encode(::fidl::Encoder* _encoder, size_t _offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, UnionSandwich* value, size_t _offset);
  zx_status_t Clone(UnionSandwich* result) const;
};

inline zx_status_t Clone(const ::test::union_::UnionSandwich& _value,
                         ::test::union_::UnionSandwich* _result) {
  return _value.Clone(_result);
}

using UnionSandwichPtr = ::std::unique_ptr<UnionSandwich>;

class UnionWithAttributes final {
 public:
  static const fidl_type_t* FidlType;

  UnionWithAttributes();
  ~UnionWithAttributes();

  UnionWithAttributes(UnionWithAttributes&&);
  UnionWithAttributes& operator=(UnionWithAttributes&&);

  static UnionWithAttributes WithX(int64_t&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {
    kUnknown = 0,

    kX = 1,  // 0x1
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

  static inline ::std::unique_ptr<UnionWithAttributes> New() { return ::std::make_unique<UnionWithAttributes>(); }

  void Encode(::fidl::Encoder* encoder, size_t offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, UnionWithAttributes* value, size_t offset);
  zx_status_t Clone(UnionWithAttributes* result) const;

  bool has_invalid_tag() const {
    return tag_ == Invalid;
  }

  bool is_x() const { return tag_ == ::test::union_::UnionWithAttributes::Tag::kX; }

  int64_t& x() {
    EnsureStorageInitialized(::test::union_::UnionWithAttributes::Tag::kX);
    return x_;
  }

  const int64_t& x() const {
    ZX_ASSERT(is_x());
    return x_;
  }
  UnionWithAttributes& set_x(int64_t value);
  UnionWithAttributes& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes);

  ::test::union_::UnionWithAttributes::Tag Which() const {
    switch (tag_) {
      case ::test::union_::UnionWithAttributes::Tag::Invalid:
      case ::test::union_::UnionWithAttributes::Tag::kX:
        return ::test::union_::UnionWithAttributes::Tag(tag_);
      default:
        return ::test::union_::UnionWithAttributes::Tag::kUnknown;
    }
  }

  // You probably want to use Which() method instead of Ordinal(). Use Ordinal() only when you need
  // access to the raw integral ordinal value.
  fidl_xunion_tag_t Ordinal() const {
    return tag_;
  }
  const std::vector<uint8_t>* UnknownBytes() const {
    if (Which() != ::test::union_::UnionWithAttributes::Tag::kUnknown) {
      return nullptr;
    }
    return &unknown_data_;
  }

  friend ::fidl::Equality<::test::union_::UnionWithAttributes>;

 private:
  void Destroy();
  void EnsureStorageInitialized(::fidl_xunion_tag_t tag);

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::union_::UnionWithAttributes::Tag::Invalid);
  union {
    int64_t x_;
    std::vector<uint8_t> unknown_data_;
  };
};

inline zx_status_t Clone(const ::test::union_::UnionWithAttributes& value,
                         ::test::union_::UnionWithAttributes* result) {
  return value.Clone(result);
}

using UnionWithAttributesPtr = ::std::unique_ptr<UnionWithAttributes>;

class EmptyFlexibleUnion final {
 public:
  static const fidl_type_t* FidlType;

  EmptyFlexibleUnion();
  ~EmptyFlexibleUnion();

  EmptyFlexibleUnion(EmptyFlexibleUnion&&);
  EmptyFlexibleUnion& operator=(EmptyFlexibleUnion&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {
    kUnknown = 0,

    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

  static inline ::std::unique_ptr<EmptyFlexibleUnion> New() { return ::std::make_unique<EmptyFlexibleUnion>(); }

  void Encode(::fidl::Encoder* encoder, size_t offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, EmptyFlexibleUnion* value, size_t offset);
  zx_status_t Clone(EmptyFlexibleUnion* result) const;

  bool has_invalid_tag() const {
    return tag_ == Invalid;
  }
  EmptyFlexibleUnion& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes);

  ::test::union_::EmptyFlexibleUnion::Tag Which() const {
    switch (tag_) {
      case ::test::union_::EmptyFlexibleUnion::Tag::Invalid:
        return ::test::union_::EmptyFlexibleUnion::Tag(tag_);
      default:
        return ::test::union_::EmptyFlexibleUnion::Tag::kUnknown;
    }
  }

  // You probably want to use Which() method instead of Ordinal(). Use Ordinal() only when you need
  // access to the raw integral ordinal value.
  fidl_xunion_tag_t Ordinal() const {
    return tag_;
  }
  const std::vector<uint8_t>* UnknownBytes() const {
    if (Which() != ::test::union_::EmptyFlexibleUnion::Tag::kUnknown) {
      return nullptr;
    }
    return &unknown_data_;
  }

  friend ::fidl::Equality<::test::union_::EmptyFlexibleUnion>;

 private:
  void Destroy();
  void EnsureStorageInitialized(::fidl_xunion_tag_t tag);

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::union_::EmptyFlexibleUnion::Tag::Invalid);
  union {
    std::vector<uint8_t> unknown_data_;
  };
};

inline zx_status_t Clone(const ::test::union_::EmptyFlexibleUnion& value,
                         ::test::union_::EmptyFlexibleUnion* result) {
  return value.Clone(result);
}

using EmptyFlexibleUnionPtr = ::std::unique_ptr<EmptyFlexibleUnion>;

}  // namespace union_
}  // namespace test
namespace fidl {

template <>
struct CodingTraits<::test::union_::Pizza>
    : public EncodableCodingTraits<::test::union_::Pizza, 16> {};

template <>
struct HasPadding<::test::union_::Pizza> : public std::true_type {};

template <>
struct IsMemcpyCompatible<::test::union_::Pizza> : public internal::BoolConstant<
                                                       !HasPadding<::test::union_::Pizza>::value && IsMemcpyCompatible<::std::vector<::std::string>>::value> {};

inline zx_status_t Clone(const ::test::union_::Pizza& value,
                         ::test::union_::Pizza* result) {
  return ::test::union_::Clone(value, result);
}

template <>
struct Equality<::test::union_::Pizza> {
  bool operator()(const ::test::union_::Pizza& _lhs, const ::test::union_::Pizza& _rhs) const {
    if (!::fidl::Equals(_lhs.toppings, _rhs.toppings)) {
      return false;
    }
    return true;
  }
};
template <>
struct CodingTraits<::test::union_::Pasta>
    : public EncodableCodingTraits<::test::union_::Pasta, 16> {};

template <>
struct HasPadding<::test::union_::Pasta> : public std::true_type {};

template <>
struct IsMemcpyCompatible<::test::union_::Pasta> : public internal::BoolConstant<
                                                       !HasPadding<::test::union_::Pasta>::value && IsMemcpyCompatible<::std::string>::value> {};

inline zx_status_t Clone(const ::test::union_::Pasta& value,
                         ::test::union_::Pasta* result) {
  return ::test::union_::Clone(value, result);
}

template <>
struct Equality<::test::union_::Pasta> {
  bool operator()(const ::test::union_::Pasta& _lhs, const ::test::union_::Pasta& _rhs) const {
    if (!::fidl::Equals(_lhs.sauce, _rhs.sauce)) {
      return false;
    }
    return true;
  }
};
template <>
struct IsFidlXUnion<::test::union_::PizzaOrPasta> : public std::true_type {};

template <>
struct CodingTraits<::test::union_::PizzaOrPasta>
    : public EncodableCodingTraits<::test::union_::PizzaOrPasta, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::union_::PizzaOrPasta>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::union_::PizzaOrPasta>* value, size_t offset,
                     cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt) {
    auto&& p_xunion = *value;
    if (p_xunion) {
      p_xunion->Encode(encoder, offset);
    }
  }

  static void Decode(Decoder* _decoder, std::unique_ptr<::test::union_::PizzaOrPasta>* value, size_t offset) {
    fidl_union_t* encoded = _decoder->GetPtr<fidl_union_t>(offset);
    if (encoded->tag == 0) {
      value->reset(nullptr);
      return;
    }

    value->reset(new ::test::union_::PizzaOrPasta);

    ::test::union_::PizzaOrPasta::Decode(_decoder, value->get(), offset);
  }
};

inline zx_status_t Clone(const ::test::union_::PizzaOrPasta& value,
                         ::test::union_::PizzaOrPasta* result) {
  return ::test::union_::Clone(value, result);
}

template <>
struct Equality<::test::union_::PizzaOrPasta> {
  bool operator()(const ::test::union_::PizzaOrPasta& _lhs, const ::test::union_::PizzaOrPasta& _rhs) const {
    if (_lhs.Ordinal() != _rhs.Ordinal()) {
      return false;
    }

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::union_::PizzaOrPasta::Tag::Invalid):
        return true;
      case ::test::union_::PizzaOrPasta::Tag::kPizza:
        return ::fidl::Equals(_lhs.pizza_, _rhs.pizza_);
      case ::test::union_::PizzaOrPasta::Tag::kPasta:
        return ::fidl::Equals(_lhs.pasta_, _rhs.pasta_);

      default:
        return false;
    }
  }
};
template <>
struct IsFidlXUnion<::test::union_::ExplicitPizzaOrPasta> : public std::true_type {};

template <>
struct CodingTraits<::test::union_::ExplicitPizzaOrPasta>
    : public EncodableCodingTraits<::test::union_::ExplicitPizzaOrPasta, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::union_::ExplicitPizzaOrPasta>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::union_::ExplicitPizzaOrPasta>* value, size_t offset,
                     cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt) {
    auto&& p_xunion = *value;
    if (p_xunion) {
      p_xunion->Encode(encoder, offset);
    }
  }

  static void Decode(Decoder* _decoder, std::unique_ptr<::test::union_::ExplicitPizzaOrPasta>* value, size_t offset) {
    fidl_union_t* encoded = _decoder->GetPtr<fidl_union_t>(offset);
    if (encoded->tag == 0) {
      value->reset(nullptr);
      return;
    }

    value->reset(new ::test::union_::ExplicitPizzaOrPasta);

    ::test::union_::ExplicitPizzaOrPasta::Decode(_decoder, value->get(), offset);
  }
};

inline zx_status_t Clone(const ::test::union_::ExplicitPizzaOrPasta& value,
                         ::test::union_::ExplicitPizzaOrPasta* result) {
  return ::test::union_::Clone(value, result);
}

template <>
struct Equality<::test::union_::ExplicitPizzaOrPasta> {
  bool operator()(const ::test::union_::ExplicitPizzaOrPasta& _lhs, const ::test::union_::ExplicitPizzaOrPasta& _rhs) const {
    if (_lhs.Ordinal() != _rhs.Ordinal()) {
      return false;
    }

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::union_::ExplicitPizzaOrPasta::Tag::Invalid):
        return true;
      case ::test::union_::ExplicitPizzaOrPasta::Tag::kPizza:
        return ::fidl::Equals(_lhs.pizza_, _rhs.pizza_);
      case ::test::union_::ExplicitPizzaOrPasta::Tag::kPasta:
        return ::fidl::Equals(_lhs.pasta_, _rhs.pasta_);

      default:
        return false;
    }
  }
};
template <>
struct IsFidlXUnion<::test::union_::FlexiblePizzaOrPasta> : public std::true_type {};

template <>
struct CodingTraits<::test::union_::FlexiblePizzaOrPasta>
    : public EncodableCodingTraits<::test::union_::FlexiblePizzaOrPasta, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::union_::FlexiblePizzaOrPasta>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::union_::FlexiblePizzaOrPasta>* value, size_t offset,
                     cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt) {
    auto&& p_xunion = *value;
    if (p_xunion) {
      p_xunion->Encode(encoder, offset);
    }
  }

  static void Decode(Decoder* _decoder, std::unique_ptr<::test::union_::FlexiblePizzaOrPasta>* value, size_t offset) {
    fidl_union_t* encoded = _decoder->GetPtr<fidl_union_t>(offset);
    if (encoded->tag == 0) {
      value->reset(nullptr);
      return;
    }

    value->reset(new ::test::union_::FlexiblePizzaOrPasta);

    ::test::union_::FlexiblePizzaOrPasta::Decode(_decoder, value->get(), offset);
  }
};

inline zx_status_t Clone(const ::test::union_::FlexiblePizzaOrPasta& value,
                         ::test::union_::FlexiblePizzaOrPasta* result) {
  return ::test::union_::Clone(value, result);
}

template <>
struct Equality<::test::union_::FlexiblePizzaOrPasta> {
  bool operator()(const ::test::union_::FlexiblePizzaOrPasta& _lhs, const ::test::union_::FlexiblePizzaOrPasta& _rhs) const {
    if (_lhs.Ordinal() != _rhs.Ordinal()) {
      return false;
    }

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::union_::FlexiblePizzaOrPasta::Tag::Invalid):
        return true;
      case ::test::union_::FlexiblePizzaOrPasta::Tag::kPizza:
        return ::fidl::Equals(_lhs.pizza_, _rhs.pizza_);
      case ::test::union_::FlexiblePizzaOrPasta::Tag::kPasta:
        return ::fidl::Equals(_lhs.pasta_, _rhs.pasta_);
      default:
        return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_);
    }
  }
};
template <>
struct IsFidlXUnion<::test::union_::StrictPizzaOrPasta> : public std::true_type {};

template <>
struct CodingTraits<::test::union_::StrictPizzaOrPasta>
    : public EncodableCodingTraits<::test::union_::StrictPizzaOrPasta, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::union_::StrictPizzaOrPasta>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::union_::StrictPizzaOrPasta>* value, size_t offset,
                     cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt) {
    auto&& p_xunion = *value;
    if (p_xunion) {
      p_xunion->Encode(encoder, offset);
    }
  }

  static void Decode(Decoder* _decoder, std::unique_ptr<::test::union_::StrictPizzaOrPasta>* value, size_t offset) {
    fidl_union_t* encoded = _decoder->GetPtr<fidl_union_t>(offset);
    if (encoded->tag == 0) {
      value->reset(nullptr);
      return;
    }

    value->reset(new ::test::union_::StrictPizzaOrPasta);

    ::test::union_::StrictPizzaOrPasta::Decode(_decoder, value->get(), offset);
  }
};

inline zx_status_t Clone(const ::test::union_::StrictPizzaOrPasta& value,
                         ::test::union_::StrictPizzaOrPasta* result) {
  return ::test::union_::Clone(value, result);
}

template <>
struct Equality<::test::union_::StrictPizzaOrPasta> {
  bool operator()(const ::test::union_::StrictPizzaOrPasta& _lhs, const ::test::union_::StrictPizzaOrPasta& _rhs) const {
    if (_lhs.Ordinal() != _rhs.Ordinal()) {
      return false;
    }

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::union_::StrictPizzaOrPasta::Tag::Invalid):
        return true;
      case ::test::union_::StrictPizzaOrPasta::Tag::kPizza:
        return ::fidl::Equals(_lhs.pizza_, _rhs.pizza_);
      case ::test::union_::StrictPizzaOrPasta::Tag::kPasta:
        return ::fidl::Equals(_lhs.pasta_, _rhs.pasta_);

      default:
        return false;
    }
  }
};
template <>
struct IsFidlXUnion<::test::union_::Union> : public std::true_type {};

template <>
struct CodingTraits<::test::union_::Union>
    : public EncodableCodingTraits<::test::union_::Union, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::union_::Union>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::union_::Union>* value, size_t offset,
                     cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt) {
    auto&& p_xunion = *value;
    if (p_xunion) {
      p_xunion->Encode(encoder, offset);
    }
  }

  static void Decode(Decoder* _decoder, std::unique_ptr<::test::union_::Union>* value, size_t offset) {
    fidl_union_t* encoded = _decoder->GetPtr<fidl_union_t>(offset);
    if (encoded->tag == 0) {
      value->reset(nullptr);
      return;
    }

    value->reset(new ::test::union_::Union);

    ::test::union_::Union::Decode(_decoder, value->get(), offset);
  }
};

inline zx_status_t Clone(const ::test::union_::Union& value,
                         ::test::union_::Union* result) {
  return ::test::union_::Clone(value, result);
}

template <>
struct Equality<::test::union_::Union> {
  bool operator()(const ::test::union_::Union& _lhs, const ::test::union_::Union& _rhs) const {
    if (_lhs.Ordinal() != _rhs.Ordinal()) {
      return false;
    }

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::union_::Union::Tag::Invalid):
        return true;
      case ::test::union_::Union::Tag::kPrimitive:
        return ::fidl::Equals(_lhs.Primitive_, _rhs.Primitive_);
      case ::test::union_::Union::Tag::kStringNeedsConstructor:
        return ::fidl::Equals(_lhs.StringNeedsConstructor_, _rhs.StringNeedsConstructor_);
      case ::test::union_::Union::Tag::kVectorStringAlsoNeedsConstructor:
        return ::fidl::Equals(_lhs.VectorStringAlsoNeedsConstructor_, _rhs.VectorStringAlsoNeedsConstructor_);

      default:
        return false;
    }
  }
};
template <>
struct IsFidlXUnion<::test::union_::FlexibleUnion> : public std::true_type {};

template <>
struct CodingTraits<::test::union_::FlexibleUnion>
    : public EncodableCodingTraits<::test::union_::FlexibleUnion, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::union_::FlexibleUnion>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::union_::FlexibleUnion>* value, size_t offset,
                     cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt) {
    auto&& p_xunion = *value;
    if (p_xunion) {
      p_xunion->Encode(encoder, offset);
    }
  }

  static void Decode(Decoder* _decoder, std::unique_ptr<::test::union_::FlexibleUnion>* value, size_t offset) {
    fidl_union_t* encoded = _decoder->GetPtr<fidl_union_t>(offset);
    if (encoded->tag == 0) {
      value->reset(nullptr);
      return;
    }

    value->reset(new ::test::union_::FlexibleUnion);

    ::test::union_::FlexibleUnion::Decode(_decoder, value->get(), offset);
  }
};

inline zx_status_t Clone(const ::test::union_::FlexibleUnion& value,
                         ::test::union_::FlexibleUnion* result) {
  return ::test::union_::Clone(value, result);
}

template <>
struct Equality<::test::union_::FlexibleUnion> {
  bool operator()(const ::test::union_::FlexibleUnion& _lhs, const ::test::union_::FlexibleUnion& _rhs) const {
    if (_lhs.Ordinal() != _rhs.Ordinal()) {
      return false;
    }

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::union_::FlexibleUnion::Tag::Invalid):
        return true;
      case ::test::union_::FlexibleUnion::Tag::kPrimitive:
        return ::fidl::Equals(_lhs.Primitive_, _rhs.Primitive_);
      case ::test::union_::FlexibleUnion::Tag::kStringNeedsConstructor:
        return ::fidl::Equals(_lhs.StringNeedsConstructor_, _rhs.StringNeedsConstructor_);
      case ::test::union_::FlexibleUnion::Tag::kVectorStringAlsoNeedsConstructor:
        return ::fidl::Equals(_lhs.VectorStringAlsoNeedsConstructor_, _rhs.VectorStringAlsoNeedsConstructor_);
      default:
        return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_);
    }
  }
};
template <>
struct IsFidlXUnion<::test::union_::StrictUnion> : public std::true_type {};

template <>
struct CodingTraits<::test::union_::StrictUnion>
    : public EncodableCodingTraits<::test::union_::StrictUnion, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::union_::StrictUnion>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::union_::StrictUnion>* value, size_t offset,
                     cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt) {
    auto&& p_xunion = *value;
    if (p_xunion) {
      p_xunion->Encode(encoder, offset);
    }
  }

  static void Decode(Decoder* _decoder, std::unique_ptr<::test::union_::StrictUnion>* value, size_t offset) {
    fidl_union_t* encoded = _decoder->GetPtr<fidl_union_t>(offset);
    if (encoded->tag == 0) {
      value->reset(nullptr);
      return;
    }

    value->reset(new ::test::union_::StrictUnion);

    ::test::union_::StrictUnion::Decode(_decoder, value->get(), offset);
  }
};

inline zx_status_t Clone(const ::test::union_::StrictUnion& value,
                         ::test::union_::StrictUnion* result) {
  return ::test::union_::Clone(value, result);
}

template <>
struct Equality<::test::union_::StrictUnion> {
  bool operator()(const ::test::union_::StrictUnion& _lhs, const ::test::union_::StrictUnion& _rhs) const {
    if (_lhs.Ordinal() != _rhs.Ordinal()) {
      return false;
    }

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::union_::StrictUnion::Tag::Invalid):
        return true;
      case ::test::union_::StrictUnion::Tag::kPrimitive:
        return ::fidl::Equals(_lhs.Primitive_, _rhs.Primitive_);
      case ::test::union_::StrictUnion::Tag::kStringNeedsConstructor:
        return ::fidl::Equals(_lhs.StringNeedsConstructor_, _rhs.StringNeedsConstructor_);
      case ::test::union_::StrictUnion::Tag::kVectorStringAlsoNeedsConstructor:
        return ::fidl::Equals(_lhs.VectorStringAlsoNeedsConstructor_, _rhs.VectorStringAlsoNeedsConstructor_);

      default:
        return false;
    }
  }
};
template <>
struct IsFidlXUnion<::test::union_::FieldCollision> : public std::true_type {};

template <>
struct CodingTraits<::test::union_::FieldCollision>
    : public EncodableCodingTraits<::test::union_::FieldCollision, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::union_::FieldCollision>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::union_::FieldCollision>* value, size_t offset,
                     cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt) {
    auto&& p_xunion = *value;
    if (p_xunion) {
      p_xunion->Encode(encoder, offset);
    }
  }

  static void Decode(Decoder* _decoder, std::unique_ptr<::test::union_::FieldCollision>* value, size_t offset) {
    fidl_union_t* encoded = _decoder->GetPtr<fidl_union_t>(offset);
    if (encoded->tag == 0) {
      value->reset(nullptr);
      return;
    }

    value->reset(new ::test::union_::FieldCollision);

    ::test::union_::FieldCollision::Decode(_decoder, value->get(), offset);
  }
};

inline zx_status_t Clone(const ::test::union_::FieldCollision& value,
                         ::test::union_::FieldCollision* result) {
  return ::test::union_::Clone(value, result);
}

template <>
struct Equality<::test::union_::FieldCollision> {
  bool operator()(const ::test::union_::FieldCollision& _lhs, const ::test::union_::FieldCollision& _rhs) const {
    if (_lhs.Ordinal() != _rhs.Ordinal()) {
      return false;
    }

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::union_::FieldCollision::Tag::Invalid):
        return true;
      case ::test::union_::FieldCollision::Tag::kFieldCollisionTag:
        return ::fidl::Equals(_lhs.field_collision_tag_, _rhs.field_collision_tag_);

      default:
        return false;
    }
  }
};
template <>
struct IsFidlXUnion<::test::union_::ExplicitUnion> : public std::true_type {};

template <>
struct CodingTraits<::test::union_::ExplicitUnion>
    : public EncodableCodingTraits<::test::union_::ExplicitUnion, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::union_::ExplicitUnion>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::union_::ExplicitUnion>* value, size_t offset,
                     cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt) {
    auto&& p_xunion = *value;
    if (p_xunion) {
      p_xunion->Encode(encoder, offset);
    }
  }

  static void Decode(Decoder* _decoder, std::unique_ptr<::test::union_::ExplicitUnion>* value, size_t offset) {
    fidl_union_t* encoded = _decoder->GetPtr<fidl_union_t>(offset);
    if (encoded->tag == 0) {
      value->reset(nullptr);
      return;
    }

    value->reset(new ::test::union_::ExplicitUnion);

    ::test::union_::ExplicitUnion::Decode(_decoder, value->get(), offset);
  }
};

inline zx_status_t Clone(const ::test::union_::ExplicitUnion& value,
                         ::test::union_::ExplicitUnion* result) {
  return ::test::union_::Clone(value, result);
}

template <>
struct Equality<::test::union_::ExplicitUnion> {
  bool operator()(const ::test::union_::ExplicitUnion& _lhs, const ::test::union_::ExplicitUnion& _rhs) const {
    if (_lhs.Ordinal() != _rhs.Ordinal()) {
      return false;
    }

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::union_::ExplicitUnion::Tag::Invalid):
        return true;
      case ::test::union_::ExplicitUnion::Tag::kPrimitive:
        return ::fidl::Equals(_lhs.Primitive_, _rhs.Primitive_);
      case ::test::union_::ExplicitUnion::Tag::kStringNeedsConstructor:
        return ::fidl::Equals(_lhs.StringNeedsConstructor_, _rhs.StringNeedsConstructor_);

      default:
        return false;
    }
  }
};
template <>
struct IsFidlXUnion<::test::union_::ReverseOrdinalUnion> : public std::true_type {};

template <>
struct CodingTraits<::test::union_::ReverseOrdinalUnion>
    : public EncodableCodingTraits<::test::union_::ReverseOrdinalUnion, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::union_::ReverseOrdinalUnion>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::union_::ReverseOrdinalUnion>* value, size_t offset,
                     cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt) {
    auto&& p_xunion = *value;
    if (p_xunion) {
      p_xunion->Encode(encoder, offset);
    }
  }

  static void Decode(Decoder* _decoder, std::unique_ptr<::test::union_::ReverseOrdinalUnion>* value, size_t offset) {
    fidl_union_t* encoded = _decoder->GetPtr<fidl_union_t>(offset);
    if (encoded->tag == 0) {
      value->reset(nullptr);
      return;
    }

    value->reset(new ::test::union_::ReverseOrdinalUnion);

    ::test::union_::ReverseOrdinalUnion::Decode(_decoder, value->get(), offset);
  }
};

inline zx_status_t Clone(const ::test::union_::ReverseOrdinalUnion& value,
                         ::test::union_::ReverseOrdinalUnion* result) {
  return ::test::union_::Clone(value, result);
}

template <>
struct Equality<::test::union_::ReverseOrdinalUnion> {
  bool operator()(const ::test::union_::ReverseOrdinalUnion& _lhs, const ::test::union_::ReverseOrdinalUnion& _rhs) const {
    if (_lhs.Ordinal() != _rhs.Ordinal()) {
      return false;
    }

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::union_::ReverseOrdinalUnion::Tag::Invalid):
        return true;
      case ::test::union_::ReverseOrdinalUnion::Tag::kFirst:
        return ::fidl::Equals(_lhs.first_, _rhs.first_);
      case ::test::union_::ReverseOrdinalUnion::Tag::kSecond:
        return ::fidl::Equals(_lhs.second_, _rhs.second_);

      default:
        return false;
    }
  }
};
template <>
struct CodingTraits<::test::union_::NullableUnionStruct>
    : public EncodableCodingTraits<::test::union_::NullableUnionStruct, 16> {};

template <>
struct HasPadding<::test::union_::NullableUnionStruct> : public std::true_type {};

template <>
struct IsMemcpyCompatible<::test::union_::NullableUnionStruct> : public internal::BoolConstant<
                                                                     !HasPadding<::test::union_::NullableUnionStruct>::value && IsMemcpyCompatible<::std::unique_ptr<::test::union_::Union>>::value> {};

inline zx_status_t Clone(const ::test::union_::NullableUnionStruct& value,
                         ::test::union_::NullableUnionStruct* result) {
  return ::test::union_::Clone(value, result);
}

template <>
struct Equality<::test::union_::NullableUnionStruct> {
  bool operator()(const ::test::union_::NullableUnionStruct& _lhs, const ::test::union_::NullableUnionStruct& _rhs) const {
    if (!::fidl::Equals(_lhs.the_union, _rhs.the_union)) {
      return false;
    }
    return true;
  }
};
template <>
struct IsFidlXUnion<::test::union_::FlexibleFoo> : public std::true_type {};

template <>
struct CodingTraits<::test::union_::FlexibleFoo>
    : public EncodableCodingTraits<::test::union_::FlexibleFoo, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::union_::FlexibleFoo>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::union_::FlexibleFoo>* value, size_t offset,
                     cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt) {
    auto&& p_xunion = *value;
    if (p_xunion) {
      p_xunion->Encode(encoder, offset);
    }
  }

  static void Decode(Decoder* _decoder, std::unique_ptr<::test::union_::FlexibleFoo>* value, size_t offset) {
    fidl_union_t* encoded = _decoder->GetPtr<fidl_union_t>(offset);
    if (encoded->tag == 0) {
      value->reset(nullptr);
      return;
    }

    value->reset(new ::test::union_::FlexibleFoo);

    ::test::union_::FlexibleFoo::Decode(_decoder, value->get(), offset);
  }
};

inline zx_status_t Clone(const ::test::union_::FlexibleFoo& value,
                         ::test::union_::FlexibleFoo* result) {
  return ::test::union_::Clone(value, result);
}

template <>
struct Equality<::test::union_::FlexibleFoo> {
  bool operator()(const ::test::union_::FlexibleFoo& _lhs, const ::test::union_::FlexibleFoo& _rhs) const {
    if (_lhs.Ordinal() != _rhs.Ordinal()) {
      return false;
    }

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::union_::FlexibleFoo::Tag::Invalid):
        return true;
      case ::test::union_::FlexibleFoo::Tag::kS:
        return ::fidl::Equals(_lhs.s_, _rhs.s_);
      case ::test::union_::FlexibleFoo::Tag::kI:
        return ::fidl::Equals(_lhs.i_, _rhs.i_);
      default:
        return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_);
    }
  }
};
template <>
struct IsFidlXUnion<::test::union_::StrictFoo> : public std::true_type {};

template <>
struct CodingTraits<::test::union_::StrictFoo>
    : public EncodableCodingTraits<::test::union_::StrictFoo, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::union_::StrictFoo>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::union_::StrictFoo>* value, size_t offset,
                     cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt) {
    auto&& p_xunion = *value;
    if (p_xunion) {
      p_xunion->Encode(encoder, offset);
    }
  }

  static void Decode(Decoder* _decoder, std::unique_ptr<::test::union_::StrictFoo>* value, size_t offset) {
    fidl_union_t* encoded = _decoder->GetPtr<fidl_union_t>(offset);
    if (encoded->tag == 0) {
      value->reset(nullptr);
      return;
    }

    value->reset(new ::test::union_::StrictFoo);

    ::test::union_::StrictFoo::Decode(_decoder, value->get(), offset);
  }
};

inline zx_status_t Clone(const ::test::union_::StrictFoo& value,
                         ::test::union_::StrictFoo* result) {
  return ::test::union_::Clone(value, result);
}

template <>
struct Equality<::test::union_::StrictFoo> {
  bool operator()(const ::test::union_::StrictFoo& _lhs, const ::test::union_::StrictFoo& _rhs) const {
    if (_lhs.Ordinal() != _rhs.Ordinal()) {
      return false;
    }

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::union_::StrictFoo::Tag::Invalid):
        return true;
      case ::test::union_::StrictFoo::Tag::kS:
        return ::fidl::Equals(_lhs.s_, _rhs.s_);
      case ::test::union_::StrictFoo::Tag::kI:
        return ::fidl::Equals(_lhs.i_, _rhs.i_);

      default:
        return false;
    }
  }
};
template <>
struct IsFidlXUnion<::test::union_::ExplicitFoo> : public std::true_type {};

template <>
struct CodingTraits<::test::union_::ExplicitFoo>
    : public EncodableCodingTraits<::test::union_::ExplicitFoo, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::union_::ExplicitFoo>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::union_::ExplicitFoo>* value, size_t offset,
                     cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt) {
    auto&& p_xunion = *value;
    if (p_xunion) {
      p_xunion->Encode(encoder, offset);
    }
  }

  static void Decode(Decoder* _decoder, std::unique_ptr<::test::union_::ExplicitFoo>* value, size_t offset) {
    fidl_union_t* encoded = _decoder->GetPtr<fidl_union_t>(offset);
    if (encoded->tag == 0) {
      value->reset(nullptr);
      return;
    }

    value->reset(new ::test::union_::ExplicitFoo);

    ::test::union_::ExplicitFoo::Decode(_decoder, value->get(), offset);
  }
};

inline zx_status_t Clone(const ::test::union_::ExplicitFoo& value,
                         ::test::union_::ExplicitFoo* result) {
  return ::test::union_::Clone(value, result);
}

template <>
struct Equality<::test::union_::ExplicitFoo> {
  bool operator()(const ::test::union_::ExplicitFoo& _lhs, const ::test::union_::ExplicitFoo& _rhs) const {
    if (_lhs.Ordinal() != _rhs.Ordinal()) {
      return false;
    }

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::union_::ExplicitFoo::Tag::Invalid):
        return true;
      case ::test::union_::ExplicitFoo::Tag::kI:
        return ::fidl::Equals(_lhs.i_, _rhs.i_);
      case ::test::union_::ExplicitFoo::Tag::kS:
        return ::fidl::Equals(_lhs.s_, _rhs.s_);
      default:
        return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_);
    }
  }
};
template <>
struct IsFidlXUnion<::test::union_::ExplicitStrictFoo> : public std::true_type {};

template <>
struct CodingTraits<::test::union_::ExplicitStrictFoo>
    : public EncodableCodingTraits<::test::union_::ExplicitStrictFoo, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::union_::ExplicitStrictFoo>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::union_::ExplicitStrictFoo>* value, size_t offset,
                     cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt) {
    auto&& p_xunion = *value;
    if (p_xunion) {
      p_xunion->Encode(encoder, offset);
    }
  }

  static void Decode(Decoder* _decoder, std::unique_ptr<::test::union_::ExplicitStrictFoo>* value, size_t offset) {
    fidl_union_t* encoded = _decoder->GetPtr<fidl_union_t>(offset);
    if (encoded->tag == 0) {
      value->reset(nullptr);
      return;
    }

    value->reset(new ::test::union_::ExplicitStrictFoo);

    ::test::union_::ExplicitStrictFoo::Decode(_decoder, value->get(), offset);
  }
};

inline zx_status_t Clone(const ::test::union_::ExplicitStrictFoo& value,
                         ::test::union_::ExplicitStrictFoo* result) {
  return ::test::union_::Clone(value, result);
}

template <>
struct Equality<::test::union_::ExplicitStrictFoo> {
  bool operator()(const ::test::union_::ExplicitStrictFoo& _lhs, const ::test::union_::ExplicitStrictFoo& _rhs) const {
    if (_lhs.Ordinal() != _rhs.Ordinal()) {
      return false;
    }

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::union_::ExplicitStrictFoo::Tag::Invalid):
        return true;
      case ::test::union_::ExplicitStrictFoo::Tag::kI:
        return ::fidl::Equals(_lhs.i_, _rhs.i_);
      case ::test::union_::ExplicitStrictFoo::Tag::kS:
        return ::fidl::Equals(_lhs.s_, _rhs.s_);

      default:
        return false;
    }
  }
};
template <>
struct IsFidlXUnion<::test::union_::OlderSimpleUnion> : public std::true_type {};

template <>
struct CodingTraits<::test::union_::OlderSimpleUnion>
    : public EncodableCodingTraits<::test::union_::OlderSimpleUnion, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::union_::OlderSimpleUnion>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::union_::OlderSimpleUnion>* value, size_t offset,
                     cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt) {
    auto&& p_xunion = *value;
    if (p_xunion) {
      p_xunion->Encode(encoder, offset);
    }
  }

  static void Decode(Decoder* _decoder, std::unique_ptr<::test::union_::OlderSimpleUnion>* value, size_t offset) {
    fidl_union_t* encoded = _decoder->GetPtr<fidl_union_t>(offset);
    if (encoded->tag == 0) {
      value->reset(nullptr);
      return;
    }

    value->reset(new ::test::union_::OlderSimpleUnion);

    ::test::union_::OlderSimpleUnion::Decode(_decoder, value->get(), offset);
  }
};

inline zx_status_t Clone(const ::test::union_::OlderSimpleUnion& value,
                         ::test::union_::OlderSimpleUnion* result) {
  return ::test::union_::Clone(value, result);
}

template <>
struct Equality<::test::union_::OlderSimpleUnion> {
  bool operator()(const ::test::union_::OlderSimpleUnion& _lhs, const ::test::union_::OlderSimpleUnion& _rhs) const {
    if (_lhs.Ordinal() != _rhs.Ordinal()) {
      return false;
    }

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::union_::OlderSimpleUnion::Tag::Invalid):
        return true;
      case ::test::union_::OlderSimpleUnion::Tag::kI:
        return ::fidl::Equals(_lhs.i_, _rhs.i_);
      case ::test::union_::OlderSimpleUnion::Tag::kF:
        return ::fidl::Equals(_lhs.f_, _rhs.f_);
      default:
        return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_);
    }
  }
};
template <>
struct IsFidlXUnion<::test::union_::NewerSimpleUnion> : public std::true_type {};

template <>
struct CodingTraits<::test::union_::NewerSimpleUnion>
    : public EncodableCodingTraits<::test::union_::NewerSimpleUnion, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::union_::NewerSimpleUnion>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::union_::NewerSimpleUnion>* value, size_t offset,
                     cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt) {
    auto&& p_xunion = *value;
    if (p_xunion) {
      p_xunion->Encode(encoder, offset);
    }
  }

  static void Decode(Decoder* _decoder, std::unique_ptr<::test::union_::NewerSimpleUnion>* value, size_t offset) {
    fidl_union_t* encoded = _decoder->GetPtr<fidl_union_t>(offset);
    if (encoded->tag == 0) {
      value->reset(nullptr);
      return;
    }

    value->reset(new ::test::union_::NewerSimpleUnion);

    ::test::union_::NewerSimpleUnion::Decode(_decoder, value->get(), offset);
  }
};

inline zx_status_t Clone(const ::test::union_::NewerSimpleUnion& value,
                         ::test::union_::NewerSimpleUnion* result) {
  return ::test::union_::Clone(value, result);
}

template <>
struct Equality<::test::union_::NewerSimpleUnion> {
  bool operator()(const ::test::union_::NewerSimpleUnion& _lhs, const ::test::union_::NewerSimpleUnion& _rhs) const {
    if (_lhs.Ordinal() != _rhs.Ordinal()) {
      return false;
    }

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::union_::NewerSimpleUnion::Tag::Invalid):
        return true;
      case ::test::union_::NewerSimpleUnion::Tag::kI:
        return ::fidl::Equals(_lhs.i_, _rhs.i_);
      case ::test::union_::NewerSimpleUnion::Tag::kS:
        return ::fidl::Equals(_lhs.s_, _rhs.s_);
      case ::test::union_::NewerSimpleUnion::Tag::kV:
        return ::fidl::Equals(_lhs.v_, _rhs.v_);
      default:
        return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_);
    }
  }
};
template <>
struct IsFidlXUnion<::test::union_::StrictSimpleUnion> : public std::true_type {};

template <>
struct CodingTraits<::test::union_::StrictSimpleUnion>
    : public EncodableCodingTraits<::test::union_::StrictSimpleUnion, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::union_::StrictSimpleUnion>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::union_::StrictSimpleUnion>* value, size_t offset,
                     cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt) {
    auto&& p_xunion = *value;
    if (p_xunion) {
      p_xunion->Encode(encoder, offset);
    }
  }

  static void Decode(Decoder* _decoder, std::unique_ptr<::test::union_::StrictSimpleUnion>* value, size_t offset) {
    fidl_union_t* encoded = _decoder->GetPtr<fidl_union_t>(offset);
    if (encoded->tag == 0) {
      value->reset(nullptr);
      return;
    }

    value->reset(new ::test::union_::StrictSimpleUnion);

    ::test::union_::StrictSimpleUnion::Decode(_decoder, value->get(), offset);
  }
};

inline zx_status_t Clone(const ::test::union_::StrictSimpleUnion& value,
                         ::test::union_::StrictSimpleUnion* result) {
  return ::test::union_::Clone(value, result);
}

template <>
struct Equality<::test::union_::StrictSimpleUnion> {
  bool operator()(const ::test::union_::StrictSimpleUnion& _lhs, const ::test::union_::StrictSimpleUnion& _rhs) const {
    if (_lhs.Ordinal() != _rhs.Ordinal()) {
      return false;
    }

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::union_::StrictSimpleUnion::Tag::Invalid):
        return true;
      case ::test::union_::StrictSimpleUnion::Tag::kI:
        return ::fidl::Equals(_lhs.i_, _rhs.i_);
      case ::test::union_::StrictSimpleUnion::Tag::kF:
        return ::fidl::Equals(_lhs.f_, _rhs.f_);
      case ::test::union_::StrictSimpleUnion::Tag::kS:
        return ::fidl::Equals(_lhs.s_, _rhs.s_);

      default:
        return false;
    }
  }
};
template <>
struct CodingTraits<::test::union_::Empty>
    : public EncodableCodingTraits<::test::union_::Empty, 1> {};

template <>
struct IsMemcpyCompatible<::test::union_::Empty> : public internal::BoolConstant<
                                                       !HasPadding<::test::union_::Empty>::value && IsMemcpyCompatible<uint8_t>::value> {};

inline zx_status_t Clone(const ::test::union_::Empty& value,
                         ::test::union_::Empty* result) {
  return ::test::union_::Clone(value, result);
}

template <>
struct Equality<::test::union_::Empty> {
  bool operator()(const ::test::union_::Empty& _lhs, const ::test::union_::Empty& _rhs) const {
    if (!::fidl::Equals(_lhs.__reserved, _rhs.__reserved)) {
      return false;
    }
    return true;
  }
};
template <>
struct IsFidlXUnion<::test::union_::UnionContainingEmptyStruct> : public std::true_type {};

template <>
struct CodingTraits<::test::union_::UnionContainingEmptyStruct>
    : public EncodableCodingTraits<::test::union_::UnionContainingEmptyStruct, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::union_::UnionContainingEmptyStruct>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::union_::UnionContainingEmptyStruct>* value, size_t offset,
                     cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt) {
    auto&& p_xunion = *value;
    if (p_xunion) {
      p_xunion->Encode(encoder, offset);
    }
  }

  static void Decode(Decoder* _decoder, std::unique_ptr<::test::union_::UnionContainingEmptyStruct>* value, size_t offset) {
    fidl_union_t* encoded = _decoder->GetPtr<fidl_union_t>(offset);
    if (encoded->tag == 0) {
      value->reset(nullptr);
      return;
    }

    value->reset(new ::test::union_::UnionContainingEmptyStruct);

    ::test::union_::UnionContainingEmptyStruct::Decode(_decoder, value->get(), offset);
  }
};

inline zx_status_t Clone(const ::test::union_::UnionContainingEmptyStruct& value,
                         ::test::union_::UnionContainingEmptyStruct* result) {
  return ::test::union_::Clone(value, result);
}

template <>
struct Equality<::test::union_::UnionContainingEmptyStruct> {
  bool operator()(const ::test::union_::UnionContainingEmptyStruct& _lhs, const ::test::union_::UnionContainingEmptyStruct& _rhs) const {
    if (_lhs.Ordinal() != _rhs.Ordinal()) {
      return false;
    }

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::union_::UnionContainingEmptyStruct::Tag::Invalid):
        return true;
      case ::test::union_::UnionContainingEmptyStruct::Tag::kEmpty:
        return ::fidl::Equals(_lhs.empty_, _rhs.empty_);
      default:
        return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_);
    }
  }
};
template <>
struct IsFidlXUnion<::test::union_::StrictBoundedUnion> : public std::true_type {};

template <>
struct CodingTraits<::test::union_::StrictBoundedUnion>
    : public EncodableCodingTraits<::test::union_::StrictBoundedUnion, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::union_::StrictBoundedUnion>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::union_::StrictBoundedUnion>* value, size_t offset,
                     cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt) {
    auto&& p_xunion = *value;
    if (p_xunion) {
      p_xunion->Encode(encoder, offset);
    }
  }

  static void Decode(Decoder* _decoder, std::unique_ptr<::test::union_::StrictBoundedUnion>* value, size_t offset) {
    fidl_union_t* encoded = _decoder->GetPtr<fidl_union_t>(offset);
    if (encoded->tag == 0) {
      value->reset(nullptr);
      return;
    }

    value->reset(new ::test::union_::StrictBoundedUnion);

    ::test::union_::StrictBoundedUnion::Decode(_decoder, value->get(), offset);
  }
};

inline zx_status_t Clone(const ::test::union_::StrictBoundedUnion& value,
                         ::test::union_::StrictBoundedUnion* result) {
  return ::test::union_::Clone(value, result);
}

template <>
struct Equality<::test::union_::StrictBoundedUnion> {
  bool operator()(const ::test::union_::StrictBoundedUnion& _lhs, const ::test::union_::StrictBoundedUnion& _rhs) const {
    if (_lhs.Ordinal() != _rhs.Ordinal()) {
      return false;
    }

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::union_::StrictBoundedUnion::Tag::Invalid):
        return true;
      case ::test::union_::StrictBoundedUnion::Tag::kV:
        return ::fidl::Equals(_lhs.v_, _rhs.v_);

      default:
        return false;
    }
  }
};
template <>
struct CodingTraits<::test::union_::TestProtocolStrictUnionHenceResponseMayBeStackAllocatedResponse>
    : public EncodableCodingTraits<::test::union_::TestProtocolStrictUnionHenceResponseMayBeStackAllocatedResponse, 16> {};

template <>
struct HasPadding<::test::union_::TestProtocolStrictUnionHenceResponseMayBeStackAllocatedResponse> : public std::true_type {};

template <>
struct IsMemcpyCompatible<::test::union_::TestProtocolStrictUnionHenceResponseMayBeStackAllocatedResponse> : public internal::BoolConstant<
                                                                                                                 !HasPadding<::test::union_::TestProtocolStrictUnionHenceResponseMayBeStackAllocatedResponse>::value && IsMemcpyCompatible<::test::union_::StrictBoundedUnion>::value> {};

inline zx_status_t Clone(const ::test::union_::TestProtocolStrictUnionHenceResponseMayBeStackAllocatedResponse& value,
                         ::test::union_::TestProtocolStrictUnionHenceResponseMayBeStackAllocatedResponse* result) {
  return ::test::union_::Clone(value, result);
}

template <>
struct Equality<::test::union_::TestProtocolStrictUnionHenceResponseMayBeStackAllocatedResponse> {
  bool operator()(const ::test::union_::TestProtocolStrictUnionHenceResponseMayBeStackAllocatedResponse& _lhs, const ::test::union_::TestProtocolStrictUnionHenceResponseMayBeStackAllocatedResponse& _rhs) const {
    if (!::fidl::Equals(_lhs.xu, _rhs.xu)) {
      return false;
    }
    return true;
  }
};
template <>
struct CodingTraits<::test::union_::TestProtocolFlexibleUnionHenceResponseMustBeHeapAllocatedResponse>
    : public EncodableCodingTraits<::test::union_::TestProtocolFlexibleUnionHenceResponseMustBeHeapAllocatedResponse, 16> {};

template <>
struct IsMemcpyCompatible<::test::union_::TestProtocolFlexibleUnionHenceResponseMustBeHeapAllocatedResponse> : public internal::BoolConstant<
                                                                                                                   !HasPadding<::test::union_::TestProtocolFlexibleUnionHenceResponseMustBeHeapAllocatedResponse>::value && IsMemcpyCompatible<::test::union_::OlderSimpleUnion>::value> {};

inline zx_status_t Clone(const ::test::union_::TestProtocolFlexibleUnionHenceResponseMustBeHeapAllocatedResponse& value,
                         ::test::union_::TestProtocolFlexibleUnionHenceResponseMustBeHeapAllocatedResponse* result) {
  return ::test::union_::Clone(value, result);
}

template <>
struct Equality<::test::union_::TestProtocolFlexibleUnionHenceResponseMustBeHeapAllocatedResponse> {
  bool operator()(const ::test::union_::TestProtocolFlexibleUnionHenceResponseMustBeHeapAllocatedResponse& _lhs, const ::test::union_::TestProtocolFlexibleUnionHenceResponseMustBeHeapAllocatedResponse& _rhs) const {
    if (!::fidl::Equals(_lhs.xu, _rhs.xu)) {
      return false;
    }
    return true;
  }
};
template <>
struct CodingTraits<::test::union_::StructWithNullableUnion>
    : public EncodableCodingTraits<::test::union_::StructWithNullableUnion, 16> {};

template <>
struct IsMemcpyCompatible<::test::union_::StructWithNullableUnion> : public internal::BoolConstant<
                                                                         !HasPadding<::test::union_::StructWithNullableUnion>::value && IsMemcpyCompatible<::std::unique_ptr<::test::union_::OlderSimpleUnion>>::value> {};

inline zx_status_t Clone(const ::test::union_::StructWithNullableUnion& value,
                         ::test::union_::StructWithNullableUnion* result) {
  return ::test::union_::Clone(value, result);
}

template <>
struct Equality<::test::union_::StructWithNullableUnion> {
  bool operator()(const ::test::union_::StructWithNullableUnion& _lhs, const ::test::union_::StructWithNullableUnion& _rhs) const {
    if (!::fidl::Equals(_lhs.x1, _rhs.x1)) {
      return false;
    }
    return true;
  }
};
template <>
struct IsFidlXUnion<::test::union_::ExplicitFlexibleUnion> : public std::true_type {};

template <>
struct CodingTraits<::test::union_::ExplicitFlexibleUnion>
    : public EncodableCodingTraits<::test::union_::ExplicitFlexibleUnion, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::union_::ExplicitFlexibleUnion>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::union_::ExplicitFlexibleUnion>* value, size_t offset,
                     cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt) {
    auto&& p_xunion = *value;
    if (p_xunion) {
      p_xunion->Encode(encoder, offset);
    }
  }

  static void Decode(Decoder* _decoder, std::unique_ptr<::test::union_::ExplicitFlexibleUnion>* value, size_t offset) {
    fidl_union_t* encoded = _decoder->GetPtr<fidl_union_t>(offset);
    if (encoded->tag == 0) {
      value->reset(nullptr);
      return;
    }

    value->reset(new ::test::union_::ExplicitFlexibleUnion);

    ::test::union_::ExplicitFlexibleUnion::Decode(_decoder, value->get(), offset);
  }
};

inline zx_status_t Clone(const ::test::union_::ExplicitFlexibleUnion& value,
                         ::test::union_::ExplicitFlexibleUnion* result) {
  return ::test::union_::Clone(value, result);
}

template <>
struct Equality<::test::union_::ExplicitFlexibleUnion> {
  bool operator()(const ::test::union_::ExplicitFlexibleUnion& _lhs, const ::test::union_::ExplicitFlexibleUnion& _rhs) const {
    if (_lhs.Ordinal() != _rhs.Ordinal()) {
      return false;
    }

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::union_::ExplicitFlexibleUnion::Tag::Invalid):
        return true;
      case ::test::union_::ExplicitFlexibleUnion::Tag::kI:
        return ::fidl::Equals(_lhs.i_, _rhs.i_);
      case ::test::union_::ExplicitFlexibleUnion::Tag::kF:
        return ::fidl::Equals(_lhs.f_, _rhs.f_);
      default:
        return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_);
    }
  }
};
template <>
struct CodingTraits<::test::union_::UnionSandwich>
    : public EncodableCodingTraits<::test::union_::UnionSandwich, 32> {};

template <>
struct HasPadding<::test::union_::UnionSandwich> : public std::true_type {};

template <>
struct IsMemcpyCompatible<::test::union_::UnionSandwich> : public internal::BoolConstant<
                                                               !HasPadding<::test::union_::UnionSandwich>::value && IsMemcpyCompatible<uint32_t>::value && IsMemcpyCompatible<::test::union_::ExplicitFlexibleUnion>::value> {};

inline zx_status_t Clone(const ::test::union_::UnionSandwich& value,
                         ::test::union_::UnionSandwich* result) {
  return ::test::union_::Clone(value, result);
}

template <>
struct Equality<::test::union_::UnionSandwich> {
  bool operator()(const ::test::union_::UnionSandwich& _lhs, const ::test::union_::UnionSandwich& _rhs) const {
    if (!::fidl::Equals(_lhs.a, _rhs.a)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.u, _rhs.u)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.b, _rhs.b)) {
      return false;
    }
    return true;
  }
};
template <>
struct IsFidlXUnion<::test::union_::UnionWithAttributes> : public std::true_type {};

template <>
struct CodingTraits<::test::union_::UnionWithAttributes>
    : public EncodableCodingTraits<::test::union_::UnionWithAttributes, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::union_::UnionWithAttributes>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::union_::UnionWithAttributes>* value, size_t offset,
                     cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt) {
    auto&& p_xunion = *value;
    if (p_xunion) {
      p_xunion->Encode(encoder, offset);
    }
  }

  static void Decode(Decoder* _decoder, std::unique_ptr<::test::union_::UnionWithAttributes>* value, size_t offset) {
    fidl_union_t* encoded = _decoder->GetPtr<fidl_union_t>(offset);
    if (encoded->tag == 0) {
      value->reset(nullptr);
      return;
    }

    value->reset(new ::test::union_::UnionWithAttributes);

    ::test::union_::UnionWithAttributes::Decode(_decoder, value->get(), offset);
  }
};

inline zx_status_t Clone(const ::test::union_::UnionWithAttributes& value,
                         ::test::union_::UnionWithAttributes* result) {
  return ::test::union_::Clone(value, result);
}

template <>
struct Equality<::test::union_::UnionWithAttributes> {
  bool operator()(const ::test::union_::UnionWithAttributes& _lhs, const ::test::union_::UnionWithAttributes& _rhs) const {
    if (_lhs.Ordinal() != _rhs.Ordinal()) {
      return false;
    }

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::union_::UnionWithAttributes::Tag::Invalid):
        return true;
      case ::test::union_::UnionWithAttributes::Tag::kX:
        return ::fidl::Equals(_lhs.x_, _rhs.x_);
      default:
        return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_);
    }
  }
};
template <>
struct IsFidlXUnion<::test::union_::EmptyFlexibleUnion> : public std::true_type {};

template <>
struct CodingTraits<::test::union_::EmptyFlexibleUnion>
    : public EncodableCodingTraits<::test::union_::EmptyFlexibleUnion, 16> {};

template <>
struct CodingTraits<std::unique_ptr<::test::union_::EmptyFlexibleUnion>> {
  static constexpr size_t kInlineSize = 16;

  static void Encode(Encoder* encoder, std::unique_ptr<::test::union_::EmptyFlexibleUnion>* value, size_t offset,
                     cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt) {
    auto&& p_xunion = *value;
    if (p_xunion) {
      p_xunion->Encode(encoder, offset);
    }
  }

  static void Decode(Decoder* _decoder, std::unique_ptr<::test::union_::EmptyFlexibleUnion>* value, size_t offset) {
    fidl_union_t* encoded = _decoder->GetPtr<fidl_union_t>(offset);
    if (encoded->tag == 0) {
      value->reset(nullptr);
      return;
    }

    value->reset(new ::test::union_::EmptyFlexibleUnion);

    ::test::union_::EmptyFlexibleUnion::Decode(_decoder, value->get(), offset);
  }
};

inline zx_status_t Clone(const ::test::union_::EmptyFlexibleUnion& value,
                         ::test::union_::EmptyFlexibleUnion* result) {
  return ::test::union_::Clone(value, result);
}

template <>
struct Equality<::test::union_::EmptyFlexibleUnion> {
  bool operator()(const ::test::union_::EmptyFlexibleUnion& _lhs, const ::test::union_::EmptyFlexibleUnion& _rhs) const {
    if (_lhs.Ordinal() != _rhs.Ordinal()) {
      return false;
    }

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::union_::EmptyFlexibleUnion::Tag::Invalid):
        return true;
      default:
        return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_);
    }
  }
};

//
// Proxies and stubs declarations
//
}  // namespace fidl
namespace test {
namespace union_ {

#ifdef __Fuchsia__

using TestProtocolPtr = ::fidl::InterfacePtr<TestProtocol>;
class TestProtocol_Proxy;
class TestProtocol_Stub;
class TestProtocol_EventSender;
class TestProtocol_Sync;
using TestProtocolSyncPtr = ::fidl::SynchronousInterfacePtr<TestProtocol>;
class TestProtocol_SyncProxy;

namespace internal {

constexpr uint64_t kTestProtocol_StrictUnionHenceResponseMayBeStackAllocated_Ordinal = 0x5bfca9479251b9c3lu;

constexpr ::fidl::MessageDynamicFlags kTestProtocol_StrictUnionHenceResponseMayBeStackAllocated_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kTestProtocol_FlexibleUnionHenceResponseMustBeHeapAllocated_Ordinal = 0x694fede3b8829ce2lu;

constexpr ::fidl::MessageDynamicFlags kTestProtocol_FlexibleUnionHenceResponseMustBeHeapAllocated_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;
}  // namespace internal

#endif  // __Fuchsia__

#ifdef __Fuchsia__

class TestProtocol {
 public:
  using Proxy_ = ::test::union_::TestProtocol_Proxy;
  using Stub_ = ::test::union_::TestProtocol_Stub;
  using EventSender_ = ::test::union_::TestProtocol_EventSender;
  using Sync_ = ::test::union_::TestProtocol_Sync;
  virtual ~TestProtocol();
  using StrictUnionHenceResponseMayBeStackAllocatedCallback =
      fit::function<void(::test::union_::StrictBoundedUnion)>;

  virtual void StrictUnionHenceResponseMayBeStackAllocated(StrictUnionHenceResponseMayBeStackAllocatedCallback callback) = 0;
  using FlexibleUnionHenceResponseMustBeHeapAllocatedCallback =
      fit::function<void(::test::union_::OlderSimpleUnion)>;

  virtual void FlexibleUnionHenceResponseMustBeHeapAllocated(FlexibleUnionHenceResponseMustBeHeapAllocatedCallback callback) = 0;
};

class TestProtocol_RequestDecoder {
 public:
  TestProtocol_RequestDecoder() = default;
  virtual ~TestProtocol_RequestDecoder() = default;
  static const fidl_type_t* GetType(uint64_t ordinal, bool* out_needs_response, bool* is_known);
  virtual void StrictUnionHenceResponseMayBeStackAllocated() = 0;
  virtual void FlexibleUnionHenceResponseMustBeHeapAllocated() = 0;
};

class TestProtocol_ResponseDecoder {
 public:
  TestProtocol_ResponseDecoder() = default;
  virtual ~TestProtocol_ResponseDecoder() = default;
  static const fidl_type_t* GetType(uint64_t ordinal);
  virtual void StrictUnionHenceResponseMayBeStackAllocated(::test::union_::StrictBoundedUnion xu) = 0;
  virtual void FlexibleUnionHenceResponseMustBeHeapAllocated(::test::union_::OlderSimpleUnion xu) = 0;
};

class TestProtocol_EventSender {
 public:
  virtual ~TestProtocol_EventSender();
};

class TestProtocol_Sync {
 public:
  using Proxy_ = ::test::union_::TestProtocol_SyncProxy;
  virtual ~TestProtocol_Sync();
  virtual zx_status_t StrictUnionHenceResponseMayBeStackAllocated(::test::union_::StrictBoundedUnion* out_xu) = 0;
  virtual zx_status_t FlexibleUnionHenceResponseMustBeHeapAllocated(::test::union_::OlderSimpleUnion* out_xu) = 0;
};

class TestProtocol_Proxy final : public ::fidl::internal::Proxy, public TestProtocol {
 public:
  explicit TestProtocol_Proxy(::fidl::internal::ProxyController* controller);
  ~TestProtocol_Proxy() override;

  zx_status_t Dispatch_(::fidl::HLCPPIncomingMessage message) override;
  // cts-coverage-fidl-name:test.union/TestProtocol.StrictUnionHenceResponseMayBeStackAllocated
  void StrictUnionHenceResponseMayBeStackAllocated(StrictUnionHenceResponseMayBeStackAllocatedCallback callback) override;
  // cts-coverage-fidl-name:test.union/TestProtocol.FlexibleUnionHenceResponseMustBeHeapAllocated
  void FlexibleUnionHenceResponseMustBeHeapAllocated(FlexibleUnionHenceResponseMustBeHeapAllocatedCallback callback) override;

 private:
  TestProtocol_Proxy(const ::test::union_::TestProtocol_Proxy&) = delete;
  TestProtocol_Proxy& operator=(const ::test::union_::TestProtocol_Proxy&) = delete;

  ::fidl::internal::ProxyController* controller_;
};

class TestProtocol_Stub final : public ::fidl::internal::Stub, public ::test::union_::TestProtocol_EventSender {
 public:
  typedef class ::test::union_::TestProtocol TestProtocol_clazz;
  explicit TestProtocol_Stub(::test::union_::TestProtocol_Stub::TestProtocol_clazz* impl);
  ~TestProtocol_Stub() override;

  zx_status_t Dispatch_(::fidl::HLCPPIncomingMessage message,
                        ::fidl::internal::PendingResponse response) override;

 private:
  ::test::union_::TestProtocol_Stub::TestProtocol_clazz* impl_;
};

class TestProtocol_SyncProxy : public ::test::union_::TestProtocol_Sync {
 public:
  explicit TestProtocol_SyncProxy(::zx::channel channel);
  ~TestProtocol_SyncProxy() override;
  // cts-coverage-fidl-name:test.union/TestProtocol.StrictUnionHenceResponseMayBeStackAllocated
  zx_status_t StrictUnionHenceResponseMayBeStackAllocated(::test::union_::StrictBoundedUnion* out_xu) override;
  // cts-coverage-fidl-name:test.union/TestProtocol.FlexibleUnionHenceResponseMustBeHeapAllocated
  zx_status_t FlexibleUnionHenceResponseMustBeHeapAllocated(::test::union_::OlderSimpleUnion* out_xu) override;

 private:
  ::fidl::internal::SynchronousProxy proxy_;
  friend class ::fidl::SynchronousInterfacePtr<TestProtocol>;
};

#endif  // __Fuchsia__

}  // namespace union_
}  // namespace test