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

// fidl_experiment = output_index_json

#pragma once

#include <cinttypes>
#include <string>

#include <lib/fidl/cpp/natural_types.h>
#include <lib/fidl/cpp/natural_coding_traits.h>

#include <fidl/test.typesinprotocols/cpp/markers.h>
#include <fidl/test.typesinprotocols/cpp/common_types.h>


#ifdef __Fuchsia__

  #include <lib/zx/channel.h>
  #include <lib/zx/handle.h>
  #include <lib/zx/vmo.h>
  

#endif  // __Fuchsia__


#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wshadow"

namespace test_typesinprotocols {


class Struct;


class ResourceStruct;


class Basic;


class Compound;


class ArrayBasic;


class ArrayCompound;


class VectorBasic;


class VectorCompound;


class VectorOptional;


class ArrayVectorNested;


class Resource;


class Table;


class ResourceTable;


class Union;


class ResourceUnion;


class ProtocolErrorBasicResult;


class ProtocolErrorCompoundResult;


class ProtocolErrorArrayBasicResult;


class ProtocolErrorArrayCompoundResult;


class ProtocolErrorVectorBasicResult;


class ProtocolErrorVectorCompoundResult;


class ProtocolErrorVectorOptionalResult;


class ProtocolErrorArrayVectorNestedResult;


class ProtocolErrorResourceResult;


class Struct {
 private:
  struct Storage_;
 public:
  Struct(Storage_ storage) noexcept;
    Struct(uint8_t __reserved) noexcept;

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

  Struct(Struct&&) noexcept = default;
  Struct& operator=(Struct&&) noexcept = default;
    Struct(const Struct& other) noexcept;
    Struct& operator=(const Struct& other) noexcept;

    bool operator==(const Struct& other) const noexcept {
      return ::fidl::internal::NaturalStructCodingTraits<::test_typesinprotocols::Struct, 1>::Equal(this, &other);
    }
    bool operator!=(const Struct& other) const noexcept {
      return !::fidl::internal::NaturalStructCodingTraits<::test_typesinprotocols::Struct, 1>::Equal(this, &other);
    }
    
      uint8_t
    __reserved() const {
      return storage_.__reserved;
    }

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

    // Setter for __reserved.
    //
    
    Struct& __reserved(uint8_t value);

  Struct(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag);

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

  Storage_ storage_;
    Storage_ CloneStorage_() const;

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

};


class Table {
 private:
  struct Storage_;
 public:
  Table(Storage_ storage) noexcept;
  Table() noexcept = default;
  Table(Table&&) noexcept = default;
  Table& operator=(Table&&) noexcept = default;
    Table(const Table& other) noexcept;
    Table& operator=(const Table& other) noexcept;
    bool operator==(const Table& other) const noexcept {
      return ::fidl::internal::NaturalTableCodingTraits<::test_typesinprotocols::Table>::Equal(this, &other);
    }
    bool operator!=(const Table& other) const noexcept {
      return !::fidl::internal::NaturalTableCodingTraits<::test_typesinprotocols::Table>::Equal(this, &other);
    }

  bool IsEmpty() const {
      return true;
  }

  Table(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag);

 private:
  struct Storage_ final {
  };

  // TODO(https://fxbug.dev/42172795): Box the storage.
  Storage_ storage_;
    Storage_ CloneStorage_() const;
  friend struct ::fidl::internal::NaturalTableCodingTraits<::test_typesinprotocols::Table>;
  friend struct ::fidl::internal::MemberVisitor<::test_typesinprotocols::Table>;
  static constexpr auto kMembers = std::make_tuple();
};

  
class Union {
 private:
  using Storage_ =
    std::variant<
      std::monostate
        , bool>;

 public:
  // TODO: share union tag types between wire & natural.
  enum class Tag : fidl_xunion_tag_t {
    kB = 1,  // 0x1
    _do_not_handle_this__write_a_default_case_instead = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

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

    bool operator==(const Union& other) const noexcept {
      return *storage_ == *other.storage_;
    }
    bool operator!=(const Union& other) const noexcept {
      return *storage_ != *other.storage_;
    }
  constexpr bool IsUnknown() const {
    return Which() == ::test_typesinprotocols::Union::Tag::_do_not_handle_this__write_a_default_case_instead;
  }

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

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

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

    // Sets the union to hold the b member.
    //
    
    Union& b(bool value) {
      storage_->emplace<1>(std::move(value));
      return *this;
    }

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

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

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

  static constexpr size_t TagToIndex(::fidl::internal::NaturalDecoder* decoder, ::test_typesinprotocols::Union::Tag tag) {
    switch (tag) {
        case ::test_typesinprotocols::Union::Tag::kB: return 1;
      default: {
        return 0;
      }
    }
  }

  static constexpr std::optional<::test_typesinprotocols::Union::Tag> IndexToTag(size_t index) {
    switch (index) {
        case 1: return ::test_typesinprotocols::Union::Tag::kB;
        default: return ::test_typesinprotocols::Union::Tag::_do_not_handle_this__write_a_default_case_instead;
    }
  }

};


#ifdef __Fuchsia__


class ResourceStruct {
 private:
  struct Storage_;
 public:
  ResourceStruct(Storage_ storage) noexcept;
    ResourceStruct(uint8_t __reserved) noexcept;

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

  ResourceStruct(ResourceStruct&&) noexcept = default;
  ResourceStruct& operator=(ResourceStruct&&) noexcept = default;
    
      uint8_t
    __reserved() const {
      return storage_.__reserved;
    }

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

    // Setter for __reserved.
    //
    
    ResourceStruct& __reserved(uint8_t value);

  ResourceStruct(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag);

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

  Storage_ storage_;

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

};


#endif  // __Fuchsia__

  
#ifdef __Fuchsia__


class ResourceTable {
 private:
  struct Storage_;
 public:
  ResourceTable(Storage_ storage) noexcept;
  ResourceTable() noexcept = default;
  ResourceTable(ResourceTable&&) noexcept = default;
  ResourceTable& operator=(ResourceTable&&) noexcept = default;

  bool IsEmpty() const {
      return true;
  }

  ResourceTable(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag);

 private:
  struct Storage_ final {
  };

  // TODO(https://fxbug.dev/42172795): Box the storage.
  Storage_ storage_;
  friend struct ::fidl::internal::NaturalTableCodingTraits<::test_typesinprotocols::ResourceTable>;
  friend struct ::fidl::internal::MemberVisitor<::test_typesinprotocols::ResourceTable>;
  static constexpr auto kMembers = std::make_tuple();
};


#endif  // __Fuchsia__

  
#ifdef __Fuchsia__


class ResourceUnion {
 private:
  using Storage_ =
    std::variant<
      std::monostate
        , bool>;

 public:
  // TODO: share union tag types between wire & natural.
  enum class Tag : fidl_xunion_tag_t {
    kB = 1,  // 0x1
    _do_not_handle_this__write_a_default_case_instead = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

  ResourceUnion(ResourceUnion&& other) noexcept
      : ResourceUnion(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag{}) {
    *storage_ = std::move(*other.storage_);
  }
  ResourceUnion& operator=(ResourceUnion&& other) noexcept {
    if (this != &other) {
      *storage_ = std::move(*other.storage_);
    }
    return *this;
  }
  constexpr bool IsUnknown() const {
    return Which() == ::test_typesinprotocols::ResourceUnion::Tag::_do_not_handle_this__write_a_default_case_instead;
  }

  constexpr ::test_typesinprotocols::ResourceUnion::Tag Which() const {
    return ResourceUnion::IndexToTag(storage_->index()).value();
  }
    static ResourceUnion WithB(bool val) {
      return ResourceUnion(std::make_shared<Storage_>(
        std::in_place_index_t<1>{},
        std::move(val)));
    }

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

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

    // Sets the union to hold the b member.
    //
    
    ResourceUnion& b(bool value) {
      storage_->emplace<1>(std::move(value));
      return *this;
    }

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

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

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

  static constexpr size_t TagToIndex(::fidl::internal::NaturalDecoder* decoder, ::test_typesinprotocols::ResourceUnion::Tag tag) {
    switch (tag) {
        case ::test_typesinprotocols::ResourceUnion::Tag::kB: return 1;
      default: {
        return 0;
      }
    }
  }

  static constexpr std::optional<::test_typesinprotocols::ResourceUnion::Tag> IndexToTag(size_t index) {
    switch (index) {
        case 1: return ::test_typesinprotocols::ResourceUnion::Tag::kB;
        default: return ::test_typesinprotocols::ResourceUnion::Tag::_do_not_handle_this__write_a_default_case_instead;
    }
  }

};


#endif  // __Fuchsia__

  
class Basic {
 private:
  struct Storage_;
 public:
  Basic(Storage_ storage) noexcept;
    Basic(uint8_t uint8, uint16_t uint16, uint32_t uint32, uint64_t uint64, int8_t int8, int16_t int16, int32_t int32, int64_t int64, float float32, double float64, ::std::string string, ::std::optional<::std::string> opt_string) noexcept;

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

  Basic(Basic&&) noexcept = default;
  Basic& operator=(Basic&&) noexcept = default;
    Basic(const Basic& other) noexcept;
    Basic& operator=(const Basic& other) noexcept;

    bool operator==(const Basic& other) const noexcept {
      return ::fidl::internal::NaturalStructCodingTraits<::test_typesinprotocols::Basic, 80>::Equal(this, &other);
    }
    bool operator!=(const Basic& other) const noexcept {
      return !::fidl::internal::NaturalStructCodingTraits<::test_typesinprotocols::Basic, 80>::Equal(this, &other);
    }
    
      uint8_t
    uint8() const {
      return storage_.uint8;
    }

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

    // Setter for uint8.
    //
    
    Basic& uint8(uint8_t value);
    
      uint16_t
    uint16() const {
      return storage_.uint16;
    }

    
    uint16_t& uint16() {
      return storage_.uint16;
    }

    // Setter for uint16.
    //
    
    Basic& uint16(uint16_t value);
    
      uint32_t
    uint32() const {
      return storage_.uint32;
    }

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

    // Setter for uint32.
    //
    
    Basic& uint32(uint32_t value);
    
      uint64_t
    uint64() const {
      return storage_.uint64;
    }

    
    uint64_t& uint64() {
      return storage_.uint64;
    }

    // Setter for uint64.
    //
    
    Basic& uint64(uint64_t value);
    
      int8_t
    int8() const {
      return storage_.int8;
    }

    
    int8_t& int8() {
      return storage_.int8;
    }

    // Setter for int8.
    //
    
    Basic& int8(int8_t value);
    
      int16_t
    int16() const {
      return storage_.int16;
    }

    
    int16_t& int16() {
      return storage_.int16;
    }

    // Setter for int16.
    //
    
    Basic& int16(int16_t value);
    
      int32_t
    int32() const {
      return storage_.int32;
    }

    
    int32_t& int32() {
      return storage_.int32;
    }

    // Setter for int32.
    //
    
    Basic& int32(int32_t value);
    
      int64_t
    int64() const {
      return storage_.int64;
    }

    
    int64_t& int64() {
      return storage_.int64;
    }

    // Setter for int64.
    //
    
    Basic& int64(int64_t value);
    
      float
    float32() const {
      return storage_.float32;
    }

    
    float& float32() {
      return storage_.float32;
    }

    // Setter for float32.
    //
    
    Basic& float32(float value);
    
      double
    float64() const {
      return storage_.float64;
    }

    
    double& float64() {
      return storage_.float64;
    }

    // Setter for float64.
    //
    
    Basic& float64(double value);
    
      const ::std::string &
    string() const {
      return storage_.string;
    }

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

    // Setter for string.
    //
    
    Basic& string(::std::string value);
    
      const ::std::optional<::std::string> &
    opt_string() const {
      return storage_.opt_string;
    }

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

    // Setter for opt_string.
    //
    
    Basic& opt_string(::std::optional<::std::string> value);

  Basic(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag);

 private:
  struct Storage_ final {
      uint8_t uint8
        = {};
      uint16_t uint16
        = {};
      uint32_t uint32
        = {};
      uint64_t uint64
        = {};
      int8_t int8
        = {};
      int16_t int16
        = {};
      int32_t int32
        = {};
      int64_t int64
        = {};
      float float32
        = {};
      double float64
        = {};
      ::std::string string;
      ::std::optional<::std::string> opt_string;
  };

  Storage_ storage_;
    Storage_ CloneStorage_() const;

  friend struct ::fidl::internal::NaturalStructCodingTraits<::test_typesinprotocols::Basic, 80>;
  friend struct ::fidl::internal::MemberVisitor<::test_typesinprotocols::Basic>;
  static constexpr auto kMembers = std::make_tuple(::fidl::internal::NaturalStructMember<Storage_, uint8_t, fidl::internal::NaturalCodingConstraintEmpty>{
        &Storage_::uint8, 0
      }, ::fidl::internal::NaturalStructMember<Storage_, uint16_t, fidl::internal::NaturalCodingConstraintEmpty>{
        &Storage_::uint16, 2
      }, ::fidl::internal::NaturalStructMember<Storage_, uint32_t, fidl::internal::NaturalCodingConstraintEmpty>{
        &Storage_::uint32, 4
      }, ::fidl::internal::NaturalStructMember<Storage_, uint64_t, fidl::internal::NaturalCodingConstraintEmpty>{
        &Storage_::uint64, 8
      }, ::fidl::internal::NaturalStructMember<Storage_, int8_t, fidl::internal::NaturalCodingConstraintEmpty>{
        &Storage_::int8, 16
      }, ::fidl::internal::NaturalStructMember<Storage_, int16_t, fidl::internal::NaturalCodingConstraintEmpty>{
        &Storage_::int16, 18
      }, ::fidl::internal::NaturalStructMember<Storage_, int32_t, fidl::internal::NaturalCodingConstraintEmpty>{
        &Storage_::int32, 20
      }, ::fidl::internal::NaturalStructMember<Storage_, int64_t, fidl::internal::NaturalCodingConstraintEmpty>{
        &Storage_::int64, 24
      }, ::fidl::internal::NaturalStructMember<Storage_, float, fidl::internal::NaturalCodingConstraintEmpty>{
        &Storage_::float32, 32
      }, ::fidl::internal::NaturalStructMember<Storage_, double, fidl::internal::NaturalCodingConstraintEmpty>{
        &Storage_::float64, 40
      }, ::fidl::internal::NaturalStructMember<Storage_, ::std::string, fidl::internal::NaturalCodingConstraintString<>>{
        &Storage_::string, 48
      }, ::fidl::internal::NaturalStructMember<Storage_, ::std::optional<::std::string>, fidl::internal::NaturalCodingConstraintString<>>{
        &Storage_::opt_string, 64
      });
  static constexpr auto kPadding = std::make_tuple(::fidl::internal::NaturalStructPadding<uint64_t>{
        .offset = 0,
        .mask = 0xff00,
      }, ::fidl::internal::NaturalStructPadding<uint64_t>{
        .offset = 16,
        .mask = 0xff00,
      }, ::fidl::internal::NaturalStructPadding<uint64_t>{
        .offset = 32,
        .mask = 0xffffffff00000000,
      });

};


class Compound {
 private:
  struct Storage_;
 public:
  Compound(Storage_ storage) noexcept;
    Compound(::test_typesinprotocols::Bits bits, ::test_typesinprotocols::Enum enum_, ::test_typesinprotocols::Struct struct_, ::test_typesinprotocols::Table table, ::test_typesinprotocols::Union union_, ::fidl::Box<::test_typesinprotocols::Struct> opt_struct, ::fidl::Box<::test_typesinprotocols::Union> opt_union) noexcept;

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

  Compound(Compound&&) noexcept = default;
  Compound& operator=(Compound&&) noexcept = default;
    Compound(const Compound& other) noexcept;
    Compound& operator=(const Compound& other) noexcept;

    bool operator==(const Compound& other) const noexcept {
      return ::fidl::internal::NaturalStructCodingTraits<::test_typesinprotocols::Compound, 72>::Equal(this, &other);
    }
    bool operator!=(const Compound& other) const noexcept {
      return !::fidl::internal::NaturalStructCodingTraits<::test_typesinprotocols::Compound, 72>::Equal(this, &other);
    }
    
      ::test_typesinprotocols::Bits
    bits() const {
      return storage_.bits;
    }

    
    ::test_typesinprotocols::Bits& bits() {
      return storage_.bits;
    }

    // Setter for bits.
    //
    
    Compound& bits(::test_typesinprotocols::Bits value);
    
      ::test_typesinprotocols::Enum
    enum_() const {
      return storage_.enum_;
    }

    
    ::test_typesinprotocols::Enum& enum_() {
      return storage_.enum_;
    }

    // Setter for enum_.
    //
    
    Compound& enum_(::test_typesinprotocols::Enum value);
    
      const ::test_typesinprotocols::Struct &
    struct_() const {
      return storage_.struct_;
    }

    
    ::test_typesinprotocols::Struct& struct_() {
      return storage_.struct_;
    }

    // Setter for struct_.
    //
    
    Compound& struct_(::test_typesinprotocols::Struct value);
    
      const ::test_typesinprotocols::Table &
    table() const {
      return storage_.table;
    }

    
    ::test_typesinprotocols::Table& table() {
      return storage_.table;
    }

    // Setter for table.
    //
    
    Compound& table(::test_typesinprotocols::Table value);
    
      const ::test_typesinprotocols::Union &
    union_() const {
      return storage_.union_;
    }

    
    ::test_typesinprotocols::Union& union_() {
      return storage_.union_;
    }

    // Setter for union_.
    //
    
    Compound& union_(::test_typesinprotocols::Union value);
    
      const ::fidl::Box<::test_typesinprotocols::Struct> &
    opt_struct() const {
      return storage_.opt_struct;
    }

    
    ::fidl::Box<::test_typesinprotocols::Struct>& opt_struct() {
      return storage_.opt_struct;
    }

    // Setter for opt_struct.
    //
    
    Compound& opt_struct(::fidl::Box<::test_typesinprotocols::Struct> value);
    
      const ::fidl::Box<::test_typesinprotocols::Union> &
    opt_union() const {
      return storage_.opt_union;
    }

    
    ::fidl::Box<::test_typesinprotocols::Union>& opt_union() {
      return storage_.opt_union;
    }

    // Setter for opt_union.
    //
    
    Compound& opt_union(::fidl::Box<::test_typesinprotocols::Union> value);

  Compound(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag);

 private:
  struct Storage_ final {
      ::test_typesinprotocols::Bits bits
        = {};
      ::test_typesinprotocols::Enum enum_
        = {};
      ::test_typesinprotocols::Struct struct_;
      ::test_typesinprotocols::Table table;
      ::test_typesinprotocols::Union union_;
      ::fidl::Box<::test_typesinprotocols::Struct> opt_struct;
      ::fidl::Box<::test_typesinprotocols::Union> opt_union;
  };

  Storage_ storage_;
    Storage_ CloneStorage_() const;

  friend struct ::fidl::internal::NaturalStructCodingTraits<::test_typesinprotocols::Compound, 72>;
  friend struct ::fidl::internal::MemberVisitor<::test_typesinprotocols::Compound>;
  static constexpr auto kMembers = std::make_tuple(::fidl::internal::NaturalStructMember<Storage_, ::test_typesinprotocols::Bits, fidl::internal::NaturalCodingConstraintEmpty>{
        &Storage_::bits, 0
      }, ::fidl::internal::NaturalStructMember<Storage_, ::test_typesinprotocols::Enum, fidl::internal::NaturalCodingConstraintEmpty>{
        &Storage_::enum_, 4
      }, ::fidl::internal::NaturalStructMember<Storage_, ::test_typesinprotocols::Struct, fidl::internal::NaturalCodingConstraintEmpty>{
        &Storage_::struct_, 8
      }, ::fidl::internal::NaturalStructMember<Storage_, ::test_typesinprotocols::Table, fidl::internal::NaturalCodingConstraintEmpty>{
        &Storage_::table, 16
      }, ::fidl::internal::NaturalStructMember<Storage_, ::test_typesinprotocols::Union, fidl::internal::NaturalCodingConstraintEmpty>{
        &Storage_::union_, 32
      }, ::fidl::internal::NaturalStructMember<Storage_, ::fidl::Box<::test_typesinprotocols::Struct>, fidl::internal::NaturalCodingConstraintEmpty>{
        &Storage_::opt_struct, 48
      }, ::fidl::internal::NaturalStructMember<Storage_, ::fidl::Box<::test_typesinprotocols::Union>, fidl::internal::NaturalCodingConstraintEmpty>{
        &Storage_::opt_union, 56
      });
  static constexpr auto kPadding = std::make_tuple(::fidl::internal::NaturalStructPadding<uint64_t>{
        .offset = 8,
        .mask = 0xffffffffffffff00,
      });

};


class ArrayBasic {
 private:
  struct Storage_;
 public:
  ArrayBasic(Storage_ storage) noexcept;
    ArrayBasic(::std::array<uint8_t, 5> array_uint8, ::std::array<uint16_t, 5> array_uint16, ::std::array<uint32_t, 5> array_uint32, ::std::array<uint64_t, 5> array_uint64, ::std::array<int8_t, 5> array_int8, ::std::array<int16_t, 5> array_int16, ::std::array<int32_t, 5> array_int32, ::std::array<int64_t, 5> array_int64, ::std::array<float, 5> array_float32, ::std::array<double, 5> array_float64, ::std::array<::std::string, 5> array_string, ::std::array<::std::optional<::std::string>, 5> array_opt_string) noexcept;

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

  ArrayBasic(ArrayBasic&&) noexcept = default;
  ArrayBasic& operator=(ArrayBasic&&) noexcept = default;
    ArrayBasic(const ArrayBasic& other) noexcept;
    ArrayBasic& operator=(const ArrayBasic& other) noexcept;

    bool operator==(const ArrayBasic& other) const noexcept {
      return ::fidl::internal::NaturalStructCodingTraits<::test_typesinprotocols::ArrayBasic, 384>::Equal(this, &other);
    }
    bool operator!=(const ArrayBasic& other) const noexcept {
      return !::fidl::internal::NaturalStructCodingTraits<::test_typesinprotocols::ArrayBasic, 384>::Equal(this, &other);
    }
    
      const ::std::array<uint8_t, 5> &
    array_uint8() const {
      return storage_.array_uint8;
    }

    
    ::std::array<uint8_t, 5>& array_uint8() {
      return storage_.array_uint8;
    }

    // Setter for array_uint8.
    //
    
    ArrayBasic& array_uint8(::std::array<uint8_t, 5> value);
    
      const ::std::array<uint16_t, 5> &
    array_uint16() const {
      return storage_.array_uint16;
    }

    
    ::std::array<uint16_t, 5>& array_uint16() {
      return storage_.array_uint16;
    }

    // Setter for array_uint16.
    //
    
    ArrayBasic& array_uint16(::std::array<uint16_t, 5> value);
    
      const ::std::array<uint32_t, 5> &
    array_uint32() const {
      return storage_.array_uint32;
    }

    
    ::std::array<uint32_t, 5>& array_uint32() {
      return storage_.array_uint32;
    }

    // Setter for array_uint32.
    //
    
    ArrayBasic& array_uint32(::std::array<uint32_t, 5> value);
    
      const ::std::array<uint64_t, 5> &
    array_uint64() const {
      return storage_.array_uint64;
    }

    
    ::std::array<uint64_t, 5>& array_uint64() {
      return storage_.array_uint64;
    }

    // Setter for array_uint64.
    //
    
    ArrayBasic& array_uint64(::std::array<uint64_t, 5> value);
    
      const ::std::array<int8_t, 5> &
    array_int8() const {
      return storage_.array_int8;
    }

    
    ::std::array<int8_t, 5>& array_int8() {
      return storage_.array_int8;
    }

    // Setter for array_int8.
    //
    
    ArrayBasic& array_int8(::std::array<int8_t, 5> value);
    
      const ::std::array<int16_t, 5> &
    array_int16() const {
      return storage_.array_int16;
    }

    
    ::std::array<int16_t, 5>& array_int16() {
      return storage_.array_int16;
    }

    // Setter for array_int16.
    //
    
    ArrayBasic& array_int16(::std::array<int16_t, 5> value);
    
      const ::std::array<int32_t, 5> &
    array_int32() const {
      return storage_.array_int32;
    }

    
    ::std::array<int32_t, 5>& array_int32() {
      return storage_.array_int32;
    }

    // Setter for array_int32.
    //
    
    ArrayBasic& array_int32(::std::array<int32_t, 5> value);
    
      const ::std::array<int64_t, 5> &
    array_int64() const {
      return storage_.array_int64;
    }

    
    ::std::array<int64_t, 5>& array_int64() {
      return storage_.array_int64;
    }

    // Setter for array_int64.
    //
    
    ArrayBasic& array_int64(::std::array<int64_t, 5> value);
    
      const ::std::array<float, 5> &
    array_float32() const {
      return storage_.array_float32;
    }

    
    ::std::array<float, 5>& array_float32() {
      return storage_.array_float32;
    }

    // Setter for array_float32.
    //
    
    ArrayBasic& array_float32(::std::array<float, 5> value);
    
      const ::std::array<double, 5> &
    array_float64() const {
      return storage_.array_float64;
    }

    
    ::std::array<double, 5>& array_float64() {
      return storage_.array_float64;
    }

    // Setter for array_float64.
    //
    
    ArrayBasic& array_float64(::std::array<double, 5> value);
    
      const ::std::array<::std::string, 5> &
    array_string() const {
      return storage_.array_string;
    }

    
    ::std::array<::std::string, 5>& array_string() {
      return storage_.array_string;
    }

    // Setter for array_string.
    //
    
    ArrayBasic& array_string(::std::array<::std::string, 5> value);
    
      const ::std::array<::std::optional<::std::string>, 5> &
    array_opt_string() const {
      return storage_.array_opt_string;
    }

    
    ::std::array<::std::optional<::std::string>, 5>& array_opt_string() {
      return storage_.array_opt_string;
    }

    // Setter for array_opt_string.
    //
    
    ArrayBasic& array_opt_string(::std::array<::std::optional<::std::string>, 5> value);

  ArrayBasic(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag);

 private:
  struct Storage_ final {
      ::std::array<uint8_t, 5> array_uint8
        = {};
      ::std::array<uint16_t, 5> array_uint16
        = {};
      ::std::array<uint32_t, 5> array_uint32
        = {};
      ::std::array<uint64_t, 5> array_uint64
        = {};
      ::std::array<int8_t, 5> array_int8
        = {};
      ::std::array<int16_t, 5> array_int16
        = {};
      ::std::array<int32_t, 5> array_int32
        = {};
      ::std::array<int64_t, 5> array_int64
        = {};
      ::std::array<float, 5> array_float32
        = {};
      ::std::array<double, 5> array_float64
        = {};
      ::std::array<::std::string, 5> array_string;
      ::std::array<::std::optional<::std::string>, 5> array_opt_string;
  };

  Storage_ storage_;
    Storage_ CloneStorage_() const;

  friend struct ::fidl::internal::NaturalStructCodingTraits<::test_typesinprotocols::ArrayBasic, 384>;
  friend struct ::fidl::internal::MemberVisitor<::test_typesinprotocols::ArrayBasic>;
  static constexpr auto kMembers = std::make_tuple(::fidl::internal::NaturalStructMember<Storage_, ::std::array<uint8_t, 5>, fidl::internal::NaturalCodingConstraintEmpty>{
        &Storage_::array_uint8, 0
      }, ::fidl::internal::NaturalStructMember<Storage_, ::std::array<uint16_t, 5>, fidl::internal::NaturalCodingConstraintEmpty>{
        &Storage_::array_uint16, 6
      }, ::fidl::internal::NaturalStructMember<Storage_, ::std::array<uint32_t, 5>, fidl::internal::NaturalCodingConstraintEmpty>{
        &Storage_::array_uint32, 16
      }, ::fidl::internal::NaturalStructMember<Storage_, ::std::array<uint64_t, 5>, fidl::internal::NaturalCodingConstraintEmpty>{
        &Storage_::array_uint64, 40
      }, ::fidl::internal::NaturalStructMember<Storage_, ::std::array<int8_t, 5>, fidl::internal::NaturalCodingConstraintEmpty>{
        &Storage_::array_int8, 80
      }, ::fidl::internal::NaturalStructMember<Storage_, ::std::array<int16_t, 5>, fidl::internal::NaturalCodingConstraintEmpty>{
        &Storage_::array_int16, 86
      }, ::fidl::internal::NaturalStructMember<Storage_, ::std::array<int32_t, 5>, fidl::internal::NaturalCodingConstraintEmpty>{
        &Storage_::array_int32, 96
      }, ::fidl::internal::NaturalStructMember<Storage_, ::std::array<int64_t, 5>, fidl::internal::NaturalCodingConstraintEmpty>{
        &Storage_::array_int64, 120
      }, ::fidl::internal::NaturalStructMember<Storage_, ::std::array<float, 5>, fidl::internal::NaturalCodingConstraintEmpty>{
        &Storage_::array_float32, 160
      }, ::fidl::internal::NaturalStructMember<Storage_, ::std::array<double, 5>, fidl::internal::NaturalCodingConstraintEmpty>{
        &Storage_::array_float64, 184
      }, ::fidl::internal::NaturalStructMember<Storage_, ::std::array<::std::string, 5>, fidl::internal::NaturalCodingConstraintString<>>{
        &Storage_::array_string, 224
      }, ::fidl::internal::NaturalStructMember<Storage_, ::std::array<::std::optional<::std::string>, 5>, fidl::internal::NaturalCodingConstraintString<>>{
        &Storage_::array_opt_string, 304
      });
  static constexpr auto kPadding = std::make_tuple(::fidl::internal::NaturalStructPadding<uint64_t>{
        .offset = 0,
        .mask = 0xff0000000000,
      }, ::fidl::internal::NaturalStructPadding<uint64_t>{
        .offset = 32,
        .mask = 0xffffffff00000000,
      }, ::fidl::internal::NaturalStructPadding<uint64_t>{
        .offset = 80,
        .mask = 0xff0000000000,
      }, ::fidl::internal::NaturalStructPadding<uint64_t>{
        .offset = 112,
        .mask = 0xffffffff00000000,
      }, ::fidl::internal::NaturalStructPadding<uint64_t>{
        .offset = 176,
        .mask = 0xffffffff00000000,
      });

};


class ArrayCompound {
 private:
  struct Storage_;
 public:
  ArrayCompound(Storage_ storage) noexcept;
    ArrayCompound(::std::array<::test_typesinprotocols::Bits, 5> array_bits, ::std::array<::test_typesinprotocols::Enum, 5> array_enum, ::std::array<::test_typesinprotocols::Struct, 5> array_struct, ::std::array<::test_typesinprotocols::Table, 5> array_table, ::std::array<::test_typesinprotocols::Union, 5> array_union, ::std::array<::fidl::Box<::test_typesinprotocols::Struct>, 5> array_opt_struct, ::std::array<::fidl::Box<::test_typesinprotocols::Union>, 5> array_opt_union) noexcept;

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

  ArrayCompound(ArrayCompound&&) noexcept = default;
  ArrayCompound& operator=(ArrayCompound&&) noexcept = default;
    ArrayCompound(const ArrayCompound& other) noexcept;
    ArrayCompound& operator=(const ArrayCompound& other) noexcept;

    bool operator==(const ArrayCompound& other) const noexcept {
      return ::fidl::internal::NaturalStructCodingTraits<::test_typesinprotocols::ArrayCompound, 328>::Equal(this, &other);
    }
    bool operator!=(const ArrayCompound& other) const noexcept {
      return !::fidl::internal::NaturalStructCodingTraits<::test_typesinprotocols::ArrayCompound, 328>::Equal(this, &other);
    }
    
      const ::std::array<::test_typesinprotocols::Bits, 5> &
    array_bits() const {
      return storage_.array_bits;
    }

    
    ::std::array<::test_typesinprotocols::Bits, 5>& array_bits() {
      return storage_.array_bits;
    }

    // Setter for array_bits.
    //
    
    ArrayCompound& array_bits(::std::array<::test_typesinprotocols::Bits, 5> value);
    
      const ::std::array<::test_typesinprotocols::Enum, 5> &
    array_enum() const {
      return storage_.array_enum;
    }

    
    ::std::array<::test_typesinprotocols::Enum, 5>& array_enum() {
      return storage_.array_enum;
    }

    // Setter for array_enum.
    //
    
    ArrayCompound& array_enum(::std::array<::test_typesinprotocols::Enum, 5> value);
    
      const ::std::array<::test_typesinprotocols::Struct, 5> &
    array_struct() const {
      return storage_.array_struct;
    }

    
    ::std::array<::test_typesinprotocols::Struct, 5>& array_struct() {
      return storage_.array_struct;
    }

    // Setter for array_struct.
    //
    
    ArrayCompound& array_struct(::std::array<::test_typesinprotocols::Struct, 5> value);
    
      const ::std::array<::test_typesinprotocols::Table, 5> &
    array_table() const {
      return storage_.array_table;
    }

    
    ::std::array<::test_typesinprotocols::Table, 5>& array_table() {
      return storage_.array_table;
    }

    // Setter for array_table.
    //
    
    ArrayCompound& array_table(::std::array<::test_typesinprotocols::Table, 5> value);
    
      const ::std::array<::test_typesinprotocols::Union, 5> &
    array_union() const {
      return storage_.array_union;
    }

    
    ::std::array<::test_typesinprotocols::Union, 5>& array_union() {
      return storage_.array_union;
    }

    // Setter for array_union.
    //
    
    ArrayCompound& array_union(::std::array<::test_typesinprotocols::Union, 5> value);
    
      const ::std::array<::fidl::Box<::test_typesinprotocols::Struct>, 5> &
    array_opt_struct() const {
      return storage_.array_opt_struct;
    }

    
    ::std::array<::fidl::Box<::test_typesinprotocols::Struct>, 5>& array_opt_struct() {
      return storage_.array_opt_struct;
    }

    // Setter for array_opt_struct.
    //
    
    ArrayCompound& array_opt_struct(::std::array<::fidl::Box<::test_typesinprotocols::Struct>, 5> value);
    
      const ::std::array<::fidl::Box<::test_typesinprotocols::Union>, 5> &
    array_opt_union() const {
      return storage_.array_opt_union;
    }

    
    ::std::array<::fidl::Box<::test_typesinprotocols::Union>, 5>& array_opt_union() {
      return storage_.array_opt_union;
    }

    // Setter for array_opt_union.
    //
    
    ArrayCompound& array_opt_union(::std::array<::fidl::Box<::test_typesinprotocols::Union>, 5> value);

  ArrayCompound(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag);

 private:
  struct Storage_ final {
      ::std::array<::test_typesinprotocols::Bits, 5> array_bits
        = {};
      ::std::array<::test_typesinprotocols::Enum, 5> array_enum
        = {};
      ::std::array<::test_typesinprotocols::Struct, 5> array_struct;
      ::std::array<::test_typesinprotocols::Table, 5> array_table;
      ::std::array<::test_typesinprotocols::Union, 5> array_union;
      ::std::array<::fidl::Box<::test_typesinprotocols::Struct>, 5> array_opt_struct;
      ::std::array<::fidl::Box<::test_typesinprotocols::Union>, 5> array_opt_union;
  };

  Storage_ storage_;
    Storage_ CloneStorage_() const;

  friend struct ::fidl::internal::NaturalStructCodingTraits<::test_typesinprotocols::ArrayCompound, 328>;
  friend struct ::fidl::internal::MemberVisitor<::test_typesinprotocols::ArrayCompound>;
  static constexpr auto kMembers = std::make_tuple(::fidl::internal::NaturalStructMember<Storage_, ::std::array<::test_typesinprotocols::Bits, 5>, fidl::internal::NaturalCodingConstraintEmpty>{
        &Storage_::array_bits, 0
      }, ::fidl::internal::NaturalStructMember<Storage_, ::std::array<::test_typesinprotocols::Enum, 5>, fidl::internal::NaturalCodingConstraintEmpty>{
        &Storage_::array_enum, 20
      }, ::fidl::internal::NaturalStructMember<Storage_, ::std::array<::test_typesinprotocols::Struct, 5>, fidl::internal::NaturalCodingConstraintEmpty>{
        &Storage_::array_struct, 40
      }, ::fidl::internal::NaturalStructMember<Storage_, ::std::array<::test_typesinprotocols::Table, 5>, fidl::internal::NaturalCodingConstraintEmpty>{
        &Storage_::array_table, 48
      }, ::fidl::internal::NaturalStructMember<Storage_, ::std::array<::test_typesinprotocols::Union, 5>, fidl::internal::NaturalCodingConstraintEmpty>{
        &Storage_::array_union, 128
      }, ::fidl::internal::NaturalStructMember<Storage_, ::std::array<::fidl::Box<::test_typesinprotocols::Struct>, 5>, fidl::internal::NaturalCodingConstraintEmpty>{
        &Storage_::array_opt_struct, 208
      }, ::fidl::internal::NaturalStructMember<Storage_, ::std::array<::fidl::Box<::test_typesinprotocols::Union>, 5>, fidl::internal::NaturalCodingConstraintEmpty>{
        &Storage_::array_opt_union, 248
      });
  static constexpr auto kPadding = std::make_tuple(::fidl::internal::NaturalStructPadding<uint64_t>{
        .offset = 40,
        .mask = 0xffffff0000000000,
      });

};


class VectorBasic {
 private:
  struct Storage_;
 public:
  VectorBasic(Storage_ storage) noexcept;
    VectorBasic(::std::vector<uint8_t> vector_uint8, ::std::vector<uint16_t> vector_uint16, ::std::vector<uint32_t> vector_uint32, ::std::vector<uint64_t> vector_uint64, ::std::vector<int8_t> vector_int8, ::std::vector<int16_t> vector_int16, ::std::vector<int32_t> vector_int32, ::std::vector<int64_t> vector_int64, ::std::vector<float> vector_float32, ::std::vector<double> vector_float64, ::std::vector<::std::string> vector_string, ::std::vector<::std::optional<::std::string>> vector_opt_string) noexcept;

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

  VectorBasic(VectorBasic&&) noexcept = default;
  VectorBasic& operator=(VectorBasic&&) noexcept = default;
    VectorBasic(const VectorBasic& other) noexcept;
    VectorBasic& operator=(const VectorBasic& other) noexcept;

    bool operator==(const VectorBasic& other) const noexcept {
      return ::fidl::internal::NaturalStructCodingTraits<::test_typesinprotocols::VectorBasic, 192>::Equal(this, &other);
    }
    bool operator!=(const VectorBasic& other) const noexcept {
      return !::fidl::internal::NaturalStructCodingTraits<::test_typesinprotocols::VectorBasic, 192>::Equal(this, &other);
    }
    
      const ::std::vector<uint8_t> &
    vector_uint8() const {
      return storage_.vector_uint8;
    }

    
    ::std::vector<uint8_t>& vector_uint8() {
      return storage_.vector_uint8;
    }

    // Setter for vector_uint8.
    //
    
    VectorBasic& vector_uint8(::std::vector<uint8_t> value);
    
      const ::std::vector<uint16_t> &
    vector_uint16() const {
      return storage_.vector_uint16;
    }

    
    ::std::vector<uint16_t>& vector_uint16() {
      return storage_.vector_uint16;
    }

    // Setter for vector_uint16.
    //
    
    VectorBasic& vector_uint16(::std::vector<uint16_t> value);
    
      const ::std::vector<uint32_t> &
    vector_uint32() const {
      return storage_.vector_uint32;
    }

    
    ::std::vector<uint32_t>& vector_uint32() {
      return storage_.vector_uint32;
    }

    // Setter for vector_uint32.
    //
    
    VectorBasic& vector_uint32(::std::vector<uint32_t> value);
    
      const ::std::vector<uint64_t> &
    vector_uint64() const {
      return storage_.vector_uint64;
    }

    
    ::std::vector<uint64_t>& vector_uint64() {
      return storage_.vector_uint64;
    }

    // Setter for vector_uint64.
    //
    
    VectorBasic& vector_uint64(::std::vector<uint64_t> value);
    
      const ::std::vector<int8_t> &
    vector_int8() const {
      return storage_.vector_int8;
    }

    
    ::std::vector<int8_t>& vector_int8() {
      return storage_.vector_int8;
    }

    // Setter for vector_int8.
    //
    
    VectorBasic& vector_int8(::std::vector<int8_t> value);
    
      const ::std::vector<int16_t> &
    vector_int16() const {
      return storage_.vector_int16;
    }

    
    ::std::vector<int16_t>& vector_int16() {
      return storage_.vector_int16;
    }

    // Setter for vector_int16.
    //
    
    VectorBasic& vector_int16(::std::vector<int16_t> value);
    
      const ::std::vector<int32_t> &
    vector_int32() const {
      return storage_.vector_int32;
    }

    
    ::std::vector<int32_t>& vector_int32() {
      return storage_.vector_int32;
    }

    // Setter for vector_int32.
    //
    
    VectorBasic& vector_int32(::std::vector<int32_t> value);
    
      const ::std::vector<int64_t> &
    vector_int64() const {
      return storage_.vector_int64;
    }

    
    ::std::vector<int64_t>& vector_int64() {
      return storage_.vector_int64;
    }

    // Setter for vector_int64.
    //
    
    VectorBasic& vector_int64(::std::vector<int64_t> value);
    
      const ::std::vector<float> &
    vector_float32() const {
      return storage_.vector_float32;
    }

    
    ::std::vector<float>& vector_float32() {
      return storage_.vector_float32;
    }

    // Setter for vector_float32.
    //
    
    VectorBasic& vector_float32(::std::vector<float> value);
    
      const ::std::vector<double> &
    vector_float64() const {
      return storage_.vector_float64;
    }

    
    ::std::vector<double>& vector_float64() {
      return storage_.vector_float64;
    }

    // Setter for vector_float64.
    //
    
    VectorBasic& vector_float64(::std::vector<double> value);
    
      const ::std::vector<::std::string> &
    vector_string() const {
      return storage_.vector_string;
    }

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

    // Setter for vector_string.
    //
    
    VectorBasic& vector_string(::std::vector<::std::string> value);
    
      const ::std::vector<::std::optional<::std::string>> &
    vector_opt_string() const {
      return storage_.vector_opt_string;
    }

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

    // Setter for vector_opt_string.
    //
    
    VectorBasic& vector_opt_string(::std::vector<::std::optional<::std::string>> value);

  VectorBasic(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag);

 private:
  struct Storage_ final {
      ::std::vector<uint8_t> vector_uint8;
      ::std::vector<uint16_t> vector_uint16;
      ::std::vector<uint32_t> vector_uint32;
      ::std::vector<uint64_t> vector_uint64;
      ::std::vector<int8_t> vector_int8;
      ::std::vector<int16_t> vector_int16;
      ::std::vector<int32_t> vector_int32;
      ::std::vector<int64_t> vector_int64;
      ::std::vector<float> vector_float32;
      ::std::vector<double> vector_float64;
      ::std::vector<::std::string> vector_string;
      ::std::vector<::std::optional<::std::string>> vector_opt_string;
  };

  Storage_ storage_;
    Storage_ CloneStorage_() const;

  friend struct ::fidl::internal::NaturalStructCodingTraits<::test_typesinprotocols::VectorBasic, 192>;
  friend struct ::fidl::internal::MemberVisitor<::test_typesinprotocols::VectorBasic>;
  static constexpr auto kMembers = std::make_tuple(::fidl::internal::NaturalStructMember<Storage_, ::std::vector<uint8_t>, fidl::internal::NaturalCodingConstraintVector<fidl::internal::NaturalCodingConstraintEmpty>>{
        &Storage_::vector_uint8, 0
      }, ::fidl::internal::NaturalStructMember<Storage_, ::std::vector<uint16_t>, fidl::internal::NaturalCodingConstraintVector<fidl::internal::NaturalCodingConstraintEmpty>>{
        &Storage_::vector_uint16, 16
      }, ::fidl::internal::NaturalStructMember<Storage_, ::std::vector<uint32_t>, fidl::internal::NaturalCodingConstraintVector<fidl::internal::NaturalCodingConstraintEmpty>>{
        &Storage_::vector_uint32, 32
      }, ::fidl::internal::NaturalStructMember<Storage_, ::std::vector<uint64_t>, fidl::internal::NaturalCodingConstraintVector<fidl::internal::NaturalCodingConstraintEmpty>>{
        &Storage_::vector_uint64, 48
      }, ::fidl::internal::NaturalStructMember<Storage_, ::std::vector<int8_t>, fidl::internal::NaturalCodingConstraintVector<fidl::internal::NaturalCodingConstraintEmpty>>{
        &Storage_::vector_int8, 64
      }, ::fidl::internal::NaturalStructMember<Storage_, ::std::vector<int16_t>, fidl::internal::NaturalCodingConstraintVector<fidl::internal::NaturalCodingConstraintEmpty>>{
        &Storage_::vector_int16, 80
      }, ::fidl::internal::NaturalStructMember<Storage_, ::std::vector<int32_t>, fidl::internal::NaturalCodingConstraintVector<fidl::internal::NaturalCodingConstraintEmpty>>{
        &Storage_::vector_int32, 96
      }, ::fidl::internal::NaturalStructMember<Storage_, ::std::vector<int64_t>, fidl::internal::NaturalCodingConstraintVector<fidl::internal::NaturalCodingConstraintEmpty>>{
        &Storage_::vector_int64, 112
      }, ::fidl::internal::NaturalStructMember<Storage_, ::std::vector<float>, fidl::internal::NaturalCodingConstraintVector<fidl::internal::NaturalCodingConstraintEmpty>>{
        &Storage_::vector_float32, 128
      }, ::fidl::internal::NaturalStructMember<Storage_, ::std::vector<double>, fidl::internal::NaturalCodingConstraintVector<fidl::internal::NaturalCodingConstraintEmpty>>{
        &Storage_::vector_float64, 144
      }, ::fidl::internal::NaturalStructMember<Storage_, ::std::vector<::std::string>, fidl::internal::NaturalCodingConstraintVector<fidl::internal::NaturalCodingConstraintString<>>>{
        &Storage_::vector_string, 160
      }, ::fidl::internal::NaturalStructMember<Storage_, ::std::vector<::std::optional<::std::string>>, fidl::internal::NaturalCodingConstraintVector<fidl::internal::NaturalCodingConstraintString<>>>{
        &Storage_::vector_opt_string, 176
      });
  static constexpr auto kPadding = std::make_tuple();

};


class VectorCompound {
 private:
  struct Storage_;
 public:
  VectorCompound(Storage_ storage) noexcept;
    VectorCompound(::std::vector<::test_typesinprotocols::Bits> vector_bits, ::std::vector<::test_typesinprotocols::Enum> vector_enum, ::std::vector<::test_typesinprotocols::Struct> vector_struct, ::std::vector<::test_typesinprotocols::Table> vector_table, ::std::vector<::test_typesinprotocols::Union> vector_union, ::std::vector<::fidl::Box<::test_typesinprotocols::Struct>> vector_opt_struct, ::std::vector<::fidl::Box<::test_typesinprotocols::Union>> vector_opt_union) noexcept;

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

  VectorCompound(VectorCompound&&) noexcept = default;
  VectorCompound& operator=(VectorCompound&&) noexcept = default;
    VectorCompound(const VectorCompound& other) noexcept;
    VectorCompound& operator=(const VectorCompound& other) noexcept;

    bool operator==(const VectorCompound& other) const noexcept {
      return ::fidl::internal::NaturalStructCodingTraits<::test_typesinprotocols::VectorCompound, 112>::Equal(this, &other);
    }
    bool operator!=(const VectorCompound& other) const noexcept {
      return !::fidl::internal::NaturalStructCodingTraits<::test_typesinprotocols::VectorCompound, 112>::Equal(this, &other);
    }
    
      const ::std::vector<::test_typesinprotocols::Bits> &
    vector_bits() const {
      return storage_.vector_bits;
    }

    
    ::std::vector<::test_typesinprotocols::Bits>& vector_bits() {
      return storage_.vector_bits;
    }

    // Setter for vector_bits.
    //
    
    VectorCompound& vector_bits(::std::vector<::test_typesinprotocols::Bits> value);
    
      const ::std::vector<::test_typesinprotocols::Enum> &
    vector_enum() const {
      return storage_.vector_enum;
    }

    
    ::std::vector<::test_typesinprotocols::Enum>& vector_enum() {
      return storage_.vector_enum;
    }

    // Setter for vector_enum.
    //
    
    VectorCompound& vector_enum(::std::vector<::test_typesinprotocols::Enum> value);
    
      const ::std::vector<::test_typesinprotocols::Struct> &
    vector_struct() const {
      return storage_.vector_struct;
    }

    
    ::std::vector<::test_typesinprotocols::Struct>& vector_struct() {
      return storage_.vector_struct;
    }

    // Setter for vector_struct.
    //
    
    VectorCompound& vector_struct(::std::vector<::test_typesinprotocols::Struct> value);
    
      const ::std::vector<::test_typesinprotocols::Table> &
    vector_table() const {
      return storage_.vector_table;
    }

    
    ::std::vector<::test_typesinprotocols::Table>& vector_table() {
      return storage_.vector_table;
    }

    // Setter for vector_table.
    //
    
    VectorCompound& vector_table(::std::vector<::test_typesinprotocols::Table> value);
    
      const ::std::vector<::test_typesinprotocols::Union> &
    vector_union() const {
      return storage_.vector_union;
    }

    
    ::std::vector<::test_typesinprotocols::Union>& vector_union() {
      return storage_.vector_union;
    }

    // Setter for vector_union.
    //
    
    VectorCompound& vector_union(::std::vector<::test_typesinprotocols::Union> value);
    
      const ::std::vector<::fidl::Box<::test_typesinprotocols::Struct>> &
    vector_opt_struct() const {
      return storage_.vector_opt_struct;
    }

    
    ::std::vector<::fidl::Box<::test_typesinprotocols::Struct>>& vector_opt_struct() {
      return storage_.vector_opt_struct;
    }

    // Setter for vector_opt_struct.
    //
    
    VectorCompound& vector_opt_struct(::std::vector<::fidl::Box<::test_typesinprotocols::Struct>> value);
    
      const ::std::vector<::fidl::Box<::test_typesinprotocols::Union>> &
    vector_opt_union() const {
      return storage_.vector_opt_union;
    }

    
    ::std::vector<::fidl::Box<::test_typesinprotocols::Union>>& vector_opt_union() {
      return storage_.vector_opt_union;
    }

    // Setter for vector_opt_union.
    //
    
    VectorCompound& vector_opt_union(::std::vector<::fidl::Box<::test_typesinprotocols::Union>> value);

  VectorCompound(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag);

 private:
  struct Storage_ final {
      ::std::vector<::test_typesinprotocols::Bits> vector_bits;
      ::std::vector<::test_typesinprotocols::Enum> vector_enum;
      ::std::vector<::test_typesinprotocols::Struct> vector_struct;
      ::std::vector<::test_typesinprotocols::Table> vector_table;
      ::std::vector<::test_typesinprotocols::Union> vector_union;
      ::std::vector<::fidl::Box<::test_typesinprotocols::Struct>> vector_opt_struct;
      ::std::vector<::fidl::Box<::test_typesinprotocols::Union>> vector_opt_union;
  };

  Storage_ storage_;
    Storage_ CloneStorage_() const;

  friend struct ::fidl::internal::NaturalStructCodingTraits<::test_typesinprotocols::VectorCompound, 112>;
  friend struct ::fidl::internal::MemberVisitor<::test_typesinprotocols::VectorCompound>;
  static constexpr auto kMembers = std::make_tuple(::fidl::internal::NaturalStructMember<Storage_, ::std::vector<::test_typesinprotocols::Bits>, fidl::internal::NaturalCodingConstraintVector<fidl::internal::NaturalCodingConstraintEmpty>>{
        &Storage_::vector_bits, 0
      }, ::fidl::internal::NaturalStructMember<Storage_, ::std::vector<::test_typesinprotocols::Enum>, fidl::internal::NaturalCodingConstraintVector<fidl::internal::NaturalCodingConstraintEmpty>>{
        &Storage_::vector_enum, 16
      }, ::fidl::internal::NaturalStructMember<Storage_, ::std::vector<::test_typesinprotocols::Struct>, fidl::internal::NaturalCodingConstraintVector<fidl::internal::NaturalCodingConstraintEmpty>>{
        &Storage_::vector_struct, 32
      }, ::fidl::internal::NaturalStructMember<Storage_, ::std::vector<::test_typesinprotocols::Table>, fidl::internal::NaturalCodingConstraintVector<fidl::internal::NaturalCodingConstraintEmpty>>{
        &Storage_::vector_table, 48
      }, ::fidl::internal::NaturalStructMember<Storage_, ::std::vector<::test_typesinprotocols::Union>, fidl::internal::NaturalCodingConstraintVector<fidl::internal::NaturalCodingConstraintEmpty>>{
        &Storage_::vector_union, 64
      }, ::fidl::internal::NaturalStructMember<Storage_, ::std::vector<::fidl::Box<::test_typesinprotocols::Struct>>, fidl::internal::NaturalCodingConstraintVector<fidl::internal::NaturalCodingConstraintEmpty>>{
        &Storage_::vector_opt_struct, 80
      }, ::fidl::internal::NaturalStructMember<Storage_, ::std::vector<::fidl::Box<::test_typesinprotocols::Union>>, fidl::internal::NaturalCodingConstraintVector<fidl::internal::NaturalCodingConstraintEmpty>>{
        &Storage_::vector_opt_union, 96
      });
  static constexpr auto kPadding = std::make_tuple();

};


class VectorOptional {
 private:
  struct Storage_;
 public:
  VectorOptional(Storage_ storage) noexcept;
    VectorOptional(::std::optional<::std::vector<uint8_t>> opt_vector_uint8, ::std::optional<::std::vector<::std::string>> opt_vector_string, ::std::optional<::std::vector<::test_typesinprotocols::Struct>> opt_vector_struct, ::std::optional<::std::vector<::fidl::Box<::test_typesinprotocols::Struct>>> opt_vector_opt_struct) noexcept;

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

  VectorOptional(VectorOptional&&) noexcept = default;
  VectorOptional& operator=(VectorOptional&&) noexcept = default;
    VectorOptional(const VectorOptional& other) noexcept;
    VectorOptional& operator=(const VectorOptional& other) noexcept;

    bool operator==(const VectorOptional& other) const noexcept {
      return ::fidl::internal::NaturalStructCodingTraits<::test_typesinprotocols::VectorOptional, 64>::Equal(this, &other);
    }
    bool operator!=(const VectorOptional& other) const noexcept {
      return !::fidl::internal::NaturalStructCodingTraits<::test_typesinprotocols::VectorOptional, 64>::Equal(this, &other);
    }
    
      const ::std::optional<::std::vector<uint8_t>> &
    opt_vector_uint8() const {
      return storage_.opt_vector_uint8;
    }

    
    ::std::optional<::std::vector<uint8_t>>& opt_vector_uint8() {
      return storage_.opt_vector_uint8;
    }

    // Setter for opt_vector_uint8.
    //
    
    VectorOptional& opt_vector_uint8(::std::optional<::std::vector<uint8_t>> value);
    
      const ::std::optional<::std::vector<::std::string>> &
    opt_vector_string() const {
      return storage_.opt_vector_string;
    }

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

    // Setter for opt_vector_string.
    //
    
    VectorOptional& opt_vector_string(::std::optional<::std::vector<::std::string>> value);
    
      const ::std::optional<::std::vector<::test_typesinprotocols::Struct>> &
    opt_vector_struct() const {
      return storage_.opt_vector_struct;
    }

    
    ::std::optional<::std::vector<::test_typesinprotocols::Struct>>& opt_vector_struct() {
      return storage_.opt_vector_struct;
    }

    // Setter for opt_vector_struct.
    //
    
    VectorOptional& opt_vector_struct(::std::optional<::std::vector<::test_typesinprotocols::Struct>> value);
    
      const ::std::optional<::std::vector<::fidl::Box<::test_typesinprotocols::Struct>>> &
    opt_vector_opt_struct() const {
      return storage_.opt_vector_opt_struct;
    }

    
    ::std::optional<::std::vector<::fidl::Box<::test_typesinprotocols::Struct>>>& opt_vector_opt_struct() {
      return storage_.opt_vector_opt_struct;
    }

    // Setter for opt_vector_opt_struct.
    //
    
    VectorOptional& opt_vector_opt_struct(::std::optional<::std::vector<::fidl::Box<::test_typesinprotocols::Struct>>> value);

  VectorOptional(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag);

 private:
  struct Storage_ final {
      ::std::optional<::std::vector<uint8_t>> opt_vector_uint8;
      ::std::optional<::std::vector<::std::string>> opt_vector_string;
      ::std::optional<::std::vector<::test_typesinprotocols::Struct>> opt_vector_struct;
      ::std::optional<::std::vector<::fidl::Box<::test_typesinprotocols::Struct>>> opt_vector_opt_struct;
  };

  Storage_ storage_;
    Storage_ CloneStorage_() const;

  friend struct ::fidl::internal::NaturalStructCodingTraits<::test_typesinprotocols::VectorOptional, 64>;
  friend struct ::fidl::internal::MemberVisitor<::test_typesinprotocols::VectorOptional>;
  static constexpr auto kMembers = std::make_tuple(::fidl::internal::NaturalStructMember<Storage_, ::std::optional<::std::vector<uint8_t>>, fidl::internal::NaturalCodingConstraintVector<fidl::internal::NaturalCodingConstraintEmpty>>{
        &Storage_::opt_vector_uint8, 0
      }, ::fidl::internal::NaturalStructMember<Storage_, ::std::optional<::std::vector<::std::string>>, fidl::internal::NaturalCodingConstraintVector<fidl::internal::NaturalCodingConstraintString<>>>{
        &Storage_::opt_vector_string, 16
      }, ::fidl::internal::NaturalStructMember<Storage_, ::std::optional<::std::vector<::test_typesinprotocols::Struct>>, fidl::internal::NaturalCodingConstraintVector<fidl::internal::NaturalCodingConstraintEmpty>>{
        &Storage_::opt_vector_struct, 32
      }, ::fidl::internal::NaturalStructMember<Storage_, ::std::optional<::std::vector<::fidl::Box<::test_typesinprotocols::Struct>>>, fidl::internal::NaturalCodingConstraintVector<fidl::internal::NaturalCodingConstraintEmpty>>{
        &Storage_::opt_vector_opt_struct, 48
      });
  static constexpr auto kPadding = std::make_tuple();

};


class ArrayVectorNested {
 private:
  struct Storage_;
 public:
  ArrayVectorNested(Storage_ storage) noexcept;
    ArrayVectorNested(::std::array<::std::array<uint8_t, 5>, 5> array_array_uint8, ::std::array<::std::vector<uint8_t>, 5> array_vector_uint8, ::std::vector<::std::array<uint8_t, 5>> vector_array_uint8, ::std::vector<::std::vector<uint8_t>> vector_vector_uint8) noexcept;

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

  ArrayVectorNested(ArrayVectorNested&&) noexcept = default;
  ArrayVectorNested& operator=(ArrayVectorNested&&) noexcept = default;
    ArrayVectorNested(const ArrayVectorNested& other) noexcept;
    ArrayVectorNested& operator=(const ArrayVectorNested& other) noexcept;

    bool operator==(const ArrayVectorNested& other) const noexcept {
      return ::fidl::internal::NaturalStructCodingTraits<::test_typesinprotocols::ArrayVectorNested, 144>::Equal(this, &other);
    }
    bool operator!=(const ArrayVectorNested& other) const noexcept {
      return !::fidl::internal::NaturalStructCodingTraits<::test_typesinprotocols::ArrayVectorNested, 144>::Equal(this, &other);
    }
    
      const ::std::array<::std::array<uint8_t, 5>, 5> &
    array_array_uint8() const {
      return storage_.array_array_uint8;
    }

    
    ::std::array<::std::array<uint8_t, 5>, 5>& array_array_uint8() {
      return storage_.array_array_uint8;
    }

    // Setter for array_array_uint8.
    //
    
    ArrayVectorNested& array_array_uint8(::std::array<::std::array<uint8_t, 5>, 5> value);
    
      const ::std::array<::std::vector<uint8_t>, 5> &
    array_vector_uint8() const {
      return storage_.array_vector_uint8;
    }

    
    ::std::array<::std::vector<uint8_t>, 5>& array_vector_uint8() {
      return storage_.array_vector_uint8;
    }

    // Setter for array_vector_uint8.
    //
    
    ArrayVectorNested& array_vector_uint8(::std::array<::std::vector<uint8_t>, 5> value);
    
      const ::std::vector<::std::array<uint8_t, 5>> &
    vector_array_uint8() const {
      return storage_.vector_array_uint8;
    }

    
    ::std::vector<::std::array<uint8_t, 5>>& vector_array_uint8() {
      return storage_.vector_array_uint8;
    }

    // Setter for vector_array_uint8.
    //
    
    ArrayVectorNested& vector_array_uint8(::std::vector<::std::array<uint8_t, 5>> value);
    
      const ::std::vector<::std::vector<uint8_t>> &
    vector_vector_uint8() const {
      return storage_.vector_vector_uint8;
    }

    
    ::std::vector<::std::vector<uint8_t>>& vector_vector_uint8() {
      return storage_.vector_vector_uint8;
    }

    // Setter for vector_vector_uint8.
    //
    
    ArrayVectorNested& vector_vector_uint8(::std::vector<::std::vector<uint8_t>> value);

  ArrayVectorNested(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag);

 private:
  struct Storage_ final {
      ::std::array<::std::array<uint8_t, 5>, 5> array_array_uint8
        = {};
      ::std::array<::std::vector<uint8_t>, 5> array_vector_uint8;
      ::std::vector<::std::array<uint8_t, 5>> vector_array_uint8;
      ::std::vector<::std::vector<uint8_t>> vector_vector_uint8;
  };

  Storage_ storage_;
    Storage_ CloneStorage_() const;

  friend struct ::fidl::internal::NaturalStructCodingTraits<::test_typesinprotocols::ArrayVectorNested, 144>;
  friend struct ::fidl::internal::MemberVisitor<::test_typesinprotocols::ArrayVectorNested>;
  static constexpr auto kMembers = std::make_tuple(::fidl::internal::NaturalStructMember<Storage_, ::std::array<::std::array<uint8_t, 5>, 5>, fidl::internal::NaturalCodingConstraintEmpty>{
        &Storage_::array_array_uint8, 0
      }, ::fidl::internal::NaturalStructMember<Storage_, ::std::array<::std::vector<uint8_t>, 5>, fidl::internal::NaturalCodingConstraintVector<fidl::internal::NaturalCodingConstraintEmpty>>{
        &Storage_::array_vector_uint8, 32
      }, ::fidl::internal::NaturalStructMember<Storage_, ::std::vector<::std::array<uint8_t, 5>>, fidl::internal::NaturalCodingConstraintVector<fidl::internal::NaturalCodingConstraintEmpty>>{
        &Storage_::vector_array_uint8, 112
      }, ::fidl::internal::NaturalStructMember<Storage_, ::std::vector<::std::vector<uint8_t>>, fidl::internal::NaturalCodingConstraintVector<fidl::internal::NaturalCodingConstraintVector<fidl::internal::NaturalCodingConstraintEmpty>>>{
        &Storage_::vector_vector_uint8, 128
      });
  static constexpr auto kPadding = std::make_tuple(::fidl::internal::NaturalStructPadding<uint64_t>{
        .offset = 24,
        .mask = 0xffffffffffffff00,
      });

};


#ifdef __Fuchsia__


class Resource {
 private:
  struct Storage_;
 public:
  Resource(Storage_ storage) noexcept;
    Resource(::zx::handle handle, ::zx::vmo vmo, ::fidl::ClientEnd<::test_typesinprotocols::Protocol> client_end, ::fidl::ServerEnd<::test_typesinprotocols::Protocol> server_end, ::test_typesinprotocols::ResourceStruct struct_, ::test_typesinprotocols::ResourceTable table, ::test_typesinprotocols::ResourceUnion union_, ::zx::handle opt_handle, ::zx::vmo opt_vmo, ::fidl::ClientEnd<::test_typesinprotocols::Protocol> opt_client_end, ::fidl::ServerEnd<::test_typesinprotocols::Protocol> opt_server_end, ::fidl::Box<::test_typesinprotocols::ResourceStruct> opt_struct, ::fidl::Box<::test_typesinprotocols::ResourceUnion> opt_union, ::std::array<::zx::handle, 5> array_handle, ::std::array<::zx::vmo, 5> array_vmo, ::std::array<::fidl::ClientEnd<::test_typesinprotocols::Protocol>, 5> array_client_end, ::std::array<::fidl::ServerEnd<::test_typesinprotocols::Protocol>, 5> array_server_end, ::std::array<::test_typesinprotocols::ResourceStruct, 5> array_struct, ::std::array<::test_typesinprotocols::ResourceTable, 5> array_table, ::std::array<::test_typesinprotocols::ResourceUnion, 5> array_union, ::std::vector<::zx::handle> vector_handle, ::std::vector<::zx::vmo> vector_vmo, ::std::vector<::fidl::ClientEnd<::test_typesinprotocols::Protocol>> vector_client_end, ::std::vector<::fidl::ServerEnd<::test_typesinprotocols::Protocol>> vector_server_end, ::std::vector<::test_typesinprotocols::ResourceStruct> vector_struct, ::std::vector<::test_typesinprotocols::ResourceTable> vector_table, ::std::vector<::test_typesinprotocols::ResourceUnion> vector_union) noexcept;

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

  Resource(Resource&&) noexcept = default;
  Resource& operator=(Resource&&) noexcept = default;
    
      const ::zx::handle &
    handle() const {
      return storage_.handle;
    }

    
    ::zx::handle& handle() {
      return storage_.handle;
    }

    // Setter for handle.
    //
    
    Resource& handle(::zx::handle value);
    
      const ::zx::vmo &
    vmo() const {
      return storage_.vmo;
    }

    
    ::zx::vmo& vmo() {
      return storage_.vmo;
    }

    // Setter for vmo.
    //
    
    Resource& vmo(::zx::vmo value);
    
      const ::fidl::ClientEnd<::test_typesinprotocols::Protocol> &
    client_end() const {
      return storage_.client_end;
    }

    
    ::fidl::ClientEnd<::test_typesinprotocols::Protocol>& client_end() {
      return storage_.client_end;
    }

    // Setter for client_end.
    //
    
    Resource& client_end(::fidl::ClientEnd<::test_typesinprotocols::Protocol> value);
    
      const ::fidl::ServerEnd<::test_typesinprotocols::Protocol> &
    server_end() const {
      return storage_.server_end;
    }

    
    ::fidl::ServerEnd<::test_typesinprotocols::Protocol>& server_end() {
      return storage_.server_end;
    }

    // Setter for server_end.
    //
    
    Resource& server_end(::fidl::ServerEnd<::test_typesinprotocols::Protocol> value);
    
      const ::test_typesinprotocols::ResourceStruct &
    struct_() const {
      return storage_.struct_;
    }

    
    ::test_typesinprotocols::ResourceStruct& struct_() {
      return storage_.struct_;
    }

    // Setter for struct_.
    //
    
    Resource& struct_(::test_typesinprotocols::ResourceStruct value);
    
      const ::test_typesinprotocols::ResourceTable &
    table() const {
      return storage_.table;
    }

    
    ::test_typesinprotocols::ResourceTable& table() {
      return storage_.table;
    }

    // Setter for table.
    //
    
    Resource& table(::test_typesinprotocols::ResourceTable value);
    
      const ::test_typesinprotocols::ResourceUnion &
    union_() const {
      return storage_.union_;
    }

    
    ::test_typesinprotocols::ResourceUnion& union_() {
      return storage_.union_;
    }

    // Setter for union_.
    //
    
    Resource& union_(::test_typesinprotocols::ResourceUnion value);
    
      const ::zx::handle &
    opt_handle() const {
      return storage_.opt_handle;
    }

    
    ::zx::handle& opt_handle() {
      return storage_.opt_handle;
    }

    // Setter for opt_handle.
    //
    
    Resource& opt_handle(::zx::handle value);
    
      const ::zx::vmo &
    opt_vmo() const {
      return storage_.opt_vmo;
    }

    
    ::zx::vmo& opt_vmo() {
      return storage_.opt_vmo;
    }

    // Setter for opt_vmo.
    //
    
    Resource& opt_vmo(::zx::vmo value);
    
      const ::fidl::ClientEnd<::test_typesinprotocols::Protocol> &
    opt_client_end() const {
      return storage_.opt_client_end;
    }

    
    ::fidl::ClientEnd<::test_typesinprotocols::Protocol>& opt_client_end() {
      return storage_.opt_client_end;
    }

    // Setter for opt_client_end.
    //
    
    Resource& opt_client_end(::fidl::ClientEnd<::test_typesinprotocols::Protocol> value);
    
      const ::fidl::ServerEnd<::test_typesinprotocols::Protocol> &
    opt_server_end() const {
      return storage_.opt_server_end;
    }

    
    ::fidl::ServerEnd<::test_typesinprotocols::Protocol>& opt_server_end() {
      return storage_.opt_server_end;
    }

    // Setter for opt_server_end.
    //
    
    Resource& opt_server_end(::fidl::ServerEnd<::test_typesinprotocols::Protocol> value);
    
      const ::fidl::Box<::test_typesinprotocols::ResourceStruct> &
    opt_struct() const {
      return storage_.opt_struct;
    }

    
    ::fidl::Box<::test_typesinprotocols::ResourceStruct>& opt_struct() {
      return storage_.opt_struct;
    }

    // Setter for opt_struct.
    //
    
    Resource& opt_struct(::fidl::Box<::test_typesinprotocols::ResourceStruct> value);
    
      const ::fidl::Box<::test_typesinprotocols::ResourceUnion> &
    opt_union() const {
      return storage_.opt_union;
    }

    
    ::fidl::Box<::test_typesinprotocols::ResourceUnion>& opt_union() {
      return storage_.opt_union;
    }

    // Setter for opt_union.
    //
    
    Resource& opt_union(::fidl::Box<::test_typesinprotocols::ResourceUnion> value);
    
      const ::std::array<::zx::handle, 5> &
    array_handle() const {
      return storage_.array_handle;
    }

    
    ::std::array<::zx::handle, 5>& array_handle() {
      return storage_.array_handle;
    }

    // Setter for array_handle.
    //
    
    Resource& array_handle(::std::array<::zx::handle, 5> value);
    
      const ::std::array<::zx::vmo, 5> &
    array_vmo() const {
      return storage_.array_vmo;
    }

    
    ::std::array<::zx::vmo, 5>& array_vmo() {
      return storage_.array_vmo;
    }

    // Setter for array_vmo.
    //
    
    Resource& array_vmo(::std::array<::zx::vmo, 5> value);
    
      const ::std::array<::fidl::ClientEnd<::test_typesinprotocols::Protocol>, 5> &
    array_client_end() const {
      return storage_.array_client_end;
    }

    
    ::std::array<::fidl::ClientEnd<::test_typesinprotocols::Protocol>, 5>& array_client_end() {
      return storage_.array_client_end;
    }

    // Setter for array_client_end.
    //
    
    Resource& array_client_end(::std::array<::fidl::ClientEnd<::test_typesinprotocols::Protocol>, 5> value);
    
      const ::std::array<::fidl::ServerEnd<::test_typesinprotocols::Protocol>, 5> &
    array_server_end() const {
      return storage_.array_server_end;
    }

    
    ::std::array<::fidl::ServerEnd<::test_typesinprotocols::Protocol>, 5>& array_server_end() {
      return storage_.array_server_end;
    }

    // Setter for array_server_end.
    //
    
    Resource& array_server_end(::std::array<::fidl::ServerEnd<::test_typesinprotocols::Protocol>, 5> value);
    
      const ::std::array<::test_typesinprotocols::ResourceStruct, 5> &
    array_struct() const {
      return storage_.array_struct;
    }

    
    ::std::array<::test_typesinprotocols::ResourceStruct, 5>& array_struct() {
      return storage_.array_struct;
    }

    // Setter for array_struct.
    //
    
    Resource& array_struct(::std::array<::test_typesinprotocols::ResourceStruct, 5> value);
    
      const ::std::array<::test_typesinprotocols::ResourceTable, 5> &
    array_table() const {
      return storage_.array_table;
    }

    
    ::std::array<::test_typesinprotocols::ResourceTable, 5>& array_table() {
      return storage_.array_table;
    }

    // Setter for array_table.
    //
    
    Resource& array_table(::std::array<::test_typesinprotocols::ResourceTable, 5> value);
    
      const ::std::array<::test_typesinprotocols::ResourceUnion, 5> &
    array_union() const {
      return storage_.array_union;
    }

    
    ::std::array<::test_typesinprotocols::ResourceUnion, 5>& array_union() {
      return storage_.array_union;
    }

    // Setter for array_union.
    //
    
    Resource& array_union(::std::array<::test_typesinprotocols::ResourceUnion, 5> value);
    
      const ::std::vector<::zx::handle> &
    vector_handle() const {
      return storage_.vector_handle;
    }

    
    ::std::vector<::zx::handle>& vector_handle() {
      return storage_.vector_handle;
    }

    // Setter for vector_handle.
    //
    
    Resource& vector_handle(::std::vector<::zx::handle> value);
    
      const ::std::vector<::zx::vmo> &
    vector_vmo() const {
      return storage_.vector_vmo;
    }

    
    ::std::vector<::zx::vmo>& vector_vmo() {
      return storage_.vector_vmo;
    }

    // Setter for vector_vmo.
    //
    
    Resource& vector_vmo(::std::vector<::zx::vmo> value);
    
      const ::std::vector<::fidl::ClientEnd<::test_typesinprotocols::Protocol>> &
    vector_client_end() const {
      return storage_.vector_client_end;
    }

    
    ::std::vector<::fidl::ClientEnd<::test_typesinprotocols::Protocol>>& vector_client_end() {
      return storage_.vector_client_end;
    }

    // Setter for vector_client_end.
    //
    
    Resource& vector_client_end(::std::vector<::fidl::ClientEnd<::test_typesinprotocols::Protocol>> value);
    
      const ::std::vector<::fidl::ServerEnd<::test_typesinprotocols::Protocol>> &
    vector_server_end() const {
      return storage_.vector_server_end;
    }

    
    ::std::vector<::fidl::ServerEnd<::test_typesinprotocols::Protocol>>& vector_server_end() {
      return storage_.vector_server_end;
    }

    // Setter for vector_server_end.
    //
    
    Resource& vector_server_end(::std::vector<::fidl::ServerEnd<::test_typesinprotocols::Protocol>> value);
    
      const ::std::vector<::test_typesinprotocols::ResourceStruct> &
    vector_struct() const {
      return storage_.vector_struct;
    }

    
    ::std::vector<::test_typesinprotocols::ResourceStruct>& vector_struct() {
      return storage_.vector_struct;
    }

    // Setter for vector_struct.
    //
    
    Resource& vector_struct(::std::vector<::test_typesinprotocols::ResourceStruct> value);
    
      const ::std::vector<::test_typesinprotocols::ResourceTable> &
    vector_table() const {
      return storage_.vector_table;
    }

    
    ::std::vector<::test_typesinprotocols::ResourceTable>& vector_table() {
      return storage_.vector_table;
    }

    // Setter for vector_table.
    //
    
    Resource& vector_table(::std::vector<::test_typesinprotocols::ResourceTable> value);
    
      const ::std::vector<::test_typesinprotocols::ResourceUnion> &
    vector_union() const {
      return storage_.vector_union;
    }

    
    ::std::vector<::test_typesinprotocols::ResourceUnion>& vector_union() {
      return storage_.vector_union;
    }

    // Setter for vector_union.
    //
    
    Resource& vector_union(::std::vector<::test_typesinprotocols::ResourceUnion> value);

  Resource(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag);

 private:
  struct Storage_ final {
      ::zx::handle handle;
      ::zx::vmo vmo;
      ::fidl::ClientEnd<::test_typesinprotocols::Protocol> client_end;
      ::fidl::ServerEnd<::test_typesinprotocols::Protocol> server_end;
      ::test_typesinprotocols::ResourceStruct struct_;
      ::test_typesinprotocols::ResourceTable table;
      ::test_typesinprotocols::ResourceUnion union_;
      ::zx::handle opt_handle;
      ::zx::vmo opt_vmo;
      ::fidl::ClientEnd<::test_typesinprotocols::Protocol> opt_client_end;
      ::fidl::ServerEnd<::test_typesinprotocols::Protocol> opt_server_end;
      ::fidl::Box<::test_typesinprotocols::ResourceStruct> opt_struct;
      ::fidl::Box<::test_typesinprotocols::ResourceUnion> opt_union;
      ::std::array<::zx::handle, 5> array_handle;
      ::std::array<::zx::vmo, 5> array_vmo;
      ::std::array<::fidl::ClientEnd<::test_typesinprotocols::Protocol>, 5> array_client_end;
      ::std::array<::fidl::ServerEnd<::test_typesinprotocols::Protocol>, 5> array_server_end;
      ::std::array<::test_typesinprotocols::ResourceStruct, 5> array_struct;
      ::std::array<::test_typesinprotocols::ResourceTable, 5> array_table;
      ::std::array<::test_typesinprotocols::ResourceUnion, 5> array_union;
      ::std::vector<::zx::handle> vector_handle;
      ::std::vector<::zx::vmo> vector_vmo;
      ::std::vector<::fidl::ClientEnd<::test_typesinprotocols::Protocol>> vector_client_end;
      ::std::vector<::fidl::ServerEnd<::test_typesinprotocols::Protocol>> vector_server_end;
      ::std::vector<::test_typesinprotocols::ResourceStruct> vector_struct;
      ::std::vector<::test_typesinprotocols::ResourceTable> vector_table;
      ::std::vector<::test_typesinprotocols::ResourceUnion> vector_union;
  };

  Storage_ storage_;

  friend struct ::fidl::internal::NaturalStructCodingTraits<::test_typesinprotocols::Resource, 456>;
  friend struct ::fidl::internal::MemberVisitor<::test_typesinprotocols::Resource>;
  static constexpr auto kMembers = std::make_tuple(::fidl::internal::NaturalStructMember<Storage_, ::zx::handle, fidl::internal::NaturalCodingConstraintHandle<ZX_OBJ_TYPE_NONE, 0x80000000, false>>{
        &Storage_::handle, 0
      }, ::fidl::internal::NaturalStructMember<Storage_, ::zx::vmo, fidl::internal::NaturalCodingConstraintHandle<ZX_OBJ_TYPE_VMO, 0x80000000, false>>{
        &Storage_::vmo, 4
      }, ::fidl::internal::NaturalStructMember<Storage_, ::fidl::ClientEnd<::test_typesinprotocols::Protocol>, fidl::internal::NaturalCodingConstraintHandle<ZX_OBJ_TYPE_CHANNEL, ZX_DEFAULT_CHANNEL_RIGHTS, false>>{
        &Storage_::client_end, 8
      }, ::fidl::internal::NaturalStructMember<Storage_, ::fidl::ServerEnd<::test_typesinprotocols::Protocol>, fidl::internal::NaturalCodingConstraintHandle<ZX_OBJ_TYPE_CHANNEL, ZX_DEFAULT_CHANNEL_RIGHTS, false>>{
        &Storage_::server_end, 12
      }, ::fidl::internal::NaturalStructMember<Storage_, ::test_typesinprotocols::ResourceStruct, fidl::internal::NaturalCodingConstraintEmpty>{
        &Storage_::struct_, 16
      }, ::fidl::internal::NaturalStructMember<Storage_, ::test_typesinprotocols::ResourceTable, fidl::internal::NaturalCodingConstraintEmpty>{
        &Storage_::table, 24
      }, ::fidl::internal::NaturalStructMember<Storage_, ::test_typesinprotocols::ResourceUnion, fidl::internal::NaturalCodingConstraintEmpty>{
        &Storage_::union_, 40
      }, ::fidl::internal::NaturalStructMember<Storage_, ::zx::handle, fidl::internal::NaturalCodingConstraintHandle<ZX_OBJ_TYPE_NONE, 0x80000000, true>>{
        &Storage_::opt_handle, 56
      }, ::fidl::internal::NaturalStructMember<Storage_, ::zx::vmo, fidl::internal::NaturalCodingConstraintHandle<ZX_OBJ_TYPE_VMO, 0x80000000, true>>{
        &Storage_::opt_vmo, 60
      }, ::fidl::internal::NaturalStructMember<Storage_, ::fidl::ClientEnd<::test_typesinprotocols::Protocol>, fidl::internal::NaturalCodingConstraintHandle<ZX_OBJ_TYPE_CHANNEL, ZX_DEFAULT_CHANNEL_RIGHTS, true>>{
        &Storage_::opt_client_end, 64
      }, ::fidl::internal::NaturalStructMember<Storage_, ::fidl::ServerEnd<::test_typesinprotocols::Protocol>, fidl::internal::NaturalCodingConstraintHandle<ZX_OBJ_TYPE_CHANNEL, ZX_DEFAULT_CHANNEL_RIGHTS, true>>{
        &Storage_::opt_server_end, 68
      }, ::fidl::internal::NaturalStructMember<Storage_, ::fidl::Box<::test_typesinprotocols::ResourceStruct>, fidl::internal::NaturalCodingConstraintEmpty>{
        &Storage_::opt_struct, 72
      }, ::fidl::internal::NaturalStructMember<Storage_, ::fidl::Box<::test_typesinprotocols::ResourceUnion>, fidl::internal::NaturalCodingConstraintEmpty>{
        &Storage_::opt_union, 80
      }, ::fidl::internal::NaturalStructMember<Storage_, ::std::array<::zx::handle, 5>, fidl::internal::NaturalCodingConstraintHandle<ZX_OBJ_TYPE_NONE, 0x80000000, false>>{
        &Storage_::array_handle, 96
      }, ::fidl::internal::NaturalStructMember<Storage_, ::std::array<::zx::vmo, 5>, fidl::internal::NaturalCodingConstraintHandle<ZX_OBJ_TYPE_VMO, 0x80000000, false>>{
        &Storage_::array_vmo, 116
      }, ::fidl::internal::NaturalStructMember<Storage_, ::std::array<::fidl::ClientEnd<::test_typesinprotocols::Protocol>, 5>, fidl::internal::NaturalCodingConstraintHandle<ZX_OBJ_TYPE_CHANNEL, ZX_DEFAULT_CHANNEL_RIGHTS, false>>{
        &Storage_::array_client_end, 136
      }, ::fidl::internal::NaturalStructMember<Storage_, ::std::array<::fidl::ServerEnd<::test_typesinprotocols::Protocol>, 5>, fidl::internal::NaturalCodingConstraintHandle<ZX_OBJ_TYPE_CHANNEL, ZX_DEFAULT_CHANNEL_RIGHTS, false>>{
        &Storage_::array_server_end, 156
      }, ::fidl::internal::NaturalStructMember<Storage_, ::std::array<::test_typesinprotocols::ResourceStruct, 5>, fidl::internal::NaturalCodingConstraintEmpty>{
        &Storage_::array_struct, 176
      }, ::fidl::internal::NaturalStructMember<Storage_, ::std::array<::test_typesinprotocols::ResourceTable, 5>, fidl::internal::NaturalCodingConstraintEmpty>{
        &Storage_::array_table, 184
      }, ::fidl::internal::NaturalStructMember<Storage_, ::std::array<::test_typesinprotocols::ResourceUnion, 5>, fidl::internal::NaturalCodingConstraintEmpty>{
        &Storage_::array_union, 264
      }, ::fidl::internal::NaturalStructMember<Storage_, ::std::vector<::zx::handle>, fidl::internal::NaturalCodingConstraintVector<fidl::internal::NaturalCodingConstraintHandle<ZX_OBJ_TYPE_NONE, 0x80000000, false>>>{
        &Storage_::vector_handle, 344
      }, ::fidl::internal::NaturalStructMember<Storage_, ::std::vector<::zx::vmo>, fidl::internal::NaturalCodingConstraintVector<fidl::internal::NaturalCodingConstraintHandle<ZX_OBJ_TYPE_VMO, 0x80000000, false>>>{
        &Storage_::vector_vmo, 360
      }, ::fidl::internal::NaturalStructMember<Storage_, ::std::vector<::fidl::ClientEnd<::test_typesinprotocols::Protocol>>, fidl::internal::NaturalCodingConstraintVector<fidl::internal::NaturalCodingConstraintHandle<ZX_OBJ_TYPE_CHANNEL, ZX_DEFAULT_CHANNEL_RIGHTS, false>>>{
        &Storage_::vector_client_end, 376
      }, ::fidl::internal::NaturalStructMember<Storage_, ::std::vector<::fidl::ServerEnd<::test_typesinprotocols::Protocol>>, fidl::internal::NaturalCodingConstraintVector<fidl::internal::NaturalCodingConstraintHandle<ZX_OBJ_TYPE_CHANNEL, ZX_DEFAULT_CHANNEL_RIGHTS, false>>>{
        &Storage_::vector_server_end, 392
      }, ::fidl::internal::NaturalStructMember<Storage_, ::std::vector<::test_typesinprotocols::ResourceStruct>, fidl::internal::NaturalCodingConstraintVector<fidl::internal::NaturalCodingConstraintEmpty>>{
        &Storage_::vector_struct, 408
      }, ::fidl::internal::NaturalStructMember<Storage_, ::std::vector<::test_typesinprotocols::ResourceTable>, fidl::internal::NaturalCodingConstraintVector<fidl::internal::NaturalCodingConstraintEmpty>>{
        &Storage_::vector_table, 424
      }, ::fidl::internal::NaturalStructMember<Storage_, ::std::vector<::test_typesinprotocols::ResourceUnion>, fidl::internal::NaturalCodingConstraintVector<fidl::internal::NaturalCodingConstraintEmpty>>{
        &Storage_::vector_union, 440
      });
  static constexpr auto kPadding = std::make_tuple(::fidl::internal::NaturalStructPadding<uint64_t>{
        .offset = 16,
        .mask = 0xffffffffffffff00,
      }, ::fidl::internal::NaturalStructPadding<uint64_t>{
        .offset = 176,
        .mask = 0xffffff0000000000,
      });

};


#endif  // __Fuchsia__

  
class ProtocolErrorBasicResult {
 private:
  using Storage_ =
    std::variant<
      std::monostate
        , ::test_typesinprotocols::Basic
        , uint32_t>;

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

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

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

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

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

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

    // Sets the union to hold the response member.
    //
    
    ProtocolErrorBasicResult& response(::test_typesinprotocols::Basic value) {
      storage_->emplace<1>(std::move(value));
      return *this;
    }
    static ProtocolErrorBasicResult WithErr(uint32_t val) {
      return ProtocolErrorBasicResult(std::make_shared<Storage_>(
        std::in_place_index_t<2>{},
        std::move(val)));
    }

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

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

    // Sets the union to hold the err member.
    //
    
    ProtocolErrorBasicResult& err(uint32_t value) {
      storage_->emplace<2>(std::move(value));
      return *this;
    }

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

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

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

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

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

};


class ProtocolErrorCompoundResult {
 private:
  using Storage_ =
    std::variant<
      std::monostate
        , ::test_typesinprotocols::Compound
        , uint32_t>;

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

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

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

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

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

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

    // Sets the union to hold the response member.
    //
    
    ProtocolErrorCompoundResult& response(::test_typesinprotocols::Compound value) {
      storage_->emplace<1>(std::move(value));
      return *this;
    }
    static ProtocolErrorCompoundResult WithErr(uint32_t val) {
      return ProtocolErrorCompoundResult(std::make_shared<Storage_>(
        std::in_place_index_t<2>{},
        std::move(val)));
    }

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

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

    // Sets the union to hold the err member.
    //
    
    ProtocolErrorCompoundResult& err(uint32_t value) {
      storage_->emplace<2>(std::move(value));
      return *this;
    }

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

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

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

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

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

};


class ProtocolErrorArrayBasicResult {
 private:
  using Storage_ =
    std::variant<
      std::monostate
        , ::test_typesinprotocols::ArrayBasic
        , uint32_t>;

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

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

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

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

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

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

    // Sets the union to hold the response member.
    //
    
    ProtocolErrorArrayBasicResult& response(::test_typesinprotocols::ArrayBasic value) {
      storage_->emplace<1>(std::move(value));
      return *this;
    }
    static ProtocolErrorArrayBasicResult WithErr(uint32_t val) {
      return ProtocolErrorArrayBasicResult(std::make_shared<Storage_>(
        std::in_place_index_t<2>{},
        std::move(val)));
    }

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

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

    // Sets the union to hold the err member.
    //
    
    ProtocolErrorArrayBasicResult& err(uint32_t value) {
      storage_->emplace<2>(std::move(value));
      return *this;
    }

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

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

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

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

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

};


class ProtocolErrorArrayCompoundResult {
 private:
  using Storage_ =
    std::variant<
      std::monostate
        , ::test_typesinprotocols::ArrayCompound
        , uint32_t>;

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

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

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

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

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

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

    // Sets the union to hold the response member.
    //
    
    ProtocolErrorArrayCompoundResult& response(::test_typesinprotocols::ArrayCompound value) {
      storage_->emplace<1>(std::move(value));
      return *this;
    }
    static ProtocolErrorArrayCompoundResult WithErr(uint32_t val) {
      return ProtocolErrorArrayCompoundResult(std::make_shared<Storage_>(
        std::in_place_index_t<2>{},
        std::move(val)));
    }

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

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

    // Sets the union to hold the err member.
    //
    
    ProtocolErrorArrayCompoundResult& err(uint32_t value) {
      storage_->emplace<2>(std::move(value));
      return *this;
    }

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

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

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

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

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

};


class ProtocolErrorVectorBasicResult {
 private:
  using Storage_ =
    std::variant<
      std::monostate
        , ::test_typesinprotocols::VectorBasic
        , uint32_t>;

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

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

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

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

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

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

    // Sets the union to hold the response member.
    //
    
    ProtocolErrorVectorBasicResult& response(::test_typesinprotocols::VectorBasic value) {
      storage_->emplace<1>(std::move(value));
      return *this;
    }
    static ProtocolErrorVectorBasicResult WithErr(uint32_t val) {
      return ProtocolErrorVectorBasicResult(std::make_shared<Storage_>(
        std::in_place_index_t<2>{},
        std::move(val)));
    }

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

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

    // Sets the union to hold the err member.
    //
    
    ProtocolErrorVectorBasicResult& err(uint32_t value) {
      storage_->emplace<2>(std::move(value));
      return *this;
    }

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

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

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

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

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

};


class ProtocolErrorVectorCompoundResult {
 private:
  using Storage_ =
    std::variant<
      std::monostate
        , ::test_typesinprotocols::VectorCompound
        , uint32_t>;

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

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

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

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

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

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

    // Sets the union to hold the response member.
    //
    
    ProtocolErrorVectorCompoundResult& response(::test_typesinprotocols::VectorCompound value) {
      storage_->emplace<1>(std::move(value));
      return *this;
    }
    static ProtocolErrorVectorCompoundResult WithErr(uint32_t val) {
      return ProtocolErrorVectorCompoundResult(std::make_shared<Storage_>(
        std::in_place_index_t<2>{},
        std::move(val)));
    }

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

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

    // Sets the union to hold the err member.
    //
    
    ProtocolErrorVectorCompoundResult& err(uint32_t value) {
      storage_->emplace<2>(std::move(value));
      return *this;
    }

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

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

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

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

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

};


class ProtocolErrorVectorOptionalResult {
 private:
  using Storage_ =
    std::variant<
      std::monostate
        , ::test_typesinprotocols::VectorOptional
        , uint32_t>;

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

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

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

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

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

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

    // Sets the union to hold the response member.
    //
    
    ProtocolErrorVectorOptionalResult& response(::test_typesinprotocols::VectorOptional value) {
      storage_->emplace<1>(std::move(value));
      return *this;
    }
    static ProtocolErrorVectorOptionalResult WithErr(uint32_t val) {
      return ProtocolErrorVectorOptionalResult(std::make_shared<Storage_>(
        std::in_place_index_t<2>{},
        std::move(val)));
    }

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

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

    // Sets the union to hold the err member.
    //
    
    ProtocolErrorVectorOptionalResult& err(uint32_t value) {
      storage_->emplace<2>(std::move(value));
      return *this;
    }

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

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

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

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

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

};


class ProtocolErrorArrayVectorNestedResult {
 private:
  using Storage_ =
    std::variant<
      std::monostate
        , ::test_typesinprotocols::ArrayVectorNested
        , uint32_t>;

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

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

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

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

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

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

    // Sets the union to hold the response member.
    //
    
    ProtocolErrorArrayVectorNestedResult& response(::test_typesinprotocols::ArrayVectorNested value) {
      storage_->emplace<1>(std::move(value));
      return *this;
    }
    static ProtocolErrorArrayVectorNestedResult WithErr(uint32_t val) {
      return ProtocolErrorArrayVectorNestedResult(std::make_shared<Storage_>(
        std::in_place_index_t<2>{},
        std::move(val)));
    }

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

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

    // Sets the union to hold the err member.
    //
    
    ProtocolErrorArrayVectorNestedResult& err(uint32_t value) {
      storage_->emplace<2>(std::move(value));
      return *this;
    }

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

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

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

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

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

};


#ifdef __Fuchsia__


class ProtocolErrorResourceResult {
 private:
  using Storage_ =
    std::variant<
      std::monostate
        , ::test_typesinprotocols::Resource
        , uint32_t>;

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

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

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

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

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

    // Sets the union to hold the response member.
    //
    
    ProtocolErrorResourceResult& response(::test_typesinprotocols::Resource value) {
      storage_->emplace<1>(std::move(value));
      return *this;
    }
    static ProtocolErrorResourceResult WithErr(uint32_t val) {
      return ProtocolErrorResourceResult(std::make_shared<Storage_>(
        std::in_place_index_t<2>{},
        std::move(val)));
    }

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

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

    // Sets the union to hold the err member.
    //
    
    ProtocolErrorResourceResult& err(uint32_t value) {
      storage_->emplace<2>(std::move(value));
      return *this;
    }

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

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

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

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

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

};


#endif  // __Fuchsia__

  
  inline Struct::Struct(Storage_ storage) noexcept : storage_(std::move(storage)) {}
    inline Struct::Struct(uint8_t __reserved) noexcept
    : storage_({
      .__reserved = std::move(__reserved)
    }) {}
    inline Struct::Struct(const ::test_typesinprotocols::Struct& other) noexcept : ::test_typesinprotocols::Struct(other.CloneStorage_()){}
    inline Struct& ::test_typesinprotocols::Struct::operator=(const ::test_typesinprotocols::Struct& other) noexcept {
      storage_ = other.CloneStorage_();
      return *this;
    }

  inline Struct::Struct(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag) : Struct(Storage_{
      .__reserved =0u,
  }) {}
    inline Struct& Struct::__reserved(uint8_t value) {
      storage_.__reserved = std::move(value);
      return *this;
    }

  
  inline Table::Table(Storage_ storage) noexcept : storage_(std::move(storage)) {}
    inline Table::Table(const ::test_typesinprotocols::Table& other) noexcept : Table(other.CloneStorage_()){}
    inline Table& ::test_typesinprotocols::Table::operator=(const Table& other) noexcept {
      storage_ = other.CloneStorage_();
      return *this;
    }

  inline Table::Table(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag) : Table(Storage_{}) {}

  
#ifdef __Fuchsia__


  inline ResourceStruct::ResourceStruct(Storage_ storage) noexcept : storage_(std::move(storage)) {}
    inline ResourceStruct::ResourceStruct(uint8_t __reserved) noexcept
    : storage_({
      .__reserved = std::move(__reserved)
    }) {}

  inline ResourceStruct::ResourceStruct(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag) : ResourceStruct(Storage_{
      .__reserved =0u,
  }) {}
    inline ResourceStruct& ResourceStruct::__reserved(uint8_t value) {
      storage_.__reserved = std::move(value);
      return *this;
    }

  
#endif  // __Fuchsia__

  
#ifdef __Fuchsia__


  inline ResourceTable::ResourceTable(Storage_ storage) noexcept : storage_(std::move(storage)) {}

  inline ResourceTable::ResourceTable(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag) : ResourceTable(Storage_{}) {}

  
#endif  // __Fuchsia__

  
  inline Basic::Basic(Storage_ storage) noexcept : storage_(std::move(storage)) {}
    inline Basic::Basic(uint8_t uint8, uint16_t uint16, uint32_t uint32, uint64_t uint64, int8_t int8, int16_t int16, int32_t int32, int64_t int64, float float32, double float64, ::std::string string, ::std::optional<::std::string> opt_string) noexcept
    : storage_({
      .uint8 = std::move(uint8), 
      .uint16 = std::move(uint16), 
      .uint32 = std::move(uint32), 
      .uint64 = std::move(uint64), 
      .int8 = std::move(int8), 
      .int16 = std::move(int16), 
      .int32 = std::move(int32), 
      .int64 = std::move(int64), 
      .float32 = std::move(float32), 
      .float64 = std::move(float64), 
      .string = std::move(string), 
      .opt_string = std::move(opt_string)
    }) {}
    inline Basic::Basic(const ::test_typesinprotocols::Basic& other) noexcept : ::test_typesinprotocols::Basic(other.CloneStorage_()){}
    inline Basic& ::test_typesinprotocols::Basic::operator=(const ::test_typesinprotocols::Basic& other) noexcept {
      storage_ = other.CloneStorage_();
      return *this;
    }

  inline Basic::Basic(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag) : Basic(Storage_{
      .uint8 ={},
      .uint16 ={},
      .uint32 ={},
      .uint64 ={},
      .int8 ={},
      .int16 ={},
      .int32 ={},
      .int64 ={},
      .float32 ={},
      .float64 ={},
      .string ={},
      .opt_string ={},
  }) {}
    inline Basic& Basic::uint8(uint8_t value) {
      storage_.uint8 = std::move(value);
      return *this;
    }
    inline Basic& Basic::uint16(uint16_t value) {
      storage_.uint16 = std::move(value);
      return *this;
    }
    inline Basic& Basic::uint32(uint32_t value) {
      storage_.uint32 = std::move(value);
      return *this;
    }
    inline Basic& Basic::uint64(uint64_t value) {
      storage_.uint64 = std::move(value);
      return *this;
    }
    inline Basic& Basic::int8(int8_t value) {
      storage_.int8 = std::move(value);
      return *this;
    }
    inline Basic& Basic::int16(int16_t value) {
      storage_.int16 = std::move(value);
      return *this;
    }
    inline Basic& Basic::int32(int32_t value) {
      storage_.int32 = std::move(value);
      return *this;
    }
    inline Basic& Basic::int64(int64_t value) {
      storage_.int64 = std::move(value);
      return *this;
    }
    inline Basic& Basic::float32(float value) {
      storage_.float32 = std::move(value);
      return *this;
    }
    inline Basic& Basic::float64(double value) {
      storage_.float64 = std::move(value);
      return *this;
    }
    inline Basic& Basic::string(::std::string value) {
      storage_.string = std::move(value);
      return *this;
    }
    inline Basic& Basic::opt_string(::std::optional<::std::string> value) {
      storage_.opt_string = std::move(value);
      return *this;
    }

  
  inline Compound::Compound(Storage_ storage) noexcept : storage_(std::move(storage)) {}
    inline Compound::Compound(::test_typesinprotocols::Bits bits, ::test_typesinprotocols::Enum enum_, ::test_typesinprotocols::Struct struct_, ::test_typesinprotocols::Table table, ::test_typesinprotocols::Union union_, ::fidl::Box<::test_typesinprotocols::Struct> opt_struct, ::fidl::Box<::test_typesinprotocols::Union> opt_union) noexcept
    : storage_({
      .bits = std::move(bits), 
      .enum_ = std::move(enum_), 
      .struct_ = std::move(struct_), 
      .table = std::move(table), 
      .union_ = std::move(union_), 
      .opt_struct = std::move(opt_struct), 
      .opt_union = std::move(opt_union)
    }) {}
    inline Compound::Compound(const ::test_typesinprotocols::Compound& other) noexcept : ::test_typesinprotocols::Compound(other.CloneStorage_()){}
    inline Compound& ::test_typesinprotocols::Compound::operator=(const ::test_typesinprotocols::Compound& other) noexcept {
      storage_ = other.CloneStorage_();
      return *this;
    }

  inline Compound::Compound(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag) : Compound(Storage_{
      .bits ={},
      .enum_ ={},
      .struct_ =::fidl::internal::DefaultConstructPossiblyInvalidObjectTag{},
      .table =::fidl::internal::DefaultConstructPossiblyInvalidObjectTag{},
      .union_ =::fidl::internal::DefaultConstructPossiblyInvalidObjectTag{},
      .opt_struct ={},
      .opt_union ={},
  }) {}
    inline Compound& Compound::bits(::test_typesinprotocols::Bits value) {
      storage_.bits = std::move(value);
      return *this;
    }
    inline Compound& Compound::enum_(::test_typesinprotocols::Enum value) {
      storage_.enum_ = std::move(value);
      return *this;
    }
    inline Compound& Compound::struct_(::test_typesinprotocols::Struct value) {
      storage_.struct_ = std::move(value);
      return *this;
    }
    inline Compound& Compound::table(::test_typesinprotocols::Table value) {
      storage_.table = std::move(value);
      return *this;
    }
    inline Compound& Compound::union_(::test_typesinprotocols::Union value) {
      storage_.union_ = std::move(value);
      return *this;
    }
    inline Compound& Compound::opt_struct(::fidl::Box<::test_typesinprotocols::Struct> value) {
      storage_.opt_struct = std::move(value);
      return *this;
    }
    inline Compound& Compound::opt_union(::fidl::Box<::test_typesinprotocols::Union> value) {
      storage_.opt_union = std::move(value);
      return *this;
    }

  
  inline ArrayBasic::ArrayBasic(Storage_ storage) noexcept : storage_(std::move(storage)) {}
    inline ArrayBasic::ArrayBasic(::std::array<uint8_t, 5> array_uint8, ::std::array<uint16_t, 5> array_uint16, ::std::array<uint32_t, 5> array_uint32, ::std::array<uint64_t, 5> array_uint64, ::std::array<int8_t, 5> array_int8, ::std::array<int16_t, 5> array_int16, ::std::array<int32_t, 5> array_int32, ::std::array<int64_t, 5> array_int64, ::std::array<float, 5> array_float32, ::std::array<double, 5> array_float64, ::std::array<::std::string, 5> array_string, ::std::array<::std::optional<::std::string>, 5> array_opt_string) noexcept
    : storage_({
      .array_uint8 = std::move(array_uint8), 
      .array_uint16 = std::move(array_uint16), 
      .array_uint32 = std::move(array_uint32), 
      .array_uint64 = std::move(array_uint64), 
      .array_int8 = std::move(array_int8), 
      .array_int16 = std::move(array_int16), 
      .array_int32 = std::move(array_int32), 
      .array_int64 = std::move(array_int64), 
      .array_float32 = std::move(array_float32), 
      .array_float64 = std::move(array_float64), 
      .array_string = std::move(array_string), 
      .array_opt_string = std::move(array_opt_string)
    }) {}
    inline ArrayBasic::ArrayBasic(const ::test_typesinprotocols::ArrayBasic& other) noexcept : ::test_typesinprotocols::ArrayBasic(other.CloneStorage_()){}
    inline ArrayBasic& ::test_typesinprotocols::ArrayBasic::operator=(const ::test_typesinprotocols::ArrayBasic& other) noexcept {
      storage_ = other.CloneStorage_();
      return *this;
    }

  inline ArrayBasic::ArrayBasic(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag) : ArrayBasic(Storage_{
      .array_uint8 =::fidl::internal::DefaultConstructPossiblyInvalidObject<::std::array<uint8_t, 5>>::Make(),
      .array_uint16 =::fidl::internal::DefaultConstructPossiblyInvalidObject<::std::array<uint16_t, 5>>::Make(),
      .array_uint32 =::fidl::internal::DefaultConstructPossiblyInvalidObject<::std::array<uint32_t, 5>>::Make(),
      .array_uint64 =::fidl::internal::DefaultConstructPossiblyInvalidObject<::std::array<uint64_t, 5>>::Make(),
      .array_int8 =::fidl::internal::DefaultConstructPossiblyInvalidObject<::std::array<int8_t, 5>>::Make(),
      .array_int16 =::fidl::internal::DefaultConstructPossiblyInvalidObject<::std::array<int16_t, 5>>::Make(),
      .array_int32 =::fidl::internal::DefaultConstructPossiblyInvalidObject<::std::array<int32_t, 5>>::Make(),
      .array_int64 =::fidl::internal::DefaultConstructPossiblyInvalidObject<::std::array<int64_t, 5>>::Make(),
      .array_float32 =::fidl::internal::DefaultConstructPossiblyInvalidObject<::std::array<float, 5>>::Make(),
      .array_float64 =::fidl::internal::DefaultConstructPossiblyInvalidObject<::std::array<double, 5>>::Make(),
      .array_string =::fidl::internal::DefaultConstructPossiblyInvalidObject<::std::array<::std::string, 5>>::Make(),
      .array_opt_string =::fidl::internal::DefaultConstructPossiblyInvalidObject<::std::array<::std::optional<::std::string>, 5>>::Make(),
  }) {}
    inline ArrayBasic& ArrayBasic::array_uint8(::std::array<uint8_t, 5> value) {
      storage_.array_uint8 = std::move(value);
      return *this;
    }
    inline ArrayBasic& ArrayBasic::array_uint16(::std::array<uint16_t, 5> value) {
      storage_.array_uint16 = std::move(value);
      return *this;
    }
    inline ArrayBasic& ArrayBasic::array_uint32(::std::array<uint32_t, 5> value) {
      storage_.array_uint32 = std::move(value);
      return *this;
    }
    inline ArrayBasic& ArrayBasic::array_uint64(::std::array<uint64_t, 5> value) {
      storage_.array_uint64 = std::move(value);
      return *this;
    }
    inline ArrayBasic& ArrayBasic::array_int8(::std::array<int8_t, 5> value) {
      storage_.array_int8 = std::move(value);
      return *this;
    }
    inline ArrayBasic& ArrayBasic::array_int16(::std::array<int16_t, 5> value) {
      storage_.array_int16 = std::move(value);
      return *this;
    }
    inline ArrayBasic& ArrayBasic::array_int32(::std::array<int32_t, 5> value) {
      storage_.array_int32 = std::move(value);
      return *this;
    }
    inline ArrayBasic& ArrayBasic::array_int64(::std::array<int64_t, 5> value) {
      storage_.array_int64 = std::move(value);
      return *this;
    }
    inline ArrayBasic& ArrayBasic::array_float32(::std::array<float, 5> value) {
      storage_.array_float32 = std::move(value);
      return *this;
    }
    inline ArrayBasic& ArrayBasic::array_float64(::std::array<double, 5> value) {
      storage_.array_float64 = std::move(value);
      return *this;
    }
    inline ArrayBasic& ArrayBasic::array_string(::std::array<::std::string, 5> value) {
      storage_.array_string = std::move(value);
      return *this;
    }
    inline ArrayBasic& ArrayBasic::array_opt_string(::std::array<::std::optional<::std::string>, 5> value) {
      storage_.array_opt_string = std::move(value);
      return *this;
    }

  
  inline ArrayCompound::ArrayCompound(Storage_ storage) noexcept : storage_(std::move(storage)) {}
    inline ArrayCompound::ArrayCompound(::std::array<::test_typesinprotocols::Bits, 5> array_bits, ::std::array<::test_typesinprotocols::Enum, 5> array_enum, ::std::array<::test_typesinprotocols::Struct, 5> array_struct, ::std::array<::test_typesinprotocols::Table, 5> array_table, ::std::array<::test_typesinprotocols::Union, 5> array_union, ::std::array<::fidl::Box<::test_typesinprotocols::Struct>, 5> array_opt_struct, ::std::array<::fidl::Box<::test_typesinprotocols::Union>, 5> array_opt_union) noexcept
    : storage_({
      .array_bits = std::move(array_bits), 
      .array_enum = std::move(array_enum), 
      .array_struct = std::move(array_struct), 
      .array_table = std::move(array_table), 
      .array_union = std::move(array_union), 
      .array_opt_struct = std::move(array_opt_struct), 
      .array_opt_union = std::move(array_opt_union)
    }) {}
    inline ArrayCompound::ArrayCompound(const ::test_typesinprotocols::ArrayCompound& other) noexcept : ::test_typesinprotocols::ArrayCompound(other.CloneStorage_()){}
    inline ArrayCompound& ::test_typesinprotocols::ArrayCompound::operator=(const ::test_typesinprotocols::ArrayCompound& other) noexcept {
      storage_ = other.CloneStorage_();
      return *this;
    }

  inline ArrayCompound::ArrayCompound(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag) : ArrayCompound(Storage_{
      .array_bits =::fidl::internal::DefaultConstructPossiblyInvalidObject<::std::array<::test_typesinprotocols::Bits, 5>>::Make(),
      .array_enum =::fidl::internal::DefaultConstructPossiblyInvalidObject<::std::array<::test_typesinprotocols::Enum, 5>>::Make(),
      .array_struct =::fidl::internal::DefaultConstructPossiblyInvalidObject<::std::array<::test_typesinprotocols::Struct, 5>>::Make(),
      .array_table =::fidl::internal::DefaultConstructPossiblyInvalidObject<::std::array<::test_typesinprotocols::Table, 5>>::Make(),
      .array_union =::fidl::internal::DefaultConstructPossiblyInvalidObject<::std::array<::test_typesinprotocols::Union, 5>>::Make(),
      .array_opt_struct =::fidl::internal::DefaultConstructPossiblyInvalidObject<::std::array<::fidl::Box<::test_typesinprotocols::Struct>, 5>>::Make(),
      .array_opt_union =::fidl::internal::DefaultConstructPossiblyInvalidObject<::std::array<::fidl::Box<::test_typesinprotocols::Union>, 5>>::Make(),
  }) {}
    inline ArrayCompound& ArrayCompound::array_bits(::std::array<::test_typesinprotocols::Bits, 5> value) {
      storage_.array_bits = std::move(value);
      return *this;
    }
    inline ArrayCompound& ArrayCompound::array_enum(::std::array<::test_typesinprotocols::Enum, 5> value) {
      storage_.array_enum = std::move(value);
      return *this;
    }
    inline ArrayCompound& ArrayCompound::array_struct(::std::array<::test_typesinprotocols::Struct, 5> value) {
      storage_.array_struct = std::move(value);
      return *this;
    }
    inline ArrayCompound& ArrayCompound::array_table(::std::array<::test_typesinprotocols::Table, 5> value) {
      storage_.array_table = std::move(value);
      return *this;
    }
    inline ArrayCompound& ArrayCompound::array_union(::std::array<::test_typesinprotocols::Union, 5> value) {
      storage_.array_union = std::move(value);
      return *this;
    }
    inline ArrayCompound& ArrayCompound::array_opt_struct(::std::array<::fidl::Box<::test_typesinprotocols::Struct>, 5> value) {
      storage_.array_opt_struct = std::move(value);
      return *this;
    }
    inline ArrayCompound& ArrayCompound::array_opt_union(::std::array<::fidl::Box<::test_typesinprotocols::Union>, 5> value) {
      storage_.array_opt_union = std::move(value);
      return *this;
    }

  
  inline VectorBasic::VectorBasic(Storage_ storage) noexcept : storage_(std::move(storage)) {}
    inline VectorBasic::VectorBasic(::std::vector<uint8_t> vector_uint8, ::std::vector<uint16_t> vector_uint16, ::std::vector<uint32_t> vector_uint32, ::std::vector<uint64_t> vector_uint64, ::std::vector<int8_t> vector_int8, ::std::vector<int16_t> vector_int16, ::std::vector<int32_t> vector_int32, ::std::vector<int64_t> vector_int64, ::std::vector<float> vector_float32, ::std::vector<double> vector_float64, ::std::vector<::std::string> vector_string, ::std::vector<::std::optional<::std::string>> vector_opt_string) noexcept
    : storage_({
      .vector_uint8 = std::move(vector_uint8), 
      .vector_uint16 = std::move(vector_uint16), 
      .vector_uint32 = std::move(vector_uint32), 
      .vector_uint64 = std::move(vector_uint64), 
      .vector_int8 = std::move(vector_int8), 
      .vector_int16 = std::move(vector_int16), 
      .vector_int32 = std::move(vector_int32), 
      .vector_int64 = std::move(vector_int64), 
      .vector_float32 = std::move(vector_float32), 
      .vector_float64 = std::move(vector_float64), 
      .vector_string = std::move(vector_string), 
      .vector_opt_string = std::move(vector_opt_string)
    }) {}
    inline VectorBasic::VectorBasic(const ::test_typesinprotocols::VectorBasic& other) noexcept : ::test_typesinprotocols::VectorBasic(other.CloneStorage_()){}
    inline VectorBasic& ::test_typesinprotocols::VectorBasic::operator=(const ::test_typesinprotocols::VectorBasic& other) noexcept {
      storage_ = other.CloneStorage_();
      return *this;
    }

  inline VectorBasic::VectorBasic(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag) : VectorBasic(Storage_{
      .vector_uint8 ={},
      .vector_uint16 ={},
      .vector_uint32 ={},
      .vector_uint64 ={},
      .vector_int8 ={},
      .vector_int16 ={},
      .vector_int32 ={},
      .vector_int64 ={},
      .vector_float32 ={},
      .vector_float64 ={},
      .vector_string ={},
      .vector_opt_string ={},
  }) {}
    inline VectorBasic& VectorBasic::vector_uint8(::std::vector<uint8_t> value) {
      storage_.vector_uint8 = std::move(value);
      return *this;
    }
    inline VectorBasic& VectorBasic::vector_uint16(::std::vector<uint16_t> value) {
      storage_.vector_uint16 = std::move(value);
      return *this;
    }
    inline VectorBasic& VectorBasic::vector_uint32(::std::vector<uint32_t> value) {
      storage_.vector_uint32 = std::move(value);
      return *this;
    }
    inline VectorBasic& VectorBasic::vector_uint64(::std::vector<uint64_t> value) {
      storage_.vector_uint64 = std::move(value);
      return *this;
    }
    inline VectorBasic& VectorBasic::vector_int8(::std::vector<int8_t> value) {
      storage_.vector_int8 = std::move(value);
      return *this;
    }
    inline VectorBasic& VectorBasic::vector_int16(::std::vector<int16_t> value) {
      storage_.vector_int16 = std::move(value);
      return *this;
    }
    inline VectorBasic& VectorBasic::vector_int32(::std::vector<int32_t> value) {
      storage_.vector_int32 = std::move(value);
      return *this;
    }
    inline VectorBasic& VectorBasic::vector_int64(::std::vector<int64_t> value) {
      storage_.vector_int64 = std::move(value);
      return *this;
    }
    inline VectorBasic& VectorBasic::vector_float32(::std::vector<float> value) {
      storage_.vector_float32 = std::move(value);
      return *this;
    }
    inline VectorBasic& VectorBasic::vector_float64(::std::vector<double> value) {
      storage_.vector_float64 = std::move(value);
      return *this;
    }
    inline VectorBasic& VectorBasic::vector_string(::std::vector<::std::string> value) {
      storage_.vector_string = std::move(value);
      return *this;
    }
    inline VectorBasic& VectorBasic::vector_opt_string(::std::vector<::std::optional<::std::string>> value) {
      storage_.vector_opt_string = std::move(value);
      return *this;
    }

  
  inline VectorCompound::VectorCompound(Storage_ storage) noexcept : storage_(std::move(storage)) {}
    inline VectorCompound::VectorCompound(::std::vector<::test_typesinprotocols::Bits> vector_bits, ::std::vector<::test_typesinprotocols::Enum> vector_enum, ::std::vector<::test_typesinprotocols::Struct> vector_struct, ::std::vector<::test_typesinprotocols::Table> vector_table, ::std::vector<::test_typesinprotocols::Union> vector_union, ::std::vector<::fidl::Box<::test_typesinprotocols::Struct>> vector_opt_struct, ::std::vector<::fidl::Box<::test_typesinprotocols::Union>> vector_opt_union) noexcept
    : storage_({
      .vector_bits = std::move(vector_bits), 
      .vector_enum = std::move(vector_enum), 
      .vector_struct = std::move(vector_struct), 
      .vector_table = std::move(vector_table), 
      .vector_union = std::move(vector_union), 
      .vector_opt_struct = std::move(vector_opt_struct), 
      .vector_opt_union = std::move(vector_opt_union)
    }) {}
    inline VectorCompound::VectorCompound(const ::test_typesinprotocols::VectorCompound& other) noexcept : ::test_typesinprotocols::VectorCompound(other.CloneStorage_()){}
    inline VectorCompound& ::test_typesinprotocols::VectorCompound::operator=(const ::test_typesinprotocols::VectorCompound& other) noexcept {
      storage_ = other.CloneStorage_();
      return *this;
    }

  inline VectorCompound::VectorCompound(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag) : VectorCompound(Storage_{
      .vector_bits ={},
      .vector_enum ={},
      .vector_struct ={},
      .vector_table ={},
      .vector_union ={},
      .vector_opt_struct ={},
      .vector_opt_union ={},
  }) {}
    inline VectorCompound& VectorCompound::vector_bits(::std::vector<::test_typesinprotocols::Bits> value) {
      storage_.vector_bits = std::move(value);
      return *this;
    }
    inline VectorCompound& VectorCompound::vector_enum(::std::vector<::test_typesinprotocols::Enum> value) {
      storage_.vector_enum = std::move(value);
      return *this;
    }
    inline VectorCompound& VectorCompound::vector_struct(::std::vector<::test_typesinprotocols::Struct> value) {
      storage_.vector_struct = std::move(value);
      return *this;
    }
    inline VectorCompound& VectorCompound::vector_table(::std::vector<::test_typesinprotocols::Table> value) {
      storage_.vector_table = std::move(value);
      return *this;
    }
    inline VectorCompound& VectorCompound::vector_union(::std::vector<::test_typesinprotocols::Union> value) {
      storage_.vector_union = std::move(value);
      return *this;
    }
    inline VectorCompound& VectorCompound::vector_opt_struct(::std::vector<::fidl::Box<::test_typesinprotocols::Struct>> value) {
      storage_.vector_opt_struct = std::move(value);
      return *this;
    }
    inline VectorCompound& VectorCompound::vector_opt_union(::std::vector<::fidl::Box<::test_typesinprotocols::Union>> value) {
      storage_.vector_opt_union = std::move(value);
      return *this;
    }

  
  inline VectorOptional::VectorOptional(Storage_ storage) noexcept : storage_(std::move(storage)) {}
    inline VectorOptional::VectorOptional(::std::optional<::std::vector<uint8_t>> opt_vector_uint8, ::std::optional<::std::vector<::std::string>> opt_vector_string, ::std::optional<::std::vector<::test_typesinprotocols::Struct>> opt_vector_struct, ::std::optional<::std::vector<::fidl::Box<::test_typesinprotocols::Struct>>> opt_vector_opt_struct) noexcept
    : storage_({
      .opt_vector_uint8 = std::move(opt_vector_uint8), 
      .opt_vector_string = std::move(opt_vector_string), 
      .opt_vector_struct = std::move(opt_vector_struct), 
      .opt_vector_opt_struct = std::move(opt_vector_opt_struct)
    }) {}
    inline VectorOptional::VectorOptional(const ::test_typesinprotocols::VectorOptional& other) noexcept : ::test_typesinprotocols::VectorOptional(other.CloneStorage_()){}
    inline VectorOptional& ::test_typesinprotocols::VectorOptional::operator=(const ::test_typesinprotocols::VectorOptional& other) noexcept {
      storage_ = other.CloneStorage_();
      return *this;
    }

  inline VectorOptional::VectorOptional(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag) : VectorOptional(Storage_{
      .opt_vector_uint8 ={},
      .opt_vector_string ={},
      .opt_vector_struct ={},
      .opt_vector_opt_struct ={},
  }) {}
    inline VectorOptional& VectorOptional::opt_vector_uint8(::std::optional<::std::vector<uint8_t>> value) {
      storage_.opt_vector_uint8 = std::move(value);
      return *this;
    }
    inline VectorOptional& VectorOptional::opt_vector_string(::std::optional<::std::vector<::std::string>> value) {
      storage_.opt_vector_string = std::move(value);
      return *this;
    }
    inline VectorOptional& VectorOptional::opt_vector_struct(::std::optional<::std::vector<::test_typesinprotocols::Struct>> value) {
      storage_.opt_vector_struct = std::move(value);
      return *this;
    }
    inline VectorOptional& VectorOptional::opt_vector_opt_struct(::std::optional<::std::vector<::fidl::Box<::test_typesinprotocols::Struct>>> value) {
      storage_.opt_vector_opt_struct = std::move(value);
      return *this;
    }

  
  inline ArrayVectorNested::ArrayVectorNested(Storage_ storage) noexcept : storage_(std::move(storage)) {}
    inline ArrayVectorNested::ArrayVectorNested(::std::array<::std::array<uint8_t, 5>, 5> array_array_uint8, ::std::array<::std::vector<uint8_t>, 5> array_vector_uint8, ::std::vector<::std::array<uint8_t, 5>> vector_array_uint8, ::std::vector<::std::vector<uint8_t>> vector_vector_uint8) noexcept
    : storage_({
      .array_array_uint8 = std::move(array_array_uint8), 
      .array_vector_uint8 = std::move(array_vector_uint8), 
      .vector_array_uint8 = std::move(vector_array_uint8), 
      .vector_vector_uint8 = std::move(vector_vector_uint8)
    }) {}
    inline ArrayVectorNested::ArrayVectorNested(const ::test_typesinprotocols::ArrayVectorNested& other) noexcept : ::test_typesinprotocols::ArrayVectorNested(other.CloneStorage_()){}
    inline ArrayVectorNested& ::test_typesinprotocols::ArrayVectorNested::operator=(const ::test_typesinprotocols::ArrayVectorNested& other) noexcept {
      storage_ = other.CloneStorage_();
      return *this;
    }

  inline ArrayVectorNested::ArrayVectorNested(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag) : ArrayVectorNested(Storage_{
      .array_array_uint8 =::fidl::internal::DefaultConstructPossiblyInvalidObject<::std::array<::std::array<uint8_t, 5>, 5>>::Make(),
      .array_vector_uint8 =::fidl::internal::DefaultConstructPossiblyInvalidObject<::std::array<::std::vector<uint8_t>, 5>>::Make(),
      .vector_array_uint8 ={},
      .vector_vector_uint8 ={},
  }) {}
    inline ArrayVectorNested& ArrayVectorNested::array_array_uint8(::std::array<::std::array<uint8_t, 5>, 5> value) {
      storage_.array_array_uint8 = std::move(value);
      return *this;
    }
    inline ArrayVectorNested& ArrayVectorNested::array_vector_uint8(::std::array<::std::vector<uint8_t>, 5> value) {
      storage_.array_vector_uint8 = std::move(value);
      return *this;
    }
    inline ArrayVectorNested& ArrayVectorNested::vector_array_uint8(::std::vector<::std::array<uint8_t, 5>> value) {
      storage_.vector_array_uint8 = std::move(value);
      return *this;
    }
    inline ArrayVectorNested& ArrayVectorNested::vector_vector_uint8(::std::vector<::std::vector<uint8_t>> value) {
      storage_.vector_vector_uint8 = std::move(value);
      return *this;
    }

  
#ifdef __Fuchsia__


  inline Resource::Resource(Storage_ storage) noexcept : storage_(std::move(storage)) {}
    inline Resource::Resource(::zx::handle handle, ::zx::vmo vmo, ::fidl::ClientEnd<::test_typesinprotocols::Protocol> client_end, ::fidl::ServerEnd<::test_typesinprotocols::Protocol> server_end, ::test_typesinprotocols::ResourceStruct struct_, ::test_typesinprotocols::ResourceTable table, ::test_typesinprotocols::ResourceUnion union_, ::zx::handle opt_handle, ::zx::vmo opt_vmo, ::fidl::ClientEnd<::test_typesinprotocols::Protocol> opt_client_end, ::fidl::ServerEnd<::test_typesinprotocols::Protocol> opt_server_end, ::fidl::Box<::test_typesinprotocols::ResourceStruct> opt_struct, ::fidl::Box<::test_typesinprotocols::ResourceUnion> opt_union, ::std::array<::zx::handle, 5> array_handle, ::std::array<::zx::vmo, 5> array_vmo, ::std::array<::fidl::ClientEnd<::test_typesinprotocols::Protocol>, 5> array_client_end, ::std::array<::fidl::ServerEnd<::test_typesinprotocols::Protocol>, 5> array_server_end, ::std::array<::test_typesinprotocols::ResourceStruct, 5> array_struct, ::std::array<::test_typesinprotocols::ResourceTable, 5> array_table, ::std::array<::test_typesinprotocols::ResourceUnion, 5> array_union, ::std::vector<::zx::handle> vector_handle, ::std::vector<::zx::vmo> vector_vmo, ::std::vector<::fidl::ClientEnd<::test_typesinprotocols::Protocol>> vector_client_end, ::std::vector<::fidl::ServerEnd<::test_typesinprotocols::Protocol>> vector_server_end, ::std::vector<::test_typesinprotocols::ResourceStruct> vector_struct, ::std::vector<::test_typesinprotocols::ResourceTable> vector_table, ::std::vector<::test_typesinprotocols::ResourceUnion> vector_union) noexcept
    : storage_({
      .handle = std::move(handle), 
      .vmo = std::move(vmo), 
      .client_end = std::move(client_end), 
      .server_end = std::move(server_end), 
      .struct_ = std::move(struct_), 
      .table = std::move(table), 
      .union_ = std::move(union_), 
      .opt_handle = std::move(opt_handle), 
      .opt_vmo = std::move(opt_vmo), 
      .opt_client_end = std::move(opt_client_end), 
      .opt_server_end = std::move(opt_server_end), 
      .opt_struct = std::move(opt_struct), 
      .opt_union = std::move(opt_union), 
      .array_handle = std::move(array_handle), 
      .array_vmo = std::move(array_vmo), 
      .array_client_end = std::move(array_client_end), 
      .array_server_end = std::move(array_server_end), 
      .array_struct = std::move(array_struct), 
      .array_table = std::move(array_table), 
      .array_union = std::move(array_union), 
      .vector_handle = std::move(vector_handle), 
      .vector_vmo = std::move(vector_vmo), 
      .vector_client_end = std::move(vector_client_end), 
      .vector_server_end = std::move(vector_server_end), 
      .vector_struct = std::move(vector_struct), 
      .vector_table = std::move(vector_table), 
      .vector_union = std::move(vector_union)
    }) {}

  inline Resource::Resource(::fidl::internal::DefaultConstructPossiblyInvalidObjectTag) : Resource(Storage_{
      .handle ={},
      .vmo ={},
      .client_end ={},
      .server_end ={},
      .struct_ =::fidl::internal::DefaultConstructPossiblyInvalidObjectTag{},
      .table =::fidl::internal::DefaultConstructPossiblyInvalidObjectTag{},
      .union_ =::fidl::internal::DefaultConstructPossiblyInvalidObjectTag{},
      .opt_handle ={},
      .opt_vmo ={},
      .opt_client_end ={},
      .opt_server_end ={},
      .opt_struct ={},
      .opt_union ={},
      .array_handle =::fidl::internal::DefaultConstructPossiblyInvalidObject<::std::array<::zx::handle, 5>>::Make(),
      .array_vmo =::fidl::internal::DefaultConstructPossiblyInvalidObject<::std::array<::zx::vmo, 5>>::Make(),
      .array_client_end =::fidl::internal::DefaultConstructPossiblyInvalidObject<::std::array<::fidl::ClientEnd<::test_typesinprotocols::Protocol>, 5>>::Make(),
      .array_server_end =::fidl::internal::DefaultConstructPossiblyInvalidObject<::std::array<::fidl::ServerEnd<::test_typesinprotocols::Protocol>, 5>>::Make(),
      .array_struct =::fidl::internal::DefaultConstructPossiblyInvalidObject<::std::array<::test_typesinprotocols::ResourceStruct, 5>>::Make(),
      .array_table =::fidl::internal::DefaultConstructPossiblyInvalidObject<::std::array<::test_typesinprotocols::ResourceTable, 5>>::Make(),
      .array_union =::fidl::internal::DefaultConstructPossiblyInvalidObject<::std::array<::test_typesinprotocols::ResourceUnion, 5>>::Make(),
      .vector_handle ={},
      .vector_vmo ={},
      .vector_client_end ={},
      .vector_server_end ={},
      .vector_struct ={},
      .vector_table ={},
      .vector_union ={},
  }) {}
    inline Resource& Resource::handle(::zx::handle value) {
      storage_.handle = std::move(value);
      return *this;
    }
    inline Resource& Resource::vmo(::zx::vmo value) {
      storage_.vmo = std::move(value);
      return *this;
    }
    inline Resource& Resource::client_end(::fidl::ClientEnd<::test_typesinprotocols::Protocol> value) {
      storage_.client_end = std::move(value);
      return *this;
    }
    inline Resource& Resource::server_end(::fidl::ServerEnd<::test_typesinprotocols::Protocol> value) {
      storage_.server_end = std::move(value);
      return *this;
    }
    inline Resource& Resource::struct_(::test_typesinprotocols::ResourceStruct value) {
      storage_.struct_ = std::move(value);
      return *this;
    }
    inline Resource& Resource::table(::test_typesinprotocols::ResourceTable value) {
      storage_.table = std::move(value);
      return *this;
    }
    inline Resource& Resource::union_(::test_typesinprotocols::ResourceUnion value) {
      storage_.union_ = std::move(value);
      return *this;
    }
    inline Resource& Resource::opt_handle(::zx::handle value) {
      storage_.opt_handle = std::move(value);
      return *this;
    }
    inline Resource& Resource::opt_vmo(::zx::vmo value) {
      storage_.opt_vmo = std::move(value);
      return *this;
    }
    inline Resource& Resource::opt_client_end(::fidl::ClientEnd<::test_typesinprotocols::Protocol> value) {
      storage_.opt_client_end = std::move(value);
      return *this;
    }
    inline Resource& Resource::opt_server_end(::fidl::ServerEnd<::test_typesinprotocols::Protocol> value) {
      storage_.opt_server_end = std::move(value);
      return *this;
    }
    inline Resource& Resource::opt_struct(::fidl::Box<::test_typesinprotocols::ResourceStruct> value) {
      storage_.opt_struct = std::move(value);
      return *this;
    }
    inline Resource& Resource::opt_union(::fidl::Box<::test_typesinprotocols::ResourceUnion> value) {
      storage_.opt_union = std::move(value);
      return *this;
    }
    inline Resource& Resource::array_handle(::std::array<::zx::handle, 5> value) {
      storage_.array_handle = std::move(value);
      return *this;
    }
    inline Resource& Resource::array_vmo(::std::array<::zx::vmo, 5> value) {
      storage_.array_vmo = std::move(value);
      return *this;
    }
    inline Resource& Resource::array_client_end(::std::array<::fidl::ClientEnd<::test_typesinprotocols::Protocol>, 5> value) {
      storage_.array_client_end = std::move(value);
      return *this;
    }
    inline Resource& Resource::array_server_end(::std::array<::fidl::ServerEnd<::test_typesinprotocols::Protocol>, 5> value) {
      storage_.array_server_end = std::move(value);
      return *this;
    }
    inline Resource& Resource::array_struct(::std::array<::test_typesinprotocols::ResourceStruct, 5> value) {
      storage_.array_struct = std::move(value);
      return *this;
    }
    inline Resource& Resource::array_table(::std::array<::test_typesinprotocols::ResourceTable, 5> value) {
      storage_.array_table = std::move(value);
      return *this;
    }
    inline Resource& Resource::array_union(::std::array<::test_typesinprotocols::ResourceUnion, 5> value) {
      storage_.array_union = std::move(value);
      return *this;
    }
    inline Resource& Resource::vector_handle(::std::vector<::zx::handle> value) {
      storage_.vector_handle = std::move(value);
      return *this;
    }
    inline Resource& Resource::vector_vmo(::std::vector<::zx::vmo> value) {
      storage_.vector_vmo = std::move(value);
      return *this;
    }
    inline Resource& Resource::vector_client_end(::std::vector<::fidl::ClientEnd<::test_typesinprotocols::Protocol>> value) {
      storage_.vector_client_end = std::move(value);
      return *this;
    }
    inline Resource& Resource::vector_server_end(::std::vector<::fidl::ServerEnd<::test_typesinprotocols::Protocol>> value) {
      storage_.vector_server_end = std::move(value);
      return *this;
    }
    inline Resource& Resource::vector_struct(::std::vector<::test_typesinprotocols::ResourceStruct> value) {
      storage_.vector_struct = std::move(value);
      return *this;
    }
    inline Resource& Resource::vector_table(::std::vector<::test_typesinprotocols::ResourceTable> value) {
      storage_.vector_table = std::move(value);
      return *this;
    }
    inline Resource& Resource::vector_union(::std::vector<::test_typesinprotocols::ResourceUnion> value) {
      storage_.vector_union = std::move(value);
      return *this;
    }

  
#endif  // __Fuchsia__

  
}  // namespace test_typesinprotocols
namespace fidl {


  template <>
  struct IsFidlType<::test_typesinprotocols::Struct> : public std::true_type {};

  template<>
  struct TypeTraits<::test_typesinprotocols::Struct> {
    static constexpr uint32_t kMaxNumHandles = 0;
    static constexpr uint32_t kMaxDepth = 0;
    static constexpr uint32_t kPrimarySize = 1;
    static constexpr uint32_t kMaxOutOfLine = 0;
    static constexpr bool kHasPointer = false;
  };

  template <>
  struct IsStruct<::test_typesinprotocols::Struct> : public std::true_type {};

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

  
#ifdef __Fuchsia__


  template <>
  struct IsResource<::test_typesinprotocols::ResourceStruct> : public std::true_type {};
  template <>
  struct IsFidlType<::test_typesinprotocols::ResourceStruct> : public std::true_type {};

  template<>
  struct TypeTraits<::test_typesinprotocols::ResourceStruct> {
    static constexpr uint32_t kMaxNumHandles = 0;
    static constexpr uint32_t kMaxDepth = 0;
    static constexpr uint32_t kPrimarySize = 1;
    static constexpr uint32_t kMaxOutOfLine = 0;
    static constexpr bool kHasPointer = false;
  };

  template <>
  struct IsStruct<::test_typesinprotocols::ResourceStruct> : public std::true_type {};

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

  
#endif  // __Fuchsia__

  
  template <>
  struct IsFidlType<::test_typesinprotocols::Basic> : public std::true_type {};

  template<>
  struct TypeTraits<::test_typesinprotocols::Basic> {
    static constexpr uint32_t kMaxNumHandles = 0;
    static constexpr uint32_t kMaxDepth = 1;
    static constexpr uint32_t kPrimarySize = 80;
    static constexpr uint32_t kMaxOutOfLine = 4294967295;
    static constexpr bool kHasPointer = true;
  };

  template <>
  struct IsStruct<::test_typesinprotocols::Basic> : public std::true_type {};

  template <>
  struct internal::NaturalCodingTraits<::test_typesinprotocols::Basic, ::fidl::internal::NaturalCodingConstraintEmpty> final
    : public ::fidl::internal::NaturalStructCodingTraits<::test_typesinprotocols::Basic, 80> {};

  
  template <>
  struct IsFidlType<::test_typesinprotocols::Compound> : public std::true_type {};

  template<>
  struct TypeTraits<::test_typesinprotocols::Compound> {
    static constexpr uint32_t kMaxNumHandles = 0;
    static constexpr uint32_t kMaxDepth = 1;
    static constexpr uint32_t kPrimarySize = 72;
    static constexpr uint32_t kMaxOutOfLine = 8;
    static constexpr bool kHasPointer = true;
  };

  template <>
  struct IsStruct<::test_typesinprotocols::Compound> : public std::true_type {};

  template <>
  struct internal::NaturalCodingTraits<::test_typesinprotocols::Compound, ::fidl::internal::NaturalCodingConstraintEmpty> final
    : public ::fidl::internal::NaturalStructCodingTraits<::test_typesinprotocols::Compound, 72> {};

  
  template <>
  struct IsFidlType<::test_typesinprotocols::ArrayBasic> : public std::true_type {};

  template<>
  struct TypeTraits<::test_typesinprotocols::ArrayBasic> {
    static constexpr uint32_t kMaxNumHandles = 0;
    static constexpr uint32_t kMaxDepth = 1;
    static constexpr uint32_t kPrimarySize = 384;
    static constexpr uint32_t kMaxOutOfLine = 4294967295;
    static constexpr bool kHasPointer = true;
  };

  template <>
  struct IsStruct<::test_typesinprotocols::ArrayBasic> : public std::true_type {};

  template <>
  struct internal::NaturalCodingTraits<::test_typesinprotocols::ArrayBasic, ::fidl::internal::NaturalCodingConstraintEmpty> final
    : public ::fidl::internal::NaturalStructCodingTraits<::test_typesinprotocols::ArrayBasic, 384> {};

  
  template <>
  struct IsFidlType<::test_typesinprotocols::ArrayCompound> : public std::true_type {};

  template<>
  struct TypeTraits<::test_typesinprotocols::ArrayCompound> {
    static constexpr uint32_t kMaxNumHandles = 0;
    static constexpr uint32_t kMaxDepth = 1;
    static constexpr uint32_t kPrimarySize = 328;
    static constexpr uint32_t kMaxOutOfLine = 40;
    static constexpr bool kHasPointer = true;
  };

  template <>
  struct IsStruct<::test_typesinprotocols::ArrayCompound> : public std::true_type {};

  template <>
  struct internal::NaturalCodingTraits<::test_typesinprotocols::ArrayCompound, ::fidl::internal::NaturalCodingConstraintEmpty> final
    : public ::fidl::internal::NaturalStructCodingTraits<::test_typesinprotocols::ArrayCompound, 328> {};

  
  template <>
  struct IsFidlType<::test_typesinprotocols::VectorBasic> : public std::true_type {};

  template<>
  struct TypeTraits<::test_typesinprotocols::VectorBasic> {
    static constexpr uint32_t kMaxNumHandles = 0;
    static constexpr uint32_t kMaxDepth = 2;
    static constexpr uint32_t kPrimarySize = 192;
    static constexpr uint32_t kMaxOutOfLine = 4294967295;
    static constexpr bool kHasPointer = true;
  };

  template <>
  struct IsStruct<::test_typesinprotocols::VectorBasic> : public std::true_type {};

  template <>
  struct internal::NaturalCodingTraits<::test_typesinprotocols::VectorBasic, ::fidl::internal::NaturalCodingConstraintEmpty> final
    : public ::fidl::internal::NaturalStructCodingTraits<::test_typesinprotocols::VectorBasic, 192> {};

  
  template <>
  struct IsFidlType<::test_typesinprotocols::VectorCompound> : public std::true_type {};

  template<>
  struct TypeTraits<::test_typesinprotocols::VectorCompound> {
    static constexpr uint32_t kMaxNumHandles = 0;
    static constexpr uint32_t kMaxDepth = 2;
    static constexpr uint32_t kPrimarySize = 112;
    static constexpr uint32_t kMaxOutOfLine = 4294967295;
    static constexpr bool kHasPointer = true;
  };

  template <>
  struct IsStruct<::test_typesinprotocols::VectorCompound> : public std::true_type {};

  template <>
  struct internal::NaturalCodingTraits<::test_typesinprotocols::VectorCompound, ::fidl::internal::NaturalCodingConstraintEmpty> final
    : public ::fidl::internal::NaturalStructCodingTraits<::test_typesinprotocols::VectorCompound, 112> {};

  
  template <>
  struct IsFidlType<::test_typesinprotocols::VectorOptional> : public std::true_type {};

  template<>
  struct TypeTraits<::test_typesinprotocols::VectorOptional> {
    static constexpr uint32_t kMaxNumHandles = 0;
    static constexpr uint32_t kMaxDepth = 2;
    static constexpr uint32_t kPrimarySize = 64;
    static constexpr uint32_t kMaxOutOfLine = 4294967295;
    static constexpr bool kHasPointer = true;
  };

  template <>
  struct IsStruct<::test_typesinprotocols::VectorOptional> : public std::true_type {};

  template <>
  struct internal::NaturalCodingTraits<::test_typesinprotocols::VectorOptional, ::fidl::internal::NaturalCodingConstraintEmpty> final
    : public ::fidl::internal::NaturalStructCodingTraits<::test_typesinprotocols::VectorOptional, 64> {};

  
  template <>
  struct IsFidlType<::test_typesinprotocols::ArrayVectorNested> : public std::true_type {};

  template<>
  struct TypeTraits<::test_typesinprotocols::ArrayVectorNested> {
    static constexpr uint32_t kMaxNumHandles = 0;
    static constexpr uint32_t kMaxDepth = 2;
    static constexpr uint32_t kPrimarySize = 144;
    static constexpr uint32_t kMaxOutOfLine = 4294967295;
    static constexpr bool kHasPointer = true;
  };

  template <>
  struct IsStruct<::test_typesinprotocols::ArrayVectorNested> : public std::true_type {};

  template <>
  struct internal::NaturalCodingTraits<::test_typesinprotocols::ArrayVectorNested, ::fidl::internal::NaturalCodingConstraintEmpty> final
    : public ::fidl::internal::NaturalStructCodingTraits<::test_typesinprotocols::ArrayVectorNested, 144> {};

  
#ifdef __Fuchsia__


  template <>
  struct IsResource<::test_typesinprotocols::Resource> : public std::true_type {};
  template <>
  struct IsFidlType<::test_typesinprotocols::Resource> : public std::true_type {};

  template<>
  struct TypeTraits<::test_typesinprotocols::Resource> {
    static constexpr uint32_t kMaxNumHandles = 4294967295;
    static constexpr uint32_t kMaxDepth = 2;
    static constexpr uint32_t kPrimarySize = 456;
    static constexpr uint32_t kMaxOutOfLine = 4294967295;
    static constexpr bool kHasPointer = true;
  };

  template <>
  struct IsStruct<::test_typesinprotocols::Resource> : public std::true_type {};

  template <>
  struct internal::NaturalCodingTraits<::test_typesinprotocols::Resource, ::fidl::internal::NaturalCodingConstraintEmpty> final
    : public ::fidl::internal::NaturalStructCodingTraits<::test_typesinprotocols::Resource, 456> {};

  
#endif  // __Fuchsia__


  template <>
  struct IsFidlType<::test_typesinprotocols::Table> : public std::true_type {};

  template<>
  struct TypeTraits<::test_typesinprotocols::Table> {
    static constexpr uint32_t kMaxNumHandles = 0;
    static constexpr uint32_t kMaxDepth = 1;
    static constexpr uint32_t kPrimarySize = 16;
    static constexpr uint32_t kMaxOutOfLine = 0;
    static constexpr bool kHasPointer = true;
  };

  template <>
  struct IsTable<::test_typesinprotocols::Table> : public std::true_type {};

  template <>
  struct internal::NaturalCodingTraits<::test_typesinprotocols::Table, ::fidl::internal::NaturalCodingConstraintEmpty> :
    public ::fidl::internal::NaturalTableCodingTraits<::test_typesinprotocols::Table> {};

  
#ifdef __Fuchsia__


  template <>
  struct IsResource<::test_typesinprotocols::ResourceTable> : public std::true_type {};
  template <>
  struct IsFidlType<::test_typesinprotocols::ResourceTable> : public std::true_type {};

  template<>
  struct TypeTraits<::test_typesinprotocols::ResourceTable> {
    static constexpr uint32_t kMaxNumHandles = 0;
    static constexpr uint32_t kMaxDepth = 1;
    static constexpr uint32_t kPrimarySize = 16;
    static constexpr uint32_t kMaxOutOfLine = 0;
    static constexpr bool kHasPointer = true;
  };

  template <>
  struct IsTable<::test_typesinprotocols::ResourceTable> : public std::true_type {};

  template <>
  struct internal::NaturalCodingTraits<::test_typesinprotocols::ResourceTable, ::fidl::internal::NaturalCodingConstraintEmpty> :
    public ::fidl::internal::NaturalTableCodingTraits<::test_typesinprotocols::ResourceTable> {};

  
#endif  // __Fuchsia__


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

  template<>
  struct TypeTraits<::test_typesinprotocols::Union> {
    static constexpr uint32_t kMaxNumHandles = 0;
    static constexpr uint32_t kMaxDepth = 1;
    static constexpr uint32_t kPrimarySize = 16;
    static constexpr uint32_t kMaxOutOfLine = 0;
    static constexpr bool kHasPointer = true;
  };

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

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


#ifdef __Fuchsia__


  template <>
  struct IsResource<::test_typesinprotocols::ResourceUnion> : public std::true_type {};
  template <>
  struct IsFidlType<::test_typesinprotocols::ResourceUnion> : public std::true_type {};

  template<>
  struct TypeTraits<::test_typesinprotocols::ResourceUnion> {
    static constexpr uint32_t kMaxNumHandles = 0;
    static constexpr uint32_t kMaxDepth = 1;
    static constexpr uint32_t kPrimarySize = 16;
    static constexpr uint32_t kMaxOutOfLine = 0;
    static constexpr bool kHasPointer = true;
  };

  template <>
  struct IsUnion<::test_typesinprotocols::ResourceUnion> : public std::true_type {};

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


#endif  // __Fuchsia__

  
  template <>
  struct IsFidlType<::test_typesinprotocols::ProtocolErrorBasicResult> : public std::true_type {};

  template<>
  struct TypeTraits<::test_typesinprotocols::ProtocolErrorBasicResult> {
    static constexpr uint32_t kMaxNumHandles = 0;
    static constexpr uint32_t kMaxDepth = 2;
    static constexpr uint32_t kPrimarySize = 16;
    static constexpr uint32_t kMaxOutOfLine = 4294967295;
    static constexpr bool kHasPointer = true;
  };

  template <>
  struct IsUnion<::test_typesinprotocols::ProtocolErrorBasicResult> : public std::true_type {};

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


  template <>
  struct IsFidlType<::test_typesinprotocols::ProtocolErrorCompoundResult> : public std::true_type {};

  template<>
  struct TypeTraits<::test_typesinprotocols::ProtocolErrorCompoundResult> {
    static constexpr uint32_t kMaxNumHandles = 0;
    static constexpr uint32_t kMaxDepth = 2;
    static constexpr uint32_t kPrimarySize = 16;
    static constexpr uint32_t kMaxOutOfLine = 80;
    static constexpr bool kHasPointer = true;
  };

  template <>
  struct IsUnion<::test_typesinprotocols::ProtocolErrorCompoundResult> : public std::true_type {};

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


  template <>
  struct IsFidlType<::test_typesinprotocols::ProtocolErrorArrayBasicResult> : public std::true_type {};

  template<>
  struct TypeTraits<::test_typesinprotocols::ProtocolErrorArrayBasicResult> {
    static constexpr uint32_t kMaxNumHandles = 0;
    static constexpr uint32_t kMaxDepth = 2;
    static constexpr uint32_t kPrimarySize = 16;
    static constexpr uint32_t kMaxOutOfLine = 4294967295;
    static constexpr bool kHasPointer = true;
  };

  template <>
  struct IsUnion<::test_typesinprotocols::ProtocolErrorArrayBasicResult> : public std::true_type {};

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


  template <>
  struct IsFidlType<::test_typesinprotocols::ProtocolErrorArrayCompoundResult> : public std::true_type {};

  template<>
  struct TypeTraits<::test_typesinprotocols::ProtocolErrorArrayCompoundResult> {
    static constexpr uint32_t kMaxNumHandles = 0;
    static constexpr uint32_t kMaxDepth = 2;
    static constexpr uint32_t kPrimarySize = 16;
    static constexpr uint32_t kMaxOutOfLine = 368;
    static constexpr bool kHasPointer = true;
  };

  template <>
  struct IsUnion<::test_typesinprotocols::ProtocolErrorArrayCompoundResult> : public std::true_type {};

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


  template <>
  struct IsFidlType<::test_typesinprotocols::ProtocolErrorVectorBasicResult> : public std::true_type {};

  template<>
  struct TypeTraits<::test_typesinprotocols::ProtocolErrorVectorBasicResult> {
    static constexpr uint32_t kMaxNumHandles = 0;
    static constexpr uint32_t kMaxDepth = 3;
    static constexpr uint32_t kPrimarySize = 16;
    static constexpr uint32_t kMaxOutOfLine = 4294967295;
    static constexpr bool kHasPointer = true;
  };

  template <>
  struct IsUnion<::test_typesinprotocols::ProtocolErrorVectorBasicResult> : public std::true_type {};

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


  template <>
  struct IsFidlType<::test_typesinprotocols::ProtocolErrorVectorCompoundResult> : public std::true_type {};

  template<>
  struct TypeTraits<::test_typesinprotocols::ProtocolErrorVectorCompoundResult> {
    static constexpr uint32_t kMaxNumHandles = 0;
    static constexpr uint32_t kMaxDepth = 3;
    static constexpr uint32_t kPrimarySize = 16;
    static constexpr uint32_t kMaxOutOfLine = 4294967295;
    static constexpr bool kHasPointer = true;
  };

  template <>
  struct IsUnion<::test_typesinprotocols::ProtocolErrorVectorCompoundResult> : public std::true_type {};

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


  template <>
  struct IsFidlType<::test_typesinprotocols::ProtocolErrorVectorOptionalResult> : public std::true_type {};

  template<>
  struct TypeTraits<::test_typesinprotocols::ProtocolErrorVectorOptionalResult> {
    static constexpr uint32_t kMaxNumHandles = 0;
    static constexpr uint32_t kMaxDepth = 3;
    static constexpr uint32_t kPrimarySize = 16;
    static constexpr uint32_t kMaxOutOfLine = 4294967295;
    static constexpr bool kHasPointer = true;
  };

  template <>
  struct IsUnion<::test_typesinprotocols::ProtocolErrorVectorOptionalResult> : public std::true_type {};

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


  template <>
  struct IsFidlType<::test_typesinprotocols::ProtocolErrorArrayVectorNestedResult> : public std::true_type {};

  template<>
  struct TypeTraits<::test_typesinprotocols::ProtocolErrorArrayVectorNestedResult> {
    static constexpr uint32_t kMaxNumHandles = 0;
    static constexpr uint32_t kMaxDepth = 3;
    static constexpr uint32_t kPrimarySize = 16;
    static constexpr uint32_t kMaxOutOfLine = 4294967295;
    static constexpr bool kHasPointer = true;
  };

  template <>
  struct IsUnion<::test_typesinprotocols::ProtocolErrorArrayVectorNestedResult> : public std::true_type {};

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


#ifdef __Fuchsia__


  template <>
  struct IsResource<::test_typesinprotocols::ProtocolErrorResourceResult> : public std::true_type {};
  template <>
  struct IsFidlType<::test_typesinprotocols::ProtocolErrorResourceResult> : public std::true_type {};

  template<>
  struct TypeTraits<::test_typesinprotocols::ProtocolErrorResourceResult> {
    static constexpr uint32_t kMaxNumHandles = 4294967295;
    static constexpr uint32_t kMaxDepth = 3;
    static constexpr uint32_t kPrimarySize = 16;
    static constexpr uint32_t kMaxOutOfLine = 4294967295;
    static constexpr bool kHasPointer = true;
  };

  template <>
  struct IsUnion<::test_typesinprotocols::ProtocolErrorResourceResult> : public std::true_type {};

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


#endif  // __Fuchsia__


  template <>
  struct internal::NaturalCodingTraits<::test_typesinprotocols::Bits, ::fidl::internal::NaturalCodingConstraintEmpty> {
    static constexpr size_t kInlineSize = sizeof(uint32_t);
    static constexpr bool kIsMemcpyCompatible = true;

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

  template <>
  struct internal::NaturalCodingTraits<::test_typesinprotocols::Enum, ::fidl::internal::NaturalCodingConstraintEmpty> {
    static constexpr size_t kInlineSize = sizeof(uint32_t);
    static constexpr bool kIsMemcpyCompatible = true;

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

#pragma clang diagnostic pop

}  // namespace fidl