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

// fidl_experiment = output_index_json

#pragma once

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

namespace test {
namespace typesinprotocols {


//
// Domain objects declarations
//


// |Bits| is flexible, hence may contain unknown members not
// defined in the FIDL schema.
class Bits final {
public:
  constexpr Bits() = default;

  // Constructs an instance of |Bits| from an underlying primitive value
  // if the primitive does not contain any unknown members not defined in the
  // FIDL schema. Otherwise, returns |cpp17::nullopt|.
  constexpr inline static cpp17::optional<Bits> TryFrom(uint32_t value) {
    if (value & ~kMask.value_) {
      return cpp17::nullopt;
    }
    return Bits(value & Bits::kMask.value_);
  }

  // Constructs an instance of |Bits| from an underlying primitive value,
  // clearing any bit member not defined in the FIDL schema.
  constexpr inline static Bits TruncatingUnknown(uint32_t value) {
    return Bits(value & Bits::kMask.value_);
  }

  // Constructs an instance of |Bits| from an underlying primitive value,
  // preserving any bit member not defined in the FIDL schema.
  constexpr explicit Bits(uint32_t value) : value_(value) {}
  const static Bits VAL;
  const static Bits kMask;

  explicit constexpr inline operator uint32_t() const { return value_; }
  explicit constexpr inline operator bool() const { return static_cast<bool>(value_); }
  constexpr inline bool operator==(const Bits& other) const { return value_ == other.value_; }
  constexpr inline bool operator!=(const Bits& other) const { return value_ != other.value_; }
  constexpr inline Bits operator~() const;
  constexpr inline Bits operator|(const Bits& other) const;
  constexpr inline Bits operator&(const Bits& other) const;
  constexpr inline Bits operator^(const Bits& other) const;
  constexpr inline void operator|=(const Bits& other);
  constexpr inline void operator&=(const Bits& other);
  constexpr inline void operator^=(const Bits& other);
  constexpr inline Bits unknown_bits() const {
    return *this & Bits(~kMask.value_);
  }
  constexpr inline bool has_unknown_bits() const { return static_cast<bool>(unknown_bits()); }

private:
  uint32_t value_ = 0;
};

#if !(__cplusplus < 201703)
constexpr const ::test::typesinprotocols::Bits Bits::VAL = ::test::typesinprotocols::Bits(1u);
constexpr const ::test::typesinprotocols::Bits Bits::kMask = ::test::typesinprotocols::Bits(1u);

#endif  // !(__cplusplus < 201703)

constexpr inline ::test::typesinprotocols::Bits Bits::operator~() const {
  return ::test::typesinprotocols::Bits(static_cast<uint32_t>(~this->value_ & kMask.value_));
}

constexpr inline ::test::typesinprotocols::Bits Bits::operator|(
    const ::test::typesinprotocols::Bits& other) const {
  return ::test::typesinprotocols::Bits(static_cast<uint32_t>(this->value_ | other.value_));
}

constexpr inline ::test::typesinprotocols::Bits Bits::operator&(
    const ::test::typesinprotocols::Bits& other) const {
  return ::test::typesinprotocols::Bits(static_cast<uint32_t>(this->value_ & other.value_));
}

constexpr inline ::test::typesinprotocols::Bits Bits::operator^(
    const ::test::typesinprotocols::Bits& other) const {
  return ::test::typesinprotocols::Bits(static_cast<uint32_t>(this->value_ ^ other.value_));
}

constexpr inline void Bits::operator|=(
    const ::test::typesinprotocols::Bits& other) {
  this->value_ |= other.value_;
}

constexpr inline void Bits::operator&=(
    const ::test::typesinprotocols::Bits& other) {
  this->value_ &= other.value_;
}

constexpr inline void Bits::operator^=(
    const ::test::typesinprotocols::Bits& other) {
  this->value_ ^= other.value_;
}

inline zx_status_t Clone(::test::typesinprotocols::Bits value,
                         ::test::typesinprotocols::Bits* result) {
  *result = value;
  return ZX_OK;
}


class Enum final {
public:
  constexpr Enum() : value_(0) {}
  constexpr explicit Enum(uint32_t value) : value_(value) {}
  constexpr operator uint32_t() const { return value_; }

  constexpr bool IsUnknown() const {
    
    switch (value_) {
      
      
    case 1u:
      
      
      return false;
    }
    return true;
  }

  constexpr static Enum Unknown() {
    return Enum(0xffffffff);
  }
    
    static const Enum VAL;

private:
  uint32_t value_;
};

#if !(__cplusplus < 201703)
constexpr const ::test::typesinprotocols::Enum Enum::VAL = ::test::typesinprotocols::Enum(1u);
#endif  // !(__cplusplus < 201703)


inline zx_status_t Clone(::test::typesinprotocols::Enum value,
                         ::test::typesinprotocols::Enum* result) {
  *result = value;
  return ZX_OK;
}


class Struct;


class Table;


class Union;


class ResourceStruct;


class ResourceTable;


class ResourceUnion;


class Basic;


class Compound;


class ArrayBasic;


class ArrayCompound;


class VectorBasic;


class VectorCompound;


class VectorOptional;


class ArrayVectorNested;


class Resource;


class Protocol_ErrorBasic_Result;


class Protocol_ErrorCompound_Result;


class Protocol_ErrorArrayBasic_Result;


class Protocol_ErrorArrayCompound_Result;


class Protocol_ErrorVectorBasic_Result;


class Protocol_ErrorVectorCompound_Result;


class Protocol_ErrorVectorOptional_Result;


class Protocol_ErrorArrayVectorNested_Result;


class Protocol_ErrorResource_Result;


#ifdef __Fuchsia__

class Protocol;
using ProtocolHandle = ::fidl::InterfaceHandle<Protocol>;

#endif  // __Fuchsia__


class Struct final {
 public:
  static const fidl_type_t* FidlType;
  
  uint8_t __reserved= 0u;

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

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

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

using StructPtr = ::std::unique_ptr<Struct>;


class Table final {
 public:
  static const fidl_type_t* FidlType;
  /// Returns whether no field is set.
  bool IsEmpty() const;

  Table();
  Table(Table&& other);
  ~Table();
  Table& operator=(Table&& other);

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

  void Encode(::fidl::Encoder* _encoder, size_t _offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, Table* _value, size_t _offset);
  zx_status_t Clone(Table* _result) const;
 private:
  template <class T, class... Args>
  void Construct(T* p, Args&&... args) {
    new (p) T(std::forward<Args>(args)...);
  }

  template <class T>
  void Destruct(T* p) {
    p->~T();
  }

  size_t MaxOrdinal() const {
    return static_cast<size_t>(field_presence_.MaxSetIndex()) + std::size_t{1};
  }

  static bool IsOrdinalKnown(uint64_t ordinal) {
    switch (ordinal) {
      return true;
    default:
      return false;
    }
  }

  ::fidl::internal::BitSet<0> field_presence_;
};

using TablePtr = ::std::unique_ptr<Table>;


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

  Union();
  ~Union();

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

  
  static Union WithB(bool&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {
  kUnknown = 0,
  
    kB = 1,  // 0x1
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

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

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

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

  bool is_b() const { return tag_ == ::test::typesinprotocols::Union::Tag::kB; }
  
  bool& b() {
    EnsureStorageInitialized(::test::typesinprotocols::Union::Tag::kB);
    return b_;
  }
  
  const bool& b() const {
    ZX_ASSERT(is_b());
    return b_;
  }
  Union& set_b(bool value);
  Union& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes);

  ::test::typesinprotocols::Union::Tag Which() const {
    
    switch (tag_) {
      case ::test::typesinprotocols::Union::Tag::Invalid:
      case ::test::typesinprotocols::Union::Tag::kB:
        return ::test::typesinprotocols::Union::Tag(tag_);
      default:
        return ::test::typesinprotocols::Union::Tag::kUnknown;
    }
    
  }

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

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

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

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::typesinprotocols::Union::Tag::Invalid);
  union {
    bool b_;
    std::vector<uint8_t> unknown_data_;
  };
};

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

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


#ifdef __Fuchsia__

class ResourceStruct final {
 public:
  static const fidl_type_t* FidlType;
  
  uint8_t __reserved= 0u;

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

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

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

using ResourceStructPtr = ::std::unique_ptr<ResourceStruct>;

#endif  // __Fuchsia__


#ifdef __Fuchsia__

class ResourceTable final {
 public:
  static const fidl_type_t* FidlType;
  /// Returns whether no field is set.
  bool IsEmpty() const;

  ResourceTable();
  ResourceTable(ResourceTable&& other);
  ~ResourceTable();
  ResourceTable& operator=(ResourceTable&& other);

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

  void Encode(::fidl::Encoder* _encoder, size_t _offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, ResourceTable* _value, size_t _offset);
  zx_status_t Clone(ResourceTable* _result) const;
 private:
  template <class T, class... Args>
  void Construct(T* p, Args&&... args) {
    new (p) T(std::forward<Args>(args)...);
  }

  template <class T>
  void Destruct(T* p) {
    p->~T();
  }

  size_t MaxOrdinal() const {
    return static_cast<size_t>(field_presence_.MaxSetIndex()) + std::size_t{1};
  }

  static bool IsOrdinalKnown(uint64_t ordinal) {
    switch (ordinal) {
      return true;
    default:
      return false;
    }
  }

  ::fidl::internal::BitSet<0> field_presence_;
};

using ResourceTablePtr = ::std::unique_ptr<ResourceTable>;

#endif  // __Fuchsia__


#ifdef __Fuchsia__

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

  ResourceUnion();
  ~ResourceUnion();

  ResourceUnion(ResourceUnion&&);
  ResourceUnion& operator=(ResourceUnion&&);

  
  static ResourceUnion WithB(bool&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {
  kUnknown = 0,
  
    kB = 1,  // 0x1
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

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

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

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

  bool is_b() const { return tag_ == ::test::typesinprotocols::ResourceUnion::Tag::kB; }
  
  bool& b() {
    EnsureStorageInitialized(::test::typesinprotocols::ResourceUnion::Tag::kB);
    return b_;
  }
  
  const bool& b() const {
    ZX_ASSERT(is_b());
    return b_;
  }
  ResourceUnion& set_b(bool value);
  ResourceUnion& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes, std::vector<zx::handle> handles);

  ::test::typesinprotocols::ResourceUnion::Tag Which() const {
    
    switch (tag_) {
      case ::test::typesinprotocols::ResourceUnion::Tag::Invalid:
      case ::test::typesinprotocols::ResourceUnion::Tag::kB:
        return ::test::typesinprotocols::ResourceUnion::Tag(tag_);
      default:
        return ::test::typesinprotocols::ResourceUnion::Tag::kUnknown;
    }
    
  }

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

  friend ::fidl::Equality<::test::typesinprotocols::ResourceUnion>;

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

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::typesinprotocols::ResourceUnion::Tag::Invalid);
  union {
    bool b_;
    ::fidl::UnknownData unknown_data_;
  };
};

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

using ResourceUnionPtr = ::std::unique_ptr<ResourceUnion>;

#endif  // __Fuchsia__


class Basic final {
 public:
  static const fidl_type_t* FidlType;
  Basic() = default;
  explicit Basic(::std::tuple<uint8_t, uint16_t, uint32_t, uint64_t, int8_t, int16_t, int32_t, int64_t, float, double, ::std::string, ::fidl::StringPtr> _value_tuple) {
    std::tie(uint8, uint16, uint32, uint64, int8, int16, int32, int64, float32, float64, string, opt_string) = std::move(_value_tuple);
  }
  operator ::std::tuple<uint8_t, uint16_t, uint32_t, uint64_t, int8_t, int16_t, int32_t, int64_t, float, double, ::std::string, ::fidl::StringPtr>() && {
    return std::make_tuple(std::move(uint8), std::move(uint16), std::move(uint32), std::move(uint64), std::move(int8), std::move(int16), std::move(int32), std::move(int64), std::move(float32), std::move(float64), std::move(string), std::move(opt_string)
    );
  }
  
  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;
  
  ::fidl::StringPtr opt_string;

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

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

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

using BasicPtr = ::std::unique_ptr<Basic>;


class Compound final {
 public:
  static const fidl_type_t* FidlType;
  Compound() = default;
  explicit Compound(::std::tuple<::test::typesinprotocols::Bits, ::test::typesinprotocols::Enum, ::test::typesinprotocols::Struct, ::test::typesinprotocols::Table, ::test::typesinprotocols::Union, ::std::unique_ptr<::test::typesinprotocols::Struct>, ::std::unique_ptr<::test::typesinprotocols::Union>> _value_tuple) {
    std::tie(bits, enum_, struct_, table, union_, opt_struct, opt_union) = std::move(_value_tuple);
  }
  operator ::std::tuple<::test::typesinprotocols::Bits, ::test::typesinprotocols::Enum, ::test::typesinprotocols::Struct, ::test::typesinprotocols::Table, ::test::typesinprotocols::Union, ::std::unique_ptr<::test::typesinprotocols::Struct>, ::std::unique_ptr<::test::typesinprotocols::Union>>() && {
    return std::make_tuple(std::move(bits), std::move(enum_), std::move(struct_), std::move(table), std::move(union_), std::move(opt_struct), std::move(opt_union)
    );
  }
  
  ::test::typesinprotocols::Bits bits{};
  
  ::test::typesinprotocols::Enum enum_{};
  
  ::test::typesinprotocols::Struct struct_;
  
  ::test::typesinprotocols::Table table;
  
  ::test::typesinprotocols::Union union_;
  
  ::std::unique_ptr<::test::typesinprotocols::Struct> opt_struct;
  
  ::std::unique_ptr<::test::typesinprotocols::Union> opt_union;

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

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

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

using CompoundPtr = ::std::unique_ptr<Compound>;


class ArrayBasic final {
 public:
  static const fidl_type_t* FidlType;
  ArrayBasic() = default;
  explicit ArrayBasic(::std::tuple<::std::array<uint8_t, 5>, ::std::array<uint16_t, 5>, ::std::array<uint32_t, 5>, ::std::array<uint64_t, 5>, ::std::array<int8_t, 5>, ::std::array<int16_t, 5>, ::std::array<int32_t, 5>, ::std::array<int64_t, 5>, ::std::array<float, 5>, ::std::array<double, 5>, ::std::array<::std::string, 5>, ::std::array<::fidl::StringPtr, 5>> _value_tuple) {
    std::tie(array_uint8, array_uint16, array_uint32, array_uint64, array_int8, array_int16, array_int32, array_int64, array_float32, array_float64, array_string, array_opt_string) = std::move(_value_tuple);
  }
  operator ::std::tuple<::std::array<uint8_t, 5>, ::std::array<uint16_t, 5>, ::std::array<uint32_t, 5>, ::std::array<uint64_t, 5>, ::std::array<int8_t, 5>, ::std::array<int16_t, 5>, ::std::array<int32_t, 5>, ::std::array<int64_t, 5>, ::std::array<float, 5>, ::std::array<double, 5>, ::std::array<::std::string, 5>, ::std::array<::fidl::StringPtr, 5>>() && {
    return std::make_tuple(std::move(array_uint8), std::move(array_uint16), std::move(array_uint32), std::move(array_uint64), std::move(array_int8), std::move(array_int16), std::move(array_int32), std::move(array_int64), std::move(array_float32), std::move(array_float64), std::move(array_string), std::move(array_opt_string)
    );
  }
  
  ::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<::fidl::StringPtr, 5> array_opt_string{};

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

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

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

using ArrayBasicPtr = ::std::unique_ptr<ArrayBasic>;


class ArrayCompound final {
 public:
  static const fidl_type_t* FidlType;
  ArrayCompound() = default;
  explicit ArrayCompound(::std::tuple<::std::array<::test::typesinprotocols::Bits, 5>, ::std::array<::test::typesinprotocols::Enum, 5>, ::std::array<::test::typesinprotocols::Struct, 5>, ::std::array<::test::typesinprotocols::Table, 5>, ::std::array<::test::typesinprotocols::Union, 5>, ::std::array<::std::unique_ptr<::test::typesinprotocols::Struct>, 5>, ::std::array<::std::unique_ptr<::test::typesinprotocols::Union>, 5>> _value_tuple) {
    std::tie(array_bits, array_enum, array_struct, array_table, array_union, array_opt_struct, array_opt_union) = std::move(_value_tuple);
  }
  operator ::std::tuple<::std::array<::test::typesinprotocols::Bits, 5>, ::std::array<::test::typesinprotocols::Enum, 5>, ::std::array<::test::typesinprotocols::Struct, 5>, ::std::array<::test::typesinprotocols::Table, 5>, ::std::array<::test::typesinprotocols::Union, 5>, ::std::array<::std::unique_ptr<::test::typesinprotocols::Struct>, 5>, ::std::array<::std::unique_ptr<::test::typesinprotocols::Union>, 5>>() && {
    return std::make_tuple(std::move(array_bits), std::move(array_enum), std::move(array_struct), std::move(array_table), std::move(array_union), std::move(array_opt_struct), std::move(array_opt_union)
    );
  }
  
  ::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<::std::unique_ptr<::test::typesinprotocols::Struct>, 5> array_opt_struct{};
  
  ::std::array<::std::unique_ptr<::test::typesinprotocols::Union>, 5> array_opt_union{};

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

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

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

using ArrayCompoundPtr = ::std::unique_ptr<ArrayCompound>;


class VectorBasic final {
 public:
  static const fidl_type_t* FidlType;
  VectorBasic() = default;
  explicit VectorBasic(::std::tuple<::std::vector<uint8_t>, ::std::vector<uint16_t>, ::std::vector<uint32_t>, ::std::vector<uint64_t>, ::std::vector<int8_t>, ::std::vector<int16_t>, ::std::vector<int32_t>, ::std::vector<int64_t>, ::std::vector<float>, ::std::vector<double>, ::std::vector<::std::string>, ::std::vector<::fidl::StringPtr>> _value_tuple) {
    std::tie(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) = std::move(_value_tuple);
  }
  operator ::std::tuple<::std::vector<uint8_t>, ::std::vector<uint16_t>, ::std::vector<uint32_t>, ::std::vector<uint64_t>, ::std::vector<int8_t>, ::std::vector<int16_t>, ::std::vector<int32_t>, ::std::vector<int64_t>, ::std::vector<float>, ::std::vector<double>, ::std::vector<::std::string>, ::std::vector<::fidl::StringPtr>>() && {
    return std::make_tuple(std::move(vector_uint8), std::move(vector_uint16), std::move(vector_uint32), std::move(vector_uint64), std::move(vector_int8), std::move(vector_int16), std::move(vector_int32), std::move(vector_int64), std::move(vector_float32), std::move(vector_float64), std::move(vector_string), std::move(vector_opt_string)
    );
  }
  
  ::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<::fidl::StringPtr> vector_opt_string;

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

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

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

using VectorBasicPtr = ::std::unique_ptr<VectorBasic>;


class VectorCompound final {
 public:
  static const fidl_type_t* FidlType;
  VectorCompound() = default;
  explicit VectorCompound(::std::tuple<::std::vector<::test::typesinprotocols::Bits>, ::std::vector<::test::typesinprotocols::Enum>, ::std::vector<::test::typesinprotocols::Struct>, ::std::vector<::test::typesinprotocols::Table>, ::std::vector<::test::typesinprotocols::Union>, ::std::vector<::std::unique_ptr<::test::typesinprotocols::Struct>>, ::std::vector<::std::unique_ptr<::test::typesinprotocols::Union>>> _value_tuple) {
    std::tie(vector_bits, vector_enum, vector_struct, vector_table, vector_union, vector_opt_struct, vector_opt_union) = std::move(_value_tuple);
  }
  operator ::std::tuple<::std::vector<::test::typesinprotocols::Bits>, ::std::vector<::test::typesinprotocols::Enum>, ::std::vector<::test::typesinprotocols::Struct>, ::std::vector<::test::typesinprotocols::Table>, ::std::vector<::test::typesinprotocols::Union>, ::std::vector<::std::unique_ptr<::test::typesinprotocols::Struct>>, ::std::vector<::std::unique_ptr<::test::typesinprotocols::Union>>>() && {
    return std::make_tuple(std::move(vector_bits), std::move(vector_enum), std::move(vector_struct), std::move(vector_table), std::move(vector_union), std::move(vector_opt_struct), std::move(vector_opt_union)
    );
  }
  
  ::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<::std::unique_ptr<::test::typesinprotocols::Struct>> vector_opt_struct;
  
  ::std::vector<::std::unique_ptr<::test::typesinprotocols::Union>> vector_opt_union;

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

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

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

using VectorCompoundPtr = ::std::unique_ptr<VectorCompound>;


class VectorOptional final {
 public:
  static const fidl_type_t* FidlType;
  VectorOptional() = default;
  explicit VectorOptional(::std::tuple<::fidl::VectorPtr<uint8_t>, ::fidl::VectorPtr<::std::string>, ::fidl::VectorPtr<::std::unique_ptr<::test::typesinprotocols::Struct>>> _value_tuple) {
    std::tie(opt_vector_uint8, opt_vector_string, opt_vector_opt_struct) = std::move(_value_tuple);
  }
  operator ::std::tuple<::fidl::VectorPtr<uint8_t>, ::fidl::VectorPtr<::std::string>, ::fidl::VectorPtr<::std::unique_ptr<::test::typesinprotocols::Struct>>>() && {
    return std::make_tuple(std::move(opt_vector_uint8), std::move(opt_vector_string), std::move(opt_vector_opt_struct)
    );
  }
  
  ::fidl::VectorPtr<uint8_t> opt_vector_uint8;
  
  ::fidl::VectorPtr<::std::string> opt_vector_string;
  
  ::fidl::VectorPtr<::std::unique_ptr<::test::typesinprotocols::Struct>> opt_vector_opt_struct;

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

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

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

using VectorOptionalPtr = ::std::unique_ptr<VectorOptional>;


class ArrayVectorNested final {
 public:
  static const fidl_type_t* FidlType;
  ArrayVectorNested() = default;
  explicit ArrayVectorNested(::std::tuple<::std::array<::std::array<uint8_t, 5>, 5>, ::std::array<::std::vector<uint8_t>, 5>, ::std::vector<::std::array<uint8_t, 5>>, ::std::vector<::std::vector<uint8_t>>> _value_tuple) {
    std::tie(array_array_uint8, array_vector_uint8, vector_array_uint8, vector_vector_uint8) = std::move(_value_tuple);
  }
  operator ::std::tuple<::std::array<::std::array<uint8_t, 5>, 5>, ::std::array<::std::vector<uint8_t>, 5>, ::std::vector<::std::array<uint8_t, 5>>, ::std::vector<::std::vector<uint8_t>>>() && {
    return std::make_tuple(std::move(array_array_uint8), std::move(array_vector_uint8), std::move(vector_array_uint8), std::move(vector_vector_uint8)
    );
  }
  
  ::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;

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

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

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

using ArrayVectorNestedPtr = ::std::unique_ptr<ArrayVectorNested>;


#ifdef __Fuchsia__

class Resource final {
 public:
  static const fidl_type_t* FidlType;
  Resource() = default;
  explicit Resource(::std::tuple<::zx::handle, ::zx::vmo, ::fidl::InterfaceHandle<::test::typesinprotocols::Protocol>, ::fidl::InterfaceRequest<::test::typesinprotocols::Protocol>, ::test::typesinprotocols::ResourceStruct, ::test::typesinprotocols::ResourceTable, ::test::typesinprotocols::ResourceUnion, ::zx::handle, ::zx::vmo, ::fidl::InterfaceHandle<::test::typesinprotocols::Protocol>, ::fidl::InterfaceRequest<::test::typesinprotocols::Protocol>, ::std::unique_ptr<::test::typesinprotocols::ResourceStruct>, ::std::unique_ptr<::test::typesinprotocols::ResourceUnion>, ::std::array<::zx::handle, 5>, ::std::array<::zx::vmo, 5>, ::std::array<::fidl::InterfaceHandle<::test::typesinprotocols::Protocol>, 5>, ::std::array<::fidl::InterfaceRequest<::test::typesinprotocols::Protocol>, 5>, ::std::array<::test::typesinprotocols::ResourceStruct, 5>, ::std::array<::test::typesinprotocols::ResourceTable, 5>, ::std::array<::test::typesinprotocols::ResourceUnion, 5>, ::std::vector<::zx::handle>, ::std::vector<::zx::vmo>, ::std::vector<::fidl::InterfaceHandle<::test::typesinprotocols::Protocol>>, ::std::vector<::fidl::InterfaceRequest<::test::typesinprotocols::Protocol>>, ::std::vector<::test::typesinprotocols::ResourceStruct>, ::std::vector<::test::typesinprotocols::ResourceTable>, ::std::vector<::test::typesinprotocols::ResourceUnion>> _value_tuple) {
    std::tie(handle, vmo, client_end, server_end, struct_, table, union_, opt_handle, opt_vmo, opt_client_end, opt_server_end, opt_struct, opt_union, array_handle, array_vmo, array_client_end, array_server_end, array_struct, array_table, array_union, vector_handle, vector_vmo, vector_client_end, vector_server_end, vector_struct, vector_table, vector_union) = std::move(_value_tuple);
  }
  operator ::std::tuple<::zx::handle, ::zx::vmo, ::fidl::InterfaceHandle<::test::typesinprotocols::Protocol>, ::fidl::InterfaceRequest<::test::typesinprotocols::Protocol>, ::test::typesinprotocols::ResourceStruct, ::test::typesinprotocols::ResourceTable, ::test::typesinprotocols::ResourceUnion, ::zx::handle, ::zx::vmo, ::fidl::InterfaceHandle<::test::typesinprotocols::Protocol>, ::fidl::InterfaceRequest<::test::typesinprotocols::Protocol>, ::std::unique_ptr<::test::typesinprotocols::ResourceStruct>, ::std::unique_ptr<::test::typesinprotocols::ResourceUnion>, ::std::array<::zx::handle, 5>, ::std::array<::zx::vmo, 5>, ::std::array<::fidl::InterfaceHandle<::test::typesinprotocols::Protocol>, 5>, ::std::array<::fidl::InterfaceRequest<::test::typesinprotocols::Protocol>, 5>, ::std::array<::test::typesinprotocols::ResourceStruct, 5>, ::std::array<::test::typesinprotocols::ResourceTable, 5>, ::std::array<::test::typesinprotocols::ResourceUnion, 5>, ::std::vector<::zx::handle>, ::std::vector<::zx::vmo>, ::std::vector<::fidl::InterfaceHandle<::test::typesinprotocols::Protocol>>, ::std::vector<::fidl::InterfaceRequest<::test::typesinprotocols::Protocol>>, ::std::vector<::test::typesinprotocols::ResourceStruct>, ::std::vector<::test::typesinprotocols::ResourceTable>, ::std::vector<::test::typesinprotocols::ResourceUnion>>() && {
    return std::make_tuple(std::move(handle), std::move(vmo), std::move(client_end), std::move(server_end), std::move(struct_), std::move(table), std::move(union_), std::move(opt_handle), std::move(opt_vmo), std::move(opt_client_end), std::move(opt_server_end), std::move(opt_struct), std::move(opt_union), std::move(array_handle), std::move(array_vmo), std::move(array_client_end), std::move(array_server_end), std::move(array_struct), std::move(array_table), std::move(array_union), std::move(vector_handle), std::move(vector_vmo), std::move(vector_client_end), std::move(vector_server_end), std::move(vector_struct), std::move(vector_table), std::move(vector_union)
    );
  }
  
  ::zx::handle handle;
  
  ::zx::vmo vmo;
  
  ::fidl::InterfaceHandle<::test::typesinprotocols::Protocol> client_end;
  
  ::fidl::InterfaceRequest<::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::InterfaceHandle<::test::typesinprotocols::Protocol> opt_client_end;
  
  ::fidl::InterfaceRequest<::test::typesinprotocols::Protocol> opt_server_end;
  
  ::std::unique_ptr<::test::typesinprotocols::ResourceStruct> opt_struct;
  
  ::std::unique_ptr<::test::typesinprotocols::ResourceUnion> opt_union;
  
  ::std::array<::zx::handle, 5> array_handle{};
  
  ::std::array<::zx::vmo, 5> array_vmo{};
  
  ::std::array<::fidl::InterfaceHandle<::test::typesinprotocols::Protocol>, 5> array_client_end{};
  
  ::std::array<::fidl::InterfaceRequest<::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::InterfaceHandle<::test::typesinprotocols::Protocol>> vector_client_end;
  
  ::std::vector<::fidl::InterfaceRequest<::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;

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

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

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

using ResourcePtr = ::std::unique_ptr<Resource>;

#endif  // __Fuchsia__


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

  Protocol_ErrorBasic_Result();
  ~Protocol_ErrorBasic_Result();

  Protocol_ErrorBasic_Result(Protocol_ErrorBasic_Result&&);
  Protocol_ErrorBasic_Result& operator=(Protocol_ErrorBasic_Result&&);

  
  static Protocol_ErrorBasic_Result WithResponse(::test::typesinprotocols::Basic&&);
  static Protocol_ErrorBasic_Result WithErr(uint32_t&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {
  
    kResponse = 1,  // 0x1
    kErr = 2,  // 0x2
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

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

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

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

  bool is_response() const { return tag_ == ::test::typesinprotocols::Protocol_ErrorBasic_Result::Tag::kResponse; }
  
  ::test::typesinprotocols::Basic& response() {
    EnsureStorageInitialized(::test::typesinprotocols::Protocol_ErrorBasic_Result::Tag::kResponse);
    return response_;
  }
  
  const ::test::typesinprotocols::Basic& response() const {
    ZX_ASSERT(is_response());
    return response_;
  }
  Protocol_ErrorBasic_Result& set_response(::test::typesinprotocols::Basic value);

  bool is_err() const { return tag_ == ::test::typesinprotocols::Protocol_ErrorBasic_Result::Tag::kErr; }
  
  uint32_t& err() {
    EnsureStorageInitialized(::test::typesinprotocols::Protocol_ErrorBasic_Result::Tag::kErr);
    return err_;
  }
  
  const uint32_t& err() const {
    ZX_ASSERT(is_err());
    return err_;
  }
  Protocol_ErrorBasic_Result& set_err(uint32_t value);

  ::test::typesinprotocols::Protocol_ErrorBasic_Result::Tag Which() const {
    
    return ::test::typesinprotocols::Protocol_ErrorBasic_Result::Tag(tag_);
    
  }

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

  friend ::fidl::Equality<::test::typesinprotocols::Protocol_ErrorBasic_Result>;
  Protocol_ErrorBasic_Result(fpromise::ok_result<::std::tuple<uint8_t, uint16_t, uint32_t, uint64_t, int8_t, int16_t, int32_t, int64_t, float, double, ::std::string, ::fidl::StringPtr>>&& result) {
    set_response(::test::typesinprotocols::Basic{std::move(result.value)});
  }
  Protocol_ErrorBasic_Result(fpromise::error_result<uint32_t>&& result) {
      set_err(std::move(result.error));
  }
  Protocol_ErrorBasic_Result(fpromise::result<::std::tuple<uint8_t, uint16_t, uint32_t, uint64_t, int8_t, int16_t, int32_t, int64_t, float, double, ::std::string, ::fidl::StringPtr>, uint32_t>&& result) {
    ZX_ASSERT(!result.is_pending());
    if (result.is_ok()) {
      set_response(::test::typesinprotocols::Basic{result.take_value()});
    } else {
      set_err(result.take_error());
    }
  }
  operator fpromise::result<::std::tuple<uint8_t, uint16_t, uint32_t, uint64_t, int8_t, int16_t, int32_t, int64_t, float, double, ::std::string, ::fidl::StringPtr>, uint32_t>() && {
    if (is_err()) {
      return fpromise::error(err());
    }
    return fpromise::ok(std::move(response()));
  }

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

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::typesinprotocols::Protocol_ErrorBasic_Result::Tag::Invalid);
  union {
    ::test::typesinprotocols::Basic response_;
    uint32_t err_;
  };
};

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

using Protocol_ErrorBasic_ResultPtr = ::std::unique_ptr<Protocol_ErrorBasic_Result>;


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

  Protocol_ErrorCompound_Result();
  ~Protocol_ErrorCompound_Result();

  Protocol_ErrorCompound_Result(Protocol_ErrorCompound_Result&&);
  Protocol_ErrorCompound_Result& operator=(Protocol_ErrorCompound_Result&&);

  
  static Protocol_ErrorCompound_Result WithResponse(::test::typesinprotocols::Compound&&);
  static Protocol_ErrorCompound_Result WithErr(uint32_t&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {
  
    kResponse = 1,  // 0x1
    kErr = 2,  // 0x2
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

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

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

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

  bool is_response() const { return tag_ == ::test::typesinprotocols::Protocol_ErrorCompound_Result::Tag::kResponse; }
  
  ::test::typesinprotocols::Compound& response() {
    EnsureStorageInitialized(::test::typesinprotocols::Protocol_ErrorCompound_Result::Tag::kResponse);
    return response_;
  }
  
  const ::test::typesinprotocols::Compound& response() const {
    ZX_ASSERT(is_response());
    return response_;
  }
  Protocol_ErrorCompound_Result& set_response(::test::typesinprotocols::Compound value);

  bool is_err() const { return tag_ == ::test::typesinprotocols::Protocol_ErrorCompound_Result::Tag::kErr; }
  
  uint32_t& err() {
    EnsureStorageInitialized(::test::typesinprotocols::Protocol_ErrorCompound_Result::Tag::kErr);
    return err_;
  }
  
  const uint32_t& err() const {
    ZX_ASSERT(is_err());
    return err_;
  }
  Protocol_ErrorCompound_Result& set_err(uint32_t value);

  ::test::typesinprotocols::Protocol_ErrorCompound_Result::Tag Which() const {
    
    return ::test::typesinprotocols::Protocol_ErrorCompound_Result::Tag(tag_);
    
  }

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

  friend ::fidl::Equality<::test::typesinprotocols::Protocol_ErrorCompound_Result>;
  Protocol_ErrorCompound_Result(fpromise::ok_result<::std::tuple<::test::typesinprotocols::Bits, ::test::typesinprotocols::Enum, ::test::typesinprotocols::Struct, ::test::typesinprotocols::Table, ::test::typesinprotocols::Union, ::std::unique_ptr<::test::typesinprotocols::Struct>, ::std::unique_ptr<::test::typesinprotocols::Union>>>&& result) {
    set_response(::test::typesinprotocols::Compound{std::move(result.value)});
  }
  Protocol_ErrorCompound_Result(fpromise::error_result<uint32_t>&& result) {
      set_err(std::move(result.error));
  }
  Protocol_ErrorCompound_Result(fpromise::result<::std::tuple<::test::typesinprotocols::Bits, ::test::typesinprotocols::Enum, ::test::typesinprotocols::Struct, ::test::typesinprotocols::Table, ::test::typesinprotocols::Union, ::std::unique_ptr<::test::typesinprotocols::Struct>, ::std::unique_ptr<::test::typesinprotocols::Union>>, uint32_t>&& result) {
    ZX_ASSERT(!result.is_pending());
    if (result.is_ok()) {
      set_response(::test::typesinprotocols::Compound{result.take_value()});
    } else {
      set_err(result.take_error());
    }
  }
  operator fpromise::result<::std::tuple<::test::typesinprotocols::Bits, ::test::typesinprotocols::Enum, ::test::typesinprotocols::Struct, ::test::typesinprotocols::Table, ::test::typesinprotocols::Union, ::std::unique_ptr<::test::typesinprotocols::Struct>, ::std::unique_ptr<::test::typesinprotocols::Union>>, uint32_t>() && {
    if (is_err()) {
      return fpromise::error(err());
    }
    return fpromise::ok(std::move(response()));
  }

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

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::typesinprotocols::Protocol_ErrorCompound_Result::Tag::Invalid);
  union {
    ::test::typesinprotocols::Compound response_;
    uint32_t err_;
  };
};

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

using Protocol_ErrorCompound_ResultPtr = ::std::unique_ptr<Protocol_ErrorCompound_Result>;


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

  Protocol_ErrorArrayBasic_Result();
  ~Protocol_ErrorArrayBasic_Result();

  Protocol_ErrorArrayBasic_Result(Protocol_ErrorArrayBasic_Result&&);
  Protocol_ErrorArrayBasic_Result& operator=(Protocol_ErrorArrayBasic_Result&&);

  
  static Protocol_ErrorArrayBasic_Result WithResponse(::test::typesinprotocols::ArrayBasic&&);
  static Protocol_ErrorArrayBasic_Result WithErr(uint32_t&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {
  
    kResponse = 1,  // 0x1
    kErr = 2,  // 0x2
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

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

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

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

  bool is_response() const { return tag_ == ::test::typesinprotocols::Protocol_ErrorArrayBasic_Result::Tag::kResponse; }
  
  ::test::typesinprotocols::ArrayBasic& response() {
    EnsureStorageInitialized(::test::typesinprotocols::Protocol_ErrorArrayBasic_Result::Tag::kResponse);
    return response_;
  }
  
  const ::test::typesinprotocols::ArrayBasic& response() const {
    ZX_ASSERT(is_response());
    return response_;
  }
  Protocol_ErrorArrayBasic_Result& set_response(::test::typesinprotocols::ArrayBasic value);

  bool is_err() const { return tag_ == ::test::typesinprotocols::Protocol_ErrorArrayBasic_Result::Tag::kErr; }
  
  uint32_t& err() {
    EnsureStorageInitialized(::test::typesinprotocols::Protocol_ErrorArrayBasic_Result::Tag::kErr);
    return err_;
  }
  
  const uint32_t& err() const {
    ZX_ASSERT(is_err());
    return err_;
  }
  Protocol_ErrorArrayBasic_Result& set_err(uint32_t value);

  ::test::typesinprotocols::Protocol_ErrorArrayBasic_Result::Tag Which() const {
    
    return ::test::typesinprotocols::Protocol_ErrorArrayBasic_Result::Tag(tag_);
    
  }

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

  friend ::fidl::Equality<::test::typesinprotocols::Protocol_ErrorArrayBasic_Result>;
  Protocol_ErrorArrayBasic_Result(fpromise::ok_result<::std::tuple<::std::array<uint8_t, 5>, ::std::array<uint16_t, 5>, ::std::array<uint32_t, 5>, ::std::array<uint64_t, 5>, ::std::array<int8_t, 5>, ::std::array<int16_t, 5>, ::std::array<int32_t, 5>, ::std::array<int64_t, 5>, ::std::array<float, 5>, ::std::array<double, 5>, ::std::array<::std::string, 5>, ::std::array<::fidl::StringPtr, 5>>>&& result) {
    set_response(::test::typesinprotocols::ArrayBasic{std::move(result.value)});
  }
  Protocol_ErrorArrayBasic_Result(fpromise::error_result<uint32_t>&& result) {
      set_err(std::move(result.error));
  }
  Protocol_ErrorArrayBasic_Result(fpromise::result<::std::tuple<::std::array<uint8_t, 5>, ::std::array<uint16_t, 5>, ::std::array<uint32_t, 5>, ::std::array<uint64_t, 5>, ::std::array<int8_t, 5>, ::std::array<int16_t, 5>, ::std::array<int32_t, 5>, ::std::array<int64_t, 5>, ::std::array<float, 5>, ::std::array<double, 5>, ::std::array<::std::string, 5>, ::std::array<::fidl::StringPtr, 5>>, uint32_t>&& result) {
    ZX_ASSERT(!result.is_pending());
    if (result.is_ok()) {
      set_response(::test::typesinprotocols::ArrayBasic{result.take_value()});
    } else {
      set_err(result.take_error());
    }
  }
  operator fpromise::result<::std::tuple<::std::array<uint8_t, 5>, ::std::array<uint16_t, 5>, ::std::array<uint32_t, 5>, ::std::array<uint64_t, 5>, ::std::array<int8_t, 5>, ::std::array<int16_t, 5>, ::std::array<int32_t, 5>, ::std::array<int64_t, 5>, ::std::array<float, 5>, ::std::array<double, 5>, ::std::array<::std::string, 5>, ::std::array<::fidl::StringPtr, 5>>, uint32_t>() && {
    if (is_err()) {
      return fpromise::error(err());
    }
    return fpromise::ok(std::move(response()));
  }

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

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::typesinprotocols::Protocol_ErrorArrayBasic_Result::Tag::Invalid);
  union {
    ::test::typesinprotocols::ArrayBasic response_;
    uint32_t err_;
  };
};

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

using Protocol_ErrorArrayBasic_ResultPtr = ::std::unique_ptr<Protocol_ErrorArrayBasic_Result>;


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

  Protocol_ErrorArrayCompound_Result();
  ~Protocol_ErrorArrayCompound_Result();

  Protocol_ErrorArrayCompound_Result(Protocol_ErrorArrayCompound_Result&&);
  Protocol_ErrorArrayCompound_Result& operator=(Protocol_ErrorArrayCompound_Result&&);

  
  static Protocol_ErrorArrayCompound_Result WithResponse(::test::typesinprotocols::ArrayCompound&&);
  static Protocol_ErrorArrayCompound_Result WithErr(uint32_t&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {
  
    kResponse = 1,  // 0x1
    kErr = 2,  // 0x2
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

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

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

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

  bool is_response() const { return tag_ == ::test::typesinprotocols::Protocol_ErrorArrayCompound_Result::Tag::kResponse; }
  
  ::test::typesinprotocols::ArrayCompound& response() {
    EnsureStorageInitialized(::test::typesinprotocols::Protocol_ErrorArrayCompound_Result::Tag::kResponse);
    return response_;
  }
  
  const ::test::typesinprotocols::ArrayCompound& response() const {
    ZX_ASSERT(is_response());
    return response_;
  }
  Protocol_ErrorArrayCompound_Result& set_response(::test::typesinprotocols::ArrayCompound value);

  bool is_err() const { return tag_ == ::test::typesinprotocols::Protocol_ErrorArrayCompound_Result::Tag::kErr; }
  
  uint32_t& err() {
    EnsureStorageInitialized(::test::typesinprotocols::Protocol_ErrorArrayCompound_Result::Tag::kErr);
    return err_;
  }
  
  const uint32_t& err() const {
    ZX_ASSERT(is_err());
    return err_;
  }
  Protocol_ErrorArrayCompound_Result& set_err(uint32_t value);

  ::test::typesinprotocols::Protocol_ErrorArrayCompound_Result::Tag Which() const {
    
    return ::test::typesinprotocols::Protocol_ErrorArrayCompound_Result::Tag(tag_);
    
  }

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

  friend ::fidl::Equality<::test::typesinprotocols::Protocol_ErrorArrayCompound_Result>;
  Protocol_ErrorArrayCompound_Result(fpromise::ok_result<::std::tuple<::std::array<::test::typesinprotocols::Bits, 5>, ::std::array<::test::typesinprotocols::Enum, 5>, ::std::array<::test::typesinprotocols::Struct, 5>, ::std::array<::test::typesinprotocols::Table, 5>, ::std::array<::test::typesinprotocols::Union, 5>, ::std::array<::std::unique_ptr<::test::typesinprotocols::Struct>, 5>, ::std::array<::std::unique_ptr<::test::typesinprotocols::Union>, 5>>>&& result) {
    set_response(::test::typesinprotocols::ArrayCompound{std::move(result.value)});
  }
  Protocol_ErrorArrayCompound_Result(fpromise::error_result<uint32_t>&& result) {
      set_err(std::move(result.error));
  }
  Protocol_ErrorArrayCompound_Result(fpromise::result<::std::tuple<::std::array<::test::typesinprotocols::Bits, 5>, ::std::array<::test::typesinprotocols::Enum, 5>, ::std::array<::test::typesinprotocols::Struct, 5>, ::std::array<::test::typesinprotocols::Table, 5>, ::std::array<::test::typesinprotocols::Union, 5>, ::std::array<::std::unique_ptr<::test::typesinprotocols::Struct>, 5>, ::std::array<::std::unique_ptr<::test::typesinprotocols::Union>, 5>>, uint32_t>&& result) {
    ZX_ASSERT(!result.is_pending());
    if (result.is_ok()) {
      set_response(::test::typesinprotocols::ArrayCompound{result.take_value()});
    } else {
      set_err(result.take_error());
    }
  }
  operator fpromise::result<::std::tuple<::std::array<::test::typesinprotocols::Bits, 5>, ::std::array<::test::typesinprotocols::Enum, 5>, ::std::array<::test::typesinprotocols::Struct, 5>, ::std::array<::test::typesinprotocols::Table, 5>, ::std::array<::test::typesinprotocols::Union, 5>, ::std::array<::std::unique_ptr<::test::typesinprotocols::Struct>, 5>, ::std::array<::std::unique_ptr<::test::typesinprotocols::Union>, 5>>, uint32_t>() && {
    if (is_err()) {
      return fpromise::error(err());
    }
    return fpromise::ok(std::move(response()));
  }

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

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::typesinprotocols::Protocol_ErrorArrayCompound_Result::Tag::Invalid);
  union {
    ::test::typesinprotocols::ArrayCompound response_;
    uint32_t err_;
  };
};

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

using Protocol_ErrorArrayCompound_ResultPtr = ::std::unique_ptr<Protocol_ErrorArrayCompound_Result>;


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

  Protocol_ErrorVectorBasic_Result();
  ~Protocol_ErrorVectorBasic_Result();

  Protocol_ErrorVectorBasic_Result(Protocol_ErrorVectorBasic_Result&&);
  Protocol_ErrorVectorBasic_Result& operator=(Protocol_ErrorVectorBasic_Result&&);

  
  static Protocol_ErrorVectorBasic_Result WithResponse(::test::typesinprotocols::VectorBasic&&);
  static Protocol_ErrorVectorBasic_Result WithErr(uint32_t&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {
  
    kResponse = 1,  // 0x1
    kErr = 2,  // 0x2
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

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

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

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

  bool is_response() const { return tag_ == ::test::typesinprotocols::Protocol_ErrorVectorBasic_Result::Tag::kResponse; }
  
  ::test::typesinprotocols::VectorBasic& response() {
    EnsureStorageInitialized(::test::typesinprotocols::Protocol_ErrorVectorBasic_Result::Tag::kResponse);
    return response_;
  }
  
  const ::test::typesinprotocols::VectorBasic& response() const {
    ZX_ASSERT(is_response());
    return response_;
  }
  Protocol_ErrorVectorBasic_Result& set_response(::test::typesinprotocols::VectorBasic value);

  bool is_err() const { return tag_ == ::test::typesinprotocols::Protocol_ErrorVectorBasic_Result::Tag::kErr; }
  
  uint32_t& err() {
    EnsureStorageInitialized(::test::typesinprotocols::Protocol_ErrorVectorBasic_Result::Tag::kErr);
    return err_;
  }
  
  const uint32_t& err() const {
    ZX_ASSERT(is_err());
    return err_;
  }
  Protocol_ErrorVectorBasic_Result& set_err(uint32_t value);

  ::test::typesinprotocols::Protocol_ErrorVectorBasic_Result::Tag Which() const {
    
    return ::test::typesinprotocols::Protocol_ErrorVectorBasic_Result::Tag(tag_);
    
  }

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

  friend ::fidl::Equality<::test::typesinprotocols::Protocol_ErrorVectorBasic_Result>;
  Protocol_ErrorVectorBasic_Result(fpromise::ok_result<::std::tuple<::std::vector<uint8_t>, ::std::vector<uint16_t>, ::std::vector<uint32_t>, ::std::vector<uint64_t>, ::std::vector<int8_t>, ::std::vector<int16_t>, ::std::vector<int32_t>, ::std::vector<int64_t>, ::std::vector<float>, ::std::vector<double>, ::std::vector<::std::string>, ::std::vector<::fidl::StringPtr>>>&& result) {
    set_response(::test::typesinprotocols::VectorBasic{std::move(result.value)});
  }
  Protocol_ErrorVectorBasic_Result(fpromise::error_result<uint32_t>&& result) {
      set_err(std::move(result.error));
  }
  Protocol_ErrorVectorBasic_Result(fpromise::result<::std::tuple<::std::vector<uint8_t>, ::std::vector<uint16_t>, ::std::vector<uint32_t>, ::std::vector<uint64_t>, ::std::vector<int8_t>, ::std::vector<int16_t>, ::std::vector<int32_t>, ::std::vector<int64_t>, ::std::vector<float>, ::std::vector<double>, ::std::vector<::std::string>, ::std::vector<::fidl::StringPtr>>, uint32_t>&& result) {
    ZX_ASSERT(!result.is_pending());
    if (result.is_ok()) {
      set_response(::test::typesinprotocols::VectorBasic{result.take_value()});
    } else {
      set_err(result.take_error());
    }
  }
  operator fpromise::result<::std::tuple<::std::vector<uint8_t>, ::std::vector<uint16_t>, ::std::vector<uint32_t>, ::std::vector<uint64_t>, ::std::vector<int8_t>, ::std::vector<int16_t>, ::std::vector<int32_t>, ::std::vector<int64_t>, ::std::vector<float>, ::std::vector<double>, ::std::vector<::std::string>, ::std::vector<::fidl::StringPtr>>, uint32_t>() && {
    if (is_err()) {
      return fpromise::error(err());
    }
    return fpromise::ok(std::move(response()));
  }

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

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::typesinprotocols::Protocol_ErrorVectorBasic_Result::Tag::Invalid);
  union {
    ::test::typesinprotocols::VectorBasic response_;
    uint32_t err_;
  };
};

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

using Protocol_ErrorVectorBasic_ResultPtr = ::std::unique_ptr<Protocol_ErrorVectorBasic_Result>;


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

  Protocol_ErrorVectorCompound_Result();
  ~Protocol_ErrorVectorCompound_Result();

  Protocol_ErrorVectorCompound_Result(Protocol_ErrorVectorCompound_Result&&);
  Protocol_ErrorVectorCompound_Result& operator=(Protocol_ErrorVectorCompound_Result&&);

  
  static Protocol_ErrorVectorCompound_Result WithResponse(::test::typesinprotocols::VectorCompound&&);
  static Protocol_ErrorVectorCompound_Result WithErr(uint32_t&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {
  
    kResponse = 1,  // 0x1
    kErr = 2,  // 0x2
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

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

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

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

  bool is_response() const { return tag_ == ::test::typesinprotocols::Protocol_ErrorVectorCompound_Result::Tag::kResponse; }
  
  ::test::typesinprotocols::VectorCompound& response() {
    EnsureStorageInitialized(::test::typesinprotocols::Protocol_ErrorVectorCompound_Result::Tag::kResponse);
    return response_;
  }
  
  const ::test::typesinprotocols::VectorCompound& response() const {
    ZX_ASSERT(is_response());
    return response_;
  }
  Protocol_ErrorVectorCompound_Result& set_response(::test::typesinprotocols::VectorCompound value);

  bool is_err() const { return tag_ == ::test::typesinprotocols::Protocol_ErrorVectorCompound_Result::Tag::kErr; }
  
  uint32_t& err() {
    EnsureStorageInitialized(::test::typesinprotocols::Protocol_ErrorVectorCompound_Result::Tag::kErr);
    return err_;
  }
  
  const uint32_t& err() const {
    ZX_ASSERT(is_err());
    return err_;
  }
  Protocol_ErrorVectorCompound_Result& set_err(uint32_t value);

  ::test::typesinprotocols::Protocol_ErrorVectorCompound_Result::Tag Which() const {
    
    return ::test::typesinprotocols::Protocol_ErrorVectorCompound_Result::Tag(tag_);
    
  }

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

  friend ::fidl::Equality<::test::typesinprotocols::Protocol_ErrorVectorCompound_Result>;
  Protocol_ErrorVectorCompound_Result(fpromise::ok_result<::std::tuple<::std::vector<::test::typesinprotocols::Bits>, ::std::vector<::test::typesinprotocols::Enum>, ::std::vector<::test::typesinprotocols::Struct>, ::std::vector<::test::typesinprotocols::Table>, ::std::vector<::test::typesinprotocols::Union>, ::std::vector<::std::unique_ptr<::test::typesinprotocols::Struct>>, ::std::vector<::std::unique_ptr<::test::typesinprotocols::Union>>>>&& result) {
    set_response(::test::typesinprotocols::VectorCompound{std::move(result.value)});
  }
  Protocol_ErrorVectorCompound_Result(fpromise::error_result<uint32_t>&& result) {
      set_err(std::move(result.error));
  }
  Protocol_ErrorVectorCompound_Result(fpromise::result<::std::tuple<::std::vector<::test::typesinprotocols::Bits>, ::std::vector<::test::typesinprotocols::Enum>, ::std::vector<::test::typesinprotocols::Struct>, ::std::vector<::test::typesinprotocols::Table>, ::std::vector<::test::typesinprotocols::Union>, ::std::vector<::std::unique_ptr<::test::typesinprotocols::Struct>>, ::std::vector<::std::unique_ptr<::test::typesinprotocols::Union>>>, uint32_t>&& result) {
    ZX_ASSERT(!result.is_pending());
    if (result.is_ok()) {
      set_response(::test::typesinprotocols::VectorCompound{result.take_value()});
    } else {
      set_err(result.take_error());
    }
  }
  operator fpromise::result<::std::tuple<::std::vector<::test::typesinprotocols::Bits>, ::std::vector<::test::typesinprotocols::Enum>, ::std::vector<::test::typesinprotocols::Struct>, ::std::vector<::test::typesinprotocols::Table>, ::std::vector<::test::typesinprotocols::Union>, ::std::vector<::std::unique_ptr<::test::typesinprotocols::Struct>>, ::std::vector<::std::unique_ptr<::test::typesinprotocols::Union>>>, uint32_t>() && {
    if (is_err()) {
      return fpromise::error(err());
    }
    return fpromise::ok(std::move(response()));
  }

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

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::typesinprotocols::Protocol_ErrorVectorCompound_Result::Tag::Invalid);
  union {
    ::test::typesinprotocols::VectorCompound response_;
    uint32_t err_;
  };
};

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

using Protocol_ErrorVectorCompound_ResultPtr = ::std::unique_ptr<Protocol_ErrorVectorCompound_Result>;


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

  Protocol_ErrorVectorOptional_Result();
  ~Protocol_ErrorVectorOptional_Result();

  Protocol_ErrorVectorOptional_Result(Protocol_ErrorVectorOptional_Result&&);
  Protocol_ErrorVectorOptional_Result& operator=(Protocol_ErrorVectorOptional_Result&&);

  
  static Protocol_ErrorVectorOptional_Result WithResponse(::test::typesinprotocols::VectorOptional&&);
  static Protocol_ErrorVectorOptional_Result WithErr(uint32_t&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {
  
    kResponse = 1,  // 0x1
    kErr = 2,  // 0x2
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

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

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

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

  bool is_response() const { return tag_ == ::test::typesinprotocols::Protocol_ErrorVectorOptional_Result::Tag::kResponse; }
  
  ::test::typesinprotocols::VectorOptional& response() {
    EnsureStorageInitialized(::test::typesinprotocols::Protocol_ErrorVectorOptional_Result::Tag::kResponse);
    return response_;
  }
  
  const ::test::typesinprotocols::VectorOptional& response() const {
    ZX_ASSERT(is_response());
    return response_;
  }
  Protocol_ErrorVectorOptional_Result& set_response(::test::typesinprotocols::VectorOptional value);

  bool is_err() const { return tag_ == ::test::typesinprotocols::Protocol_ErrorVectorOptional_Result::Tag::kErr; }
  
  uint32_t& err() {
    EnsureStorageInitialized(::test::typesinprotocols::Protocol_ErrorVectorOptional_Result::Tag::kErr);
    return err_;
  }
  
  const uint32_t& err() const {
    ZX_ASSERT(is_err());
    return err_;
  }
  Protocol_ErrorVectorOptional_Result& set_err(uint32_t value);

  ::test::typesinprotocols::Protocol_ErrorVectorOptional_Result::Tag Which() const {
    
    return ::test::typesinprotocols::Protocol_ErrorVectorOptional_Result::Tag(tag_);
    
  }

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

  friend ::fidl::Equality<::test::typesinprotocols::Protocol_ErrorVectorOptional_Result>;
  Protocol_ErrorVectorOptional_Result(fpromise::ok_result<::std::tuple<::fidl::VectorPtr<uint8_t>, ::fidl::VectorPtr<::std::string>, ::fidl::VectorPtr<::std::unique_ptr<::test::typesinprotocols::Struct>>>>&& result) {
    set_response(::test::typesinprotocols::VectorOptional{std::move(result.value)});
  }
  Protocol_ErrorVectorOptional_Result(fpromise::error_result<uint32_t>&& result) {
      set_err(std::move(result.error));
  }
  Protocol_ErrorVectorOptional_Result(fpromise::result<::std::tuple<::fidl::VectorPtr<uint8_t>, ::fidl::VectorPtr<::std::string>, ::fidl::VectorPtr<::std::unique_ptr<::test::typesinprotocols::Struct>>>, uint32_t>&& result) {
    ZX_ASSERT(!result.is_pending());
    if (result.is_ok()) {
      set_response(::test::typesinprotocols::VectorOptional{result.take_value()});
    } else {
      set_err(result.take_error());
    }
  }
  operator fpromise::result<::std::tuple<::fidl::VectorPtr<uint8_t>, ::fidl::VectorPtr<::std::string>, ::fidl::VectorPtr<::std::unique_ptr<::test::typesinprotocols::Struct>>>, uint32_t>() && {
    if (is_err()) {
      return fpromise::error(err());
    }
    return fpromise::ok(std::move(response()));
  }

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

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::typesinprotocols::Protocol_ErrorVectorOptional_Result::Tag::Invalid);
  union {
    ::test::typesinprotocols::VectorOptional response_;
    uint32_t err_;
  };
};

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

using Protocol_ErrorVectorOptional_ResultPtr = ::std::unique_ptr<Protocol_ErrorVectorOptional_Result>;


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

  Protocol_ErrorArrayVectorNested_Result();
  ~Protocol_ErrorArrayVectorNested_Result();

  Protocol_ErrorArrayVectorNested_Result(Protocol_ErrorArrayVectorNested_Result&&);
  Protocol_ErrorArrayVectorNested_Result& operator=(Protocol_ErrorArrayVectorNested_Result&&);

  
  static Protocol_ErrorArrayVectorNested_Result WithResponse(::test::typesinprotocols::ArrayVectorNested&&);
  static Protocol_ErrorArrayVectorNested_Result WithErr(uint32_t&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {
  
    kResponse = 1,  // 0x1
    kErr = 2,  // 0x2
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

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

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

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

  bool is_response() const { return tag_ == ::test::typesinprotocols::Protocol_ErrorArrayVectorNested_Result::Tag::kResponse; }
  
  ::test::typesinprotocols::ArrayVectorNested& response() {
    EnsureStorageInitialized(::test::typesinprotocols::Protocol_ErrorArrayVectorNested_Result::Tag::kResponse);
    return response_;
  }
  
  const ::test::typesinprotocols::ArrayVectorNested& response() const {
    ZX_ASSERT(is_response());
    return response_;
  }
  Protocol_ErrorArrayVectorNested_Result& set_response(::test::typesinprotocols::ArrayVectorNested value);

  bool is_err() const { return tag_ == ::test::typesinprotocols::Protocol_ErrorArrayVectorNested_Result::Tag::kErr; }
  
  uint32_t& err() {
    EnsureStorageInitialized(::test::typesinprotocols::Protocol_ErrorArrayVectorNested_Result::Tag::kErr);
    return err_;
  }
  
  const uint32_t& err() const {
    ZX_ASSERT(is_err());
    return err_;
  }
  Protocol_ErrorArrayVectorNested_Result& set_err(uint32_t value);

  ::test::typesinprotocols::Protocol_ErrorArrayVectorNested_Result::Tag Which() const {
    
    return ::test::typesinprotocols::Protocol_ErrorArrayVectorNested_Result::Tag(tag_);
    
  }

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

  friend ::fidl::Equality<::test::typesinprotocols::Protocol_ErrorArrayVectorNested_Result>;
  Protocol_ErrorArrayVectorNested_Result(fpromise::ok_result<::std::tuple<::std::array<::std::array<uint8_t, 5>, 5>, ::std::array<::std::vector<uint8_t>, 5>, ::std::vector<::std::array<uint8_t, 5>>, ::std::vector<::std::vector<uint8_t>>>>&& result) {
    set_response(::test::typesinprotocols::ArrayVectorNested{std::move(result.value)});
  }
  Protocol_ErrorArrayVectorNested_Result(fpromise::error_result<uint32_t>&& result) {
      set_err(std::move(result.error));
  }
  Protocol_ErrorArrayVectorNested_Result(fpromise::result<::std::tuple<::std::array<::std::array<uint8_t, 5>, 5>, ::std::array<::std::vector<uint8_t>, 5>, ::std::vector<::std::array<uint8_t, 5>>, ::std::vector<::std::vector<uint8_t>>>, uint32_t>&& result) {
    ZX_ASSERT(!result.is_pending());
    if (result.is_ok()) {
      set_response(::test::typesinprotocols::ArrayVectorNested{result.take_value()});
    } else {
      set_err(result.take_error());
    }
  }
  operator fpromise::result<::std::tuple<::std::array<::std::array<uint8_t, 5>, 5>, ::std::array<::std::vector<uint8_t>, 5>, ::std::vector<::std::array<uint8_t, 5>>, ::std::vector<::std::vector<uint8_t>>>, uint32_t>() && {
    if (is_err()) {
      return fpromise::error(err());
    }
    return fpromise::ok(std::move(response()));
  }

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

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::typesinprotocols::Protocol_ErrorArrayVectorNested_Result::Tag::Invalid);
  union {
    ::test::typesinprotocols::ArrayVectorNested response_;
    uint32_t err_;
  };
};

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

using Protocol_ErrorArrayVectorNested_ResultPtr = ::std::unique_ptr<Protocol_ErrorArrayVectorNested_Result>;


#ifdef __Fuchsia__

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

  Protocol_ErrorResource_Result();
  ~Protocol_ErrorResource_Result();

  Protocol_ErrorResource_Result(Protocol_ErrorResource_Result&&);
  Protocol_ErrorResource_Result& operator=(Protocol_ErrorResource_Result&&);

  
  static Protocol_ErrorResource_Result WithResponse(::test::typesinprotocols::Resource&&);
  static Protocol_ErrorResource_Result WithErr(uint32_t&&);

  enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t {
  
    kResponse = 1,  // 0x1
    kErr = 2,  // 0x2
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

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

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

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

  bool is_response() const { return tag_ == ::test::typesinprotocols::Protocol_ErrorResource_Result::Tag::kResponse; }
  
  ::test::typesinprotocols::Resource& response() {
    EnsureStorageInitialized(::test::typesinprotocols::Protocol_ErrorResource_Result::Tag::kResponse);
    return response_;
  }
  
  const ::test::typesinprotocols::Resource& response() const {
    ZX_ASSERT(is_response());
    return response_;
  }
  Protocol_ErrorResource_Result& set_response(::test::typesinprotocols::Resource value);

  bool is_err() const { return tag_ == ::test::typesinprotocols::Protocol_ErrorResource_Result::Tag::kErr; }
  
  uint32_t& err() {
    EnsureStorageInitialized(::test::typesinprotocols::Protocol_ErrorResource_Result::Tag::kErr);
    return err_;
  }
  
  const uint32_t& err() const {
    ZX_ASSERT(is_err());
    return err_;
  }
  Protocol_ErrorResource_Result& set_err(uint32_t value);

  ::test::typesinprotocols::Protocol_ErrorResource_Result::Tag Which() const {
    
    return ::test::typesinprotocols::Protocol_ErrorResource_Result::Tag(tag_);
    
  }

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

  friend ::fidl::Equality<::test::typesinprotocols::Protocol_ErrorResource_Result>;
  Protocol_ErrorResource_Result(fpromise::ok_result<::std::tuple<::zx::handle, ::zx::vmo, ::fidl::InterfaceHandle<::test::typesinprotocols::Protocol>, ::fidl::InterfaceRequest<::test::typesinprotocols::Protocol>, ::test::typesinprotocols::ResourceStruct, ::test::typesinprotocols::ResourceTable, ::test::typesinprotocols::ResourceUnion, ::zx::handle, ::zx::vmo, ::fidl::InterfaceHandle<::test::typesinprotocols::Protocol>, ::fidl::InterfaceRequest<::test::typesinprotocols::Protocol>, ::std::unique_ptr<::test::typesinprotocols::ResourceStruct>, ::std::unique_ptr<::test::typesinprotocols::ResourceUnion>, ::std::array<::zx::handle, 5>, ::std::array<::zx::vmo, 5>, ::std::array<::fidl::InterfaceHandle<::test::typesinprotocols::Protocol>, 5>, ::std::array<::fidl::InterfaceRequest<::test::typesinprotocols::Protocol>, 5>, ::std::array<::test::typesinprotocols::ResourceStruct, 5>, ::std::array<::test::typesinprotocols::ResourceTable, 5>, ::std::array<::test::typesinprotocols::ResourceUnion, 5>, ::std::vector<::zx::handle>, ::std::vector<::zx::vmo>, ::std::vector<::fidl::InterfaceHandle<::test::typesinprotocols::Protocol>>, ::std::vector<::fidl::InterfaceRequest<::test::typesinprotocols::Protocol>>, ::std::vector<::test::typesinprotocols::ResourceStruct>, ::std::vector<::test::typesinprotocols::ResourceTable>, ::std::vector<::test::typesinprotocols::ResourceUnion>>>&& result) {
    set_response(::test::typesinprotocols::Resource{std::move(result.value)});
  }
  Protocol_ErrorResource_Result(fpromise::error_result<uint32_t>&& result) {
      set_err(std::move(result.error));
  }
  Protocol_ErrorResource_Result(fpromise::result<::std::tuple<::zx::handle, ::zx::vmo, ::fidl::InterfaceHandle<::test::typesinprotocols::Protocol>, ::fidl::InterfaceRequest<::test::typesinprotocols::Protocol>, ::test::typesinprotocols::ResourceStruct, ::test::typesinprotocols::ResourceTable, ::test::typesinprotocols::ResourceUnion, ::zx::handle, ::zx::vmo, ::fidl::InterfaceHandle<::test::typesinprotocols::Protocol>, ::fidl::InterfaceRequest<::test::typesinprotocols::Protocol>, ::std::unique_ptr<::test::typesinprotocols::ResourceStruct>, ::std::unique_ptr<::test::typesinprotocols::ResourceUnion>, ::std::array<::zx::handle, 5>, ::std::array<::zx::vmo, 5>, ::std::array<::fidl::InterfaceHandle<::test::typesinprotocols::Protocol>, 5>, ::std::array<::fidl::InterfaceRequest<::test::typesinprotocols::Protocol>, 5>, ::std::array<::test::typesinprotocols::ResourceStruct, 5>, ::std::array<::test::typesinprotocols::ResourceTable, 5>, ::std::array<::test::typesinprotocols::ResourceUnion, 5>, ::std::vector<::zx::handle>, ::std::vector<::zx::vmo>, ::std::vector<::fidl::InterfaceHandle<::test::typesinprotocols::Protocol>>, ::std::vector<::fidl::InterfaceRequest<::test::typesinprotocols::Protocol>>, ::std::vector<::test::typesinprotocols::ResourceStruct>, ::std::vector<::test::typesinprotocols::ResourceTable>, ::std::vector<::test::typesinprotocols::ResourceUnion>>, uint32_t>&& result) {
    ZX_ASSERT(!result.is_pending());
    if (result.is_ok()) {
      set_response(::test::typesinprotocols::Resource{result.take_value()});
    } else {
      set_err(result.take_error());
    }
  }
  operator fpromise::result<::std::tuple<::zx::handle, ::zx::vmo, ::fidl::InterfaceHandle<::test::typesinprotocols::Protocol>, ::fidl::InterfaceRequest<::test::typesinprotocols::Protocol>, ::test::typesinprotocols::ResourceStruct, ::test::typesinprotocols::ResourceTable, ::test::typesinprotocols::ResourceUnion, ::zx::handle, ::zx::vmo, ::fidl::InterfaceHandle<::test::typesinprotocols::Protocol>, ::fidl::InterfaceRequest<::test::typesinprotocols::Protocol>, ::std::unique_ptr<::test::typesinprotocols::ResourceStruct>, ::std::unique_ptr<::test::typesinprotocols::ResourceUnion>, ::std::array<::zx::handle, 5>, ::std::array<::zx::vmo, 5>, ::std::array<::fidl::InterfaceHandle<::test::typesinprotocols::Protocol>, 5>, ::std::array<::fidl::InterfaceRequest<::test::typesinprotocols::Protocol>, 5>, ::std::array<::test::typesinprotocols::ResourceStruct, 5>, ::std::array<::test::typesinprotocols::ResourceTable, 5>, ::std::array<::test::typesinprotocols::ResourceUnion, 5>, ::std::vector<::zx::handle>, ::std::vector<::zx::vmo>, ::std::vector<::fidl::InterfaceHandle<::test::typesinprotocols::Protocol>>, ::std::vector<::fidl::InterfaceRequest<::test::typesinprotocols::Protocol>>, ::std::vector<::test::typesinprotocols::ResourceStruct>, ::std::vector<::test::typesinprotocols::ResourceTable>, ::std::vector<::test::typesinprotocols::ResourceUnion>>, uint32_t>() && {
    if (is_err()) {
      return fpromise::error(err());
    }
    return fpromise::ok(std::move(response()));
  }

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

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::typesinprotocols::Protocol_ErrorResource_Result::Tag::Invalid);
  union {
    ::test::typesinprotocols::Resource response_;
    uint32_t err_;
  };
};

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

using Protocol_ErrorResource_ResultPtr = ::std::unique_ptr<Protocol_ErrorResource_Result>;

#endif  // __Fuchsia__


#ifdef __Fuchsia__

  namespace _internal {
__LOCAL extern "C" const fidl_type_t test_typesinprotocols_BasicTable;
  
  
__LOCAL extern "C" const fidl_type_t test_typesinprotocols_CompoundTable;
  
  
__LOCAL extern "C" const fidl_type_t test_typesinprotocols_ArrayBasicTable;
  
  
__LOCAL extern "C" const fidl_type_t test_typesinprotocols_ArrayCompoundTable;
  
  
__LOCAL extern "C" const fidl_type_t test_typesinprotocols_VectorBasicTable;
  
  
__LOCAL extern "C" const fidl_type_t test_typesinprotocols_VectorCompoundTable;
  
  
__LOCAL extern "C" const fidl_type_t test_typesinprotocols_VectorOptionalTable;
  
  
__LOCAL extern "C" const fidl_type_t test_typesinprotocols_ArrayVectorNestedTable;
  
  
__LOCAL extern "C" const fidl_type_t test_typesinprotocols_ResourceTable;
  
  
}  // namespace _internal

class Protocol_RequestEncoder {
 public:
  static ::fidl::HLCPPOutgoingMessage OneWayBasic(::fidl::MessageEncoder* _encoder, 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, ::fidl::StringPtr* opt_string) {
    _encoder->Alloc(80);
    ::fidl::Encode(_encoder, uint8, 0 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, uint16, 2 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, uint32, 4 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, uint64, 8 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, int8, 16 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, int16, 18 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, int32, 20 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, int64, 24 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, float32, 32 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, float64, 40 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, string, 48 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, opt_string, 64 + sizeof(fidl_message_header_t));
    

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage TwoWayBasic(::fidl::MessageEncoder* _encoder, 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, ::fidl::StringPtr* opt_string) {
    _encoder->Alloc(80);
    ::fidl::Encode(_encoder, uint8, 0 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, uint16, 2 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, uint32, 4 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, uint64, 8 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, int8, 16 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, int16, 18 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, int32, 20 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, int64, 24 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, float32, 32 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, float64, 40 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, string, 48 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, opt_string, 64 + sizeof(fidl_message_header_t));
    

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage ErrorBasic(::fidl::MessageEncoder* _encoder) {

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage OneWayCompound(::fidl::MessageEncoder* _encoder, ::test::typesinprotocols::Bits* bits, ::test::typesinprotocols::Enum* enum_, ::test::typesinprotocols::Struct* struct_, ::test::typesinprotocols::Table* table, ::test::typesinprotocols::Union* union_, ::std::unique_ptr<::test::typesinprotocols::Struct>* opt_struct, ::std::unique_ptr<::test::typesinprotocols::Union>* opt_union) {
    _encoder->Alloc(72);
    ::fidl::Encode(_encoder, bits, 0 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, enum_, 4 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, struct_, 8 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, table, 16 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, union_, 32 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, opt_struct, 48 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, opt_union, 56 + sizeof(fidl_message_header_t));
    

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage TwoWayCompound(::fidl::MessageEncoder* _encoder, ::test::typesinprotocols::Bits* bits, ::test::typesinprotocols::Enum* enum_, ::test::typesinprotocols::Struct* struct_, ::test::typesinprotocols::Table* table, ::test::typesinprotocols::Union* union_, ::std::unique_ptr<::test::typesinprotocols::Struct>* opt_struct, ::std::unique_ptr<::test::typesinprotocols::Union>* opt_union) {
    _encoder->Alloc(72);
    ::fidl::Encode(_encoder, bits, 0 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, enum_, 4 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, struct_, 8 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, table, 16 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, union_, 32 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, opt_struct, 48 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, opt_union, 56 + sizeof(fidl_message_header_t));
    

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage ErrorCompound(::fidl::MessageEncoder* _encoder) {

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage OneWayArrayBasic(::fidl::MessageEncoder* _encoder, ::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<::fidl::StringPtr, 5>* array_opt_string) {
    _encoder->Alloc(384);
    ::fidl::Encode(_encoder, array_uint8, 0 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_uint16, 6 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_uint32, 16 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_uint64, 40 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_int8, 80 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_int16, 86 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_int32, 96 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_int64, 120 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_float32, 160 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_float64, 184 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_string, 224 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_opt_string, 304 + sizeof(fidl_message_header_t));
    

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage TwoWayArrayBasic(::fidl::MessageEncoder* _encoder, ::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<::fidl::StringPtr, 5>* array_opt_string) {
    _encoder->Alloc(384);
    ::fidl::Encode(_encoder, array_uint8, 0 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_uint16, 6 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_uint32, 16 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_uint64, 40 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_int8, 80 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_int16, 86 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_int32, 96 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_int64, 120 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_float32, 160 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_float64, 184 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_string, 224 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_opt_string, 304 + sizeof(fidl_message_header_t));
    

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage ErrorArrayBasic(::fidl::MessageEncoder* _encoder) {

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage OneWayArrayCompound(::fidl::MessageEncoder* _encoder, ::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<::std::unique_ptr<::test::typesinprotocols::Struct>, 5>* array_opt_struct, ::std::array<::std::unique_ptr<::test::typesinprotocols::Union>, 5>* array_opt_union) {
    _encoder->Alloc(328);
    ::fidl::Encode(_encoder, array_bits, 0 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_enum, 20 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_struct, 40 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_table, 48 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_union, 128 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_opt_struct, 208 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_opt_union, 248 + sizeof(fidl_message_header_t));
    

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage TwoWayArrayCompound(::fidl::MessageEncoder* _encoder, ::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<::std::unique_ptr<::test::typesinprotocols::Struct>, 5>* array_opt_struct, ::std::array<::std::unique_ptr<::test::typesinprotocols::Union>, 5>* array_opt_union) {
    _encoder->Alloc(328);
    ::fidl::Encode(_encoder, array_bits, 0 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_enum, 20 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_struct, 40 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_table, 48 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_union, 128 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_opt_struct, 208 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_opt_union, 248 + sizeof(fidl_message_header_t));
    

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage ErrorArrayCompound(::fidl::MessageEncoder* _encoder) {

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage OneWayVectorBasic(::fidl::MessageEncoder* _encoder, ::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<::fidl::StringPtr>* vector_opt_string) {
    _encoder->Alloc(192);
    ::fidl::Encode(_encoder, vector_uint8, 0 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_uint16, 16 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_uint32, 32 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_uint64, 48 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_int8, 64 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_int16, 80 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_int32, 96 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_int64, 112 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_float32, 128 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_float64, 144 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_string, 160 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_opt_string, 176 + sizeof(fidl_message_header_t));
    

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage TwoWayVectorBasic(::fidl::MessageEncoder* _encoder, ::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<::fidl::StringPtr>* vector_opt_string) {
    _encoder->Alloc(192);
    ::fidl::Encode(_encoder, vector_uint8, 0 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_uint16, 16 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_uint32, 32 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_uint64, 48 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_int8, 64 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_int16, 80 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_int32, 96 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_int64, 112 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_float32, 128 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_float64, 144 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_string, 160 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_opt_string, 176 + sizeof(fidl_message_header_t));
    

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage ErrorVectorBasic(::fidl::MessageEncoder* _encoder) {

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage OneWayVectorCompound(::fidl::MessageEncoder* _encoder, ::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<::std::unique_ptr<::test::typesinprotocols::Struct>>* vector_opt_struct, ::std::vector<::std::unique_ptr<::test::typesinprotocols::Union>>* vector_opt_union) {
    _encoder->Alloc(112);
    ::fidl::Encode(_encoder, vector_bits, 0 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_enum, 16 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_struct, 32 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_table, 48 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_union, 64 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_opt_struct, 80 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_opt_union, 96 + sizeof(fidl_message_header_t));
    

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage TwoWayVectorCompound(::fidl::MessageEncoder* _encoder, ::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<::std::unique_ptr<::test::typesinprotocols::Struct>>* vector_opt_struct, ::std::vector<::std::unique_ptr<::test::typesinprotocols::Union>>* vector_opt_union) {
    _encoder->Alloc(112);
    ::fidl::Encode(_encoder, vector_bits, 0 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_enum, 16 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_struct, 32 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_table, 48 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_union, 64 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_opt_struct, 80 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_opt_union, 96 + sizeof(fidl_message_header_t));
    

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage ErrorVectorCompound(::fidl::MessageEncoder* _encoder) {

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage OneWayVectorOptional(::fidl::MessageEncoder* _encoder, ::fidl::VectorPtr<uint8_t>* opt_vector_uint8, ::fidl::VectorPtr<::std::string>* opt_vector_string, ::fidl::VectorPtr<::std::unique_ptr<::test::typesinprotocols::Struct>>* opt_vector_opt_struct) {
    _encoder->Alloc(64);
    ::fidl::Encode(_encoder, opt_vector_uint8, 0 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, opt_vector_string, 16 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, opt_vector_opt_struct, 48 + sizeof(fidl_message_header_t));
    

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage TwoWayVectorOptional(::fidl::MessageEncoder* _encoder, ::fidl::VectorPtr<uint8_t>* opt_vector_uint8, ::fidl::VectorPtr<::std::string>* opt_vector_string, ::fidl::VectorPtr<::std::unique_ptr<::test::typesinprotocols::Struct>>* opt_vector_opt_struct) {
    _encoder->Alloc(64);
    ::fidl::Encode(_encoder, opt_vector_uint8, 0 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, opt_vector_string, 16 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, opt_vector_opt_struct, 48 + sizeof(fidl_message_header_t));
    

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage ErrorVectorOptional(::fidl::MessageEncoder* _encoder) {

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage OneWayArrayVectorNested(::fidl::MessageEncoder* _encoder, ::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) {
    _encoder->Alloc(144);
    ::fidl::Encode(_encoder, array_array_uint8, 0 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_vector_uint8, 32 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_array_uint8, 112 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_vector_uint8, 128 + sizeof(fidl_message_header_t));
    

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage TwoWayArrayVectorNested(::fidl::MessageEncoder* _encoder, ::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) {
    _encoder->Alloc(144);
    ::fidl::Encode(_encoder, array_array_uint8, 0 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_vector_uint8, 32 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_array_uint8, 112 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_vector_uint8, 128 + sizeof(fidl_message_header_t));
    

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage ErrorArrayVectorNested(::fidl::MessageEncoder* _encoder) {

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage OneWayResource(::fidl::MessageEncoder* _encoder, ::zx::handle* handle, ::zx::vmo* vmo, ::fidl::InterfaceHandle<::test::typesinprotocols::Protocol>* client_end, ::fidl::InterfaceRequest<::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::InterfaceHandle<::test::typesinprotocols::Protocol>* opt_client_end, ::fidl::InterfaceRequest<::test::typesinprotocols::Protocol>* opt_server_end, ::std::unique_ptr<::test::typesinprotocols::ResourceStruct>* opt_struct, ::std::unique_ptr<::test::typesinprotocols::ResourceUnion>* opt_union, ::std::array<::zx::handle, 5>* array_handle, ::std::array<::zx::vmo, 5>* array_vmo, ::std::array<::fidl::InterfaceHandle<::test::typesinprotocols::Protocol>, 5>* array_client_end, ::std::array<::fidl::InterfaceRequest<::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::InterfaceHandle<::test::typesinprotocols::Protocol>>* vector_client_end, ::std::vector<::fidl::InterfaceRequest<::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) {
    _encoder->Alloc(456);
    ::fidl::Encode(_encoder, handle, 0 + sizeof(fidl_message_header_t), ::fidl::HandleInformation {
      .object_type = ZX_OBJ_TYPE_NONE,
      .rights = 0x80000000,
    });
    
    ::fidl::Encode(_encoder, vmo, 4 + sizeof(fidl_message_header_t), ::fidl::HandleInformation {
      .object_type = ZX_OBJ_TYPE_VMO,
      .rights = 0x80000000,
    });
    
    ::fidl::Encode(_encoder, client_end, 8 + sizeof(fidl_message_header_t), ::fidl::HandleInformation {
      .object_type = ZX_OBJ_TYPE_CHANNEL,
      .rights = ZX_DEFAULT_CHANNEL_RIGHTS,
    });
    
    ::fidl::Encode(_encoder, server_end, 12 + sizeof(fidl_message_header_t), ::fidl::HandleInformation {
      .object_type = ZX_OBJ_TYPE_CHANNEL,
      .rights = ZX_DEFAULT_CHANNEL_RIGHTS,
    });
    
    ::fidl::Encode(_encoder, struct_, 16 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, table, 24 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, union_, 40 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, opt_handle, 56 + sizeof(fidl_message_header_t), ::fidl::HandleInformation {
      .object_type = ZX_OBJ_TYPE_NONE,
      .rights = 0x80000000,
    });
    
    ::fidl::Encode(_encoder, opt_vmo, 60 + sizeof(fidl_message_header_t), ::fidl::HandleInformation {
      .object_type = ZX_OBJ_TYPE_VMO,
      .rights = 0x80000000,
    });
    
    ::fidl::Encode(_encoder, opt_client_end, 64 + sizeof(fidl_message_header_t), ::fidl::HandleInformation {
      .object_type = ZX_OBJ_TYPE_CHANNEL,
      .rights = ZX_DEFAULT_CHANNEL_RIGHTS,
    });
    
    ::fidl::Encode(_encoder, opt_server_end, 68 + sizeof(fidl_message_header_t), ::fidl::HandleInformation {
      .object_type = ZX_OBJ_TYPE_CHANNEL,
      .rights = ZX_DEFAULT_CHANNEL_RIGHTS,
    });
    
    ::fidl::Encode(_encoder, opt_struct, 72 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, opt_union, 80 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_handle, 96 + sizeof(fidl_message_header_t), ::fidl::HandleInformation {
      .object_type = ZX_OBJ_TYPE_NONE,
      .rights = 0x80000000,
    });
    
    ::fidl::Encode(_encoder, array_vmo, 116 + sizeof(fidl_message_header_t), ::fidl::HandleInformation {
      .object_type = ZX_OBJ_TYPE_VMO,
      .rights = 0x80000000,
    });
    
    ::fidl::Encode(_encoder, array_client_end, 136 + sizeof(fidl_message_header_t), ::fidl::HandleInformation {
      .object_type = ZX_OBJ_TYPE_CHANNEL,
      .rights = ZX_DEFAULT_CHANNEL_RIGHTS,
    });
    
    ::fidl::Encode(_encoder, array_server_end, 156 + sizeof(fidl_message_header_t), ::fidl::HandleInformation {
      .object_type = ZX_OBJ_TYPE_CHANNEL,
      .rights = ZX_DEFAULT_CHANNEL_RIGHTS,
    });
    
    ::fidl::Encode(_encoder, array_struct, 176 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_table, 184 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_union, 264 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_handle, 344 + sizeof(fidl_message_header_t), ::fidl::HandleInformation {
      .object_type = ZX_OBJ_TYPE_NONE,
      .rights = 0x80000000,
    });
    
    ::fidl::Encode(_encoder, vector_vmo, 360 + sizeof(fidl_message_header_t), ::fidl::HandleInformation {
      .object_type = ZX_OBJ_TYPE_VMO,
      .rights = 0x80000000,
    });
    
    ::fidl::Encode(_encoder, vector_client_end, 376 + sizeof(fidl_message_header_t), ::fidl::HandleInformation {
      .object_type = ZX_OBJ_TYPE_CHANNEL,
      .rights = ZX_DEFAULT_CHANNEL_RIGHTS,
    });
    
    ::fidl::Encode(_encoder, vector_server_end, 392 + sizeof(fidl_message_header_t), ::fidl::HandleInformation {
      .object_type = ZX_OBJ_TYPE_CHANNEL,
      .rights = ZX_DEFAULT_CHANNEL_RIGHTS,
    });
    
    ::fidl::Encode(_encoder, vector_struct, 408 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_table, 424 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_union, 440 + sizeof(fidl_message_header_t));
    

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage TwoWayResource(::fidl::MessageEncoder* _encoder, ::zx::handle* handle, ::zx::vmo* vmo, ::fidl::InterfaceHandle<::test::typesinprotocols::Protocol>* client_end, ::fidl::InterfaceRequest<::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::InterfaceHandle<::test::typesinprotocols::Protocol>* opt_client_end, ::fidl::InterfaceRequest<::test::typesinprotocols::Protocol>* opt_server_end, ::std::unique_ptr<::test::typesinprotocols::ResourceStruct>* opt_struct, ::std::unique_ptr<::test::typesinprotocols::ResourceUnion>* opt_union, ::std::array<::zx::handle, 5>* array_handle, ::std::array<::zx::vmo, 5>* array_vmo, ::std::array<::fidl::InterfaceHandle<::test::typesinprotocols::Protocol>, 5>* array_client_end, ::std::array<::fidl::InterfaceRequest<::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::InterfaceHandle<::test::typesinprotocols::Protocol>>* vector_client_end, ::std::vector<::fidl::InterfaceRequest<::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) {
    _encoder->Alloc(456);
    ::fidl::Encode(_encoder, handle, 0 + sizeof(fidl_message_header_t), ::fidl::HandleInformation {
      .object_type = ZX_OBJ_TYPE_NONE,
      .rights = 0x80000000,
    });
    
    ::fidl::Encode(_encoder, vmo, 4 + sizeof(fidl_message_header_t), ::fidl::HandleInformation {
      .object_type = ZX_OBJ_TYPE_VMO,
      .rights = 0x80000000,
    });
    
    ::fidl::Encode(_encoder, client_end, 8 + sizeof(fidl_message_header_t), ::fidl::HandleInformation {
      .object_type = ZX_OBJ_TYPE_CHANNEL,
      .rights = ZX_DEFAULT_CHANNEL_RIGHTS,
    });
    
    ::fidl::Encode(_encoder, server_end, 12 + sizeof(fidl_message_header_t), ::fidl::HandleInformation {
      .object_type = ZX_OBJ_TYPE_CHANNEL,
      .rights = ZX_DEFAULT_CHANNEL_RIGHTS,
    });
    
    ::fidl::Encode(_encoder, struct_, 16 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, table, 24 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, union_, 40 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, opt_handle, 56 + sizeof(fidl_message_header_t), ::fidl::HandleInformation {
      .object_type = ZX_OBJ_TYPE_NONE,
      .rights = 0x80000000,
    });
    
    ::fidl::Encode(_encoder, opt_vmo, 60 + sizeof(fidl_message_header_t), ::fidl::HandleInformation {
      .object_type = ZX_OBJ_TYPE_VMO,
      .rights = 0x80000000,
    });
    
    ::fidl::Encode(_encoder, opt_client_end, 64 + sizeof(fidl_message_header_t), ::fidl::HandleInformation {
      .object_type = ZX_OBJ_TYPE_CHANNEL,
      .rights = ZX_DEFAULT_CHANNEL_RIGHTS,
    });
    
    ::fidl::Encode(_encoder, opt_server_end, 68 + sizeof(fidl_message_header_t), ::fidl::HandleInformation {
      .object_type = ZX_OBJ_TYPE_CHANNEL,
      .rights = ZX_DEFAULT_CHANNEL_RIGHTS,
    });
    
    ::fidl::Encode(_encoder, opt_struct, 72 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, opt_union, 80 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_handle, 96 + sizeof(fidl_message_header_t), ::fidl::HandleInformation {
      .object_type = ZX_OBJ_TYPE_NONE,
      .rights = 0x80000000,
    });
    
    ::fidl::Encode(_encoder, array_vmo, 116 + sizeof(fidl_message_header_t), ::fidl::HandleInformation {
      .object_type = ZX_OBJ_TYPE_VMO,
      .rights = 0x80000000,
    });
    
    ::fidl::Encode(_encoder, array_client_end, 136 + sizeof(fidl_message_header_t), ::fidl::HandleInformation {
      .object_type = ZX_OBJ_TYPE_CHANNEL,
      .rights = ZX_DEFAULT_CHANNEL_RIGHTS,
    });
    
    ::fidl::Encode(_encoder, array_server_end, 156 + sizeof(fidl_message_header_t), ::fidl::HandleInformation {
      .object_type = ZX_OBJ_TYPE_CHANNEL,
      .rights = ZX_DEFAULT_CHANNEL_RIGHTS,
    });
    
    ::fidl::Encode(_encoder, array_struct, 176 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_table, 184 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_union, 264 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_handle, 344 + sizeof(fidl_message_header_t), ::fidl::HandleInformation {
      .object_type = ZX_OBJ_TYPE_NONE,
      .rights = 0x80000000,
    });
    
    ::fidl::Encode(_encoder, vector_vmo, 360 + sizeof(fidl_message_header_t), ::fidl::HandleInformation {
      .object_type = ZX_OBJ_TYPE_VMO,
      .rights = 0x80000000,
    });
    
    ::fidl::Encode(_encoder, vector_client_end, 376 + sizeof(fidl_message_header_t), ::fidl::HandleInformation {
      .object_type = ZX_OBJ_TYPE_CHANNEL,
      .rights = ZX_DEFAULT_CHANNEL_RIGHTS,
    });
    
    ::fidl::Encode(_encoder, vector_server_end, 392 + sizeof(fidl_message_header_t), ::fidl::HandleInformation {
      .object_type = ZX_OBJ_TYPE_CHANNEL,
      .rights = ZX_DEFAULT_CHANNEL_RIGHTS,
    });
    
    ::fidl::Encode(_encoder, vector_struct, 408 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_table, 424 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_union, 440 + sizeof(fidl_message_header_t));
    

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage ErrorResource(::fidl::MessageEncoder* _encoder) {

    return _encoder->GetMessage();
  }
};
  
  
  namespace _internal {
__LOCAL extern "C" const fidl_type_t test_typesinprotocols_Protocol_ErrorBasic_ResultTable;
  
  
__LOCAL extern "C" const fidl_type_t test_typesinprotocols_Protocol_ErrorCompound_ResultTable;
  
  
__LOCAL extern "C" const fidl_type_t test_typesinprotocols_Protocol_ErrorArrayBasic_ResultTable;
  
  
__LOCAL extern "C" const fidl_type_t test_typesinprotocols_Protocol_ErrorArrayCompound_ResultTable;
  
  
__LOCAL extern "C" const fidl_type_t test_typesinprotocols_Protocol_ErrorVectorBasic_ResultTable;
  
  
__LOCAL extern "C" const fidl_type_t test_typesinprotocols_Protocol_ErrorVectorCompound_ResultTable;
  
  
__LOCAL extern "C" const fidl_type_t test_typesinprotocols_Protocol_ErrorVectorOptional_ResultTable;
  
  
__LOCAL extern "C" const fidl_type_t test_typesinprotocols_Protocol_ErrorArrayVectorNested_ResultTable;
  
  
__LOCAL extern "C" const fidl_type_t test_typesinprotocols_Protocol_ErrorResource_ResultTable;
  

}  // namespace _internal

class Protocol_ResponseEncoder {
 public:
  static ::fidl::HLCPPOutgoingMessage TwoWayBasic(::fidl::MessageEncoder* _encoder, 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, ::fidl::StringPtr* opt_string) {
    _encoder->Alloc(80);
    ::fidl::Encode(_encoder, uint8, 0 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, uint16, 2 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, uint32, 4 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, uint64, 8 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, int8, 16 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, int16, 18 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, int32, 20 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, int64, 24 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, float32, 32 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, float64, 40 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, string, 48 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, opt_string, 64 + sizeof(fidl_message_header_t));
    

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage ErrorBasic(::fidl::MessageEncoder* _encoder, ::test::typesinprotocols::Protocol_ErrorBasic_Result* Protocol_ErrorBasic_Result) {
    _encoder->Alloc(16);
    ::fidl::Encode(_encoder, Protocol_ErrorBasic_Result, 0 + sizeof(fidl_message_header_t));
    

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage EventBasic(::fidl::MessageEncoder* _encoder, 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, ::fidl::StringPtr* opt_string) {
    _encoder->Alloc(80);
    ::fidl::Encode(_encoder, uint8, 0 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, uint16, 2 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, uint32, 4 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, uint64, 8 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, int8, 16 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, int16, 18 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, int32, 20 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, int64, 24 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, float32, 32 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, float64, 40 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, string, 48 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, opt_string, 64 + sizeof(fidl_message_header_t));
    

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage TwoWayCompound(::fidl::MessageEncoder* _encoder, ::test::typesinprotocols::Bits* bits, ::test::typesinprotocols::Enum* enum_, ::test::typesinprotocols::Struct* struct_, ::test::typesinprotocols::Table* table, ::test::typesinprotocols::Union* union_, ::std::unique_ptr<::test::typesinprotocols::Struct>* opt_struct, ::std::unique_ptr<::test::typesinprotocols::Union>* opt_union) {
    _encoder->Alloc(72);
    ::fidl::Encode(_encoder, bits, 0 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, enum_, 4 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, struct_, 8 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, table, 16 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, union_, 32 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, opt_struct, 48 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, opt_union, 56 + sizeof(fidl_message_header_t));
    

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage ErrorCompound(::fidl::MessageEncoder* _encoder, ::test::typesinprotocols::Protocol_ErrorCompound_Result* Protocol_ErrorCompound_Result) {
    _encoder->Alloc(16);
    ::fidl::Encode(_encoder, Protocol_ErrorCompound_Result, 0 + sizeof(fidl_message_header_t));
    

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage EventCompound(::fidl::MessageEncoder* _encoder, ::test::typesinprotocols::Bits* bits, ::test::typesinprotocols::Enum* enum_, ::test::typesinprotocols::Struct* struct_, ::test::typesinprotocols::Table* table, ::test::typesinprotocols::Union* union_, ::std::unique_ptr<::test::typesinprotocols::Struct>* opt_struct, ::std::unique_ptr<::test::typesinprotocols::Union>* opt_union) {
    _encoder->Alloc(72);
    ::fidl::Encode(_encoder, bits, 0 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, enum_, 4 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, struct_, 8 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, table, 16 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, union_, 32 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, opt_struct, 48 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, opt_union, 56 + sizeof(fidl_message_header_t));
    

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage TwoWayArrayBasic(::fidl::MessageEncoder* _encoder, ::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<::fidl::StringPtr, 5>* array_opt_string) {
    _encoder->Alloc(384);
    ::fidl::Encode(_encoder, array_uint8, 0 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_uint16, 6 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_uint32, 16 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_uint64, 40 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_int8, 80 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_int16, 86 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_int32, 96 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_int64, 120 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_float32, 160 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_float64, 184 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_string, 224 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_opt_string, 304 + sizeof(fidl_message_header_t));
    

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage ErrorArrayBasic(::fidl::MessageEncoder* _encoder, ::test::typesinprotocols::Protocol_ErrorArrayBasic_Result* Protocol_ErrorArrayBasic_Result) {
    _encoder->Alloc(16);
    ::fidl::Encode(_encoder, Protocol_ErrorArrayBasic_Result, 0 + sizeof(fidl_message_header_t));
    

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage EventArrayBasic(::fidl::MessageEncoder* _encoder, ::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<::fidl::StringPtr, 5>* array_opt_string) {
    _encoder->Alloc(384);
    ::fidl::Encode(_encoder, array_uint8, 0 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_uint16, 6 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_uint32, 16 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_uint64, 40 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_int8, 80 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_int16, 86 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_int32, 96 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_int64, 120 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_float32, 160 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_float64, 184 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_string, 224 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_opt_string, 304 + sizeof(fidl_message_header_t));
    

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage TwoWayArrayCompound(::fidl::MessageEncoder* _encoder, ::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<::std::unique_ptr<::test::typesinprotocols::Struct>, 5>* array_opt_struct, ::std::array<::std::unique_ptr<::test::typesinprotocols::Union>, 5>* array_opt_union) {
    _encoder->Alloc(328);
    ::fidl::Encode(_encoder, array_bits, 0 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_enum, 20 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_struct, 40 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_table, 48 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_union, 128 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_opt_struct, 208 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_opt_union, 248 + sizeof(fidl_message_header_t));
    

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage ErrorArrayCompound(::fidl::MessageEncoder* _encoder, ::test::typesinprotocols::Protocol_ErrorArrayCompound_Result* Protocol_ErrorArrayCompound_Result) {
    _encoder->Alloc(16);
    ::fidl::Encode(_encoder, Protocol_ErrorArrayCompound_Result, 0 + sizeof(fidl_message_header_t));
    

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage EventArrayCompound(::fidl::MessageEncoder* _encoder, ::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<::std::unique_ptr<::test::typesinprotocols::Struct>, 5>* array_opt_struct, ::std::array<::std::unique_ptr<::test::typesinprotocols::Union>, 5>* array_opt_union) {
    _encoder->Alloc(328);
    ::fidl::Encode(_encoder, array_bits, 0 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_enum, 20 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_struct, 40 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_table, 48 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_union, 128 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_opt_struct, 208 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_opt_union, 248 + sizeof(fidl_message_header_t));
    

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage TwoWayVectorBasic(::fidl::MessageEncoder* _encoder, ::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<::fidl::StringPtr>* vector_opt_string) {
    _encoder->Alloc(192);
    ::fidl::Encode(_encoder, vector_uint8, 0 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_uint16, 16 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_uint32, 32 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_uint64, 48 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_int8, 64 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_int16, 80 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_int32, 96 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_int64, 112 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_float32, 128 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_float64, 144 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_string, 160 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_opt_string, 176 + sizeof(fidl_message_header_t));
    

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage ErrorVectorBasic(::fidl::MessageEncoder* _encoder, ::test::typesinprotocols::Protocol_ErrorVectorBasic_Result* Protocol_ErrorVectorBasic_Result) {
    _encoder->Alloc(16);
    ::fidl::Encode(_encoder, Protocol_ErrorVectorBasic_Result, 0 + sizeof(fidl_message_header_t));
    

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage EventVectorBasic(::fidl::MessageEncoder* _encoder, ::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<::fidl::StringPtr>* vector_opt_string) {
    _encoder->Alloc(192);
    ::fidl::Encode(_encoder, vector_uint8, 0 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_uint16, 16 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_uint32, 32 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_uint64, 48 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_int8, 64 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_int16, 80 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_int32, 96 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_int64, 112 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_float32, 128 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_float64, 144 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_string, 160 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_opt_string, 176 + sizeof(fidl_message_header_t));
    

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage TwoWayVectorCompound(::fidl::MessageEncoder* _encoder, ::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<::std::unique_ptr<::test::typesinprotocols::Struct>>* vector_opt_struct, ::std::vector<::std::unique_ptr<::test::typesinprotocols::Union>>* vector_opt_union) {
    _encoder->Alloc(112);
    ::fidl::Encode(_encoder, vector_bits, 0 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_enum, 16 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_struct, 32 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_table, 48 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_union, 64 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_opt_struct, 80 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_opt_union, 96 + sizeof(fidl_message_header_t));
    

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage ErrorVectorCompound(::fidl::MessageEncoder* _encoder, ::test::typesinprotocols::Protocol_ErrorVectorCompound_Result* Protocol_ErrorVectorCompound_Result) {
    _encoder->Alloc(16);
    ::fidl::Encode(_encoder, Protocol_ErrorVectorCompound_Result, 0 + sizeof(fidl_message_header_t));
    

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage EventVectorCompound(::fidl::MessageEncoder* _encoder, ::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<::std::unique_ptr<::test::typesinprotocols::Struct>>* vector_opt_struct, ::std::vector<::std::unique_ptr<::test::typesinprotocols::Union>>* vector_opt_union) {
    _encoder->Alloc(112);
    ::fidl::Encode(_encoder, vector_bits, 0 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_enum, 16 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_struct, 32 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_table, 48 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_union, 64 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_opt_struct, 80 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_opt_union, 96 + sizeof(fidl_message_header_t));
    

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage TwoWayVectorOptional(::fidl::MessageEncoder* _encoder, ::fidl::VectorPtr<uint8_t>* opt_vector_uint8, ::fidl::VectorPtr<::std::string>* opt_vector_string, ::fidl::VectorPtr<::std::unique_ptr<::test::typesinprotocols::Struct>>* opt_vector_opt_struct) {
    _encoder->Alloc(64);
    ::fidl::Encode(_encoder, opt_vector_uint8, 0 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, opt_vector_string, 16 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, opt_vector_opt_struct, 48 + sizeof(fidl_message_header_t));
    

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage ErrorVectorOptional(::fidl::MessageEncoder* _encoder, ::test::typesinprotocols::Protocol_ErrorVectorOptional_Result* Protocol_ErrorVectorOptional_Result) {
    _encoder->Alloc(16);
    ::fidl::Encode(_encoder, Protocol_ErrorVectorOptional_Result, 0 + sizeof(fidl_message_header_t));
    

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage EventVectorOptional(::fidl::MessageEncoder* _encoder, ::fidl::VectorPtr<uint8_t>* opt_vector_uint8, ::fidl::VectorPtr<::std::string>* opt_vector_string, ::fidl::VectorPtr<::std::unique_ptr<::test::typesinprotocols::Struct>>* opt_vector_opt_struct) {
    _encoder->Alloc(64);
    ::fidl::Encode(_encoder, opt_vector_uint8, 0 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, opt_vector_string, 16 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, opt_vector_opt_struct, 48 + sizeof(fidl_message_header_t));
    

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage TwoWayArrayVectorNested(::fidl::MessageEncoder* _encoder, ::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) {
    _encoder->Alloc(144);
    ::fidl::Encode(_encoder, array_array_uint8, 0 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_vector_uint8, 32 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_array_uint8, 112 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_vector_uint8, 128 + sizeof(fidl_message_header_t));
    

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage ErrorArrayVectorNested(::fidl::MessageEncoder* _encoder, ::test::typesinprotocols::Protocol_ErrorArrayVectorNested_Result* Protocol_ErrorArrayVectorNested_Result) {
    _encoder->Alloc(16);
    ::fidl::Encode(_encoder, Protocol_ErrorArrayVectorNested_Result, 0 + sizeof(fidl_message_header_t));
    

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage EventArrayVectorNested(::fidl::MessageEncoder* _encoder, ::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) {
    _encoder->Alloc(144);
    ::fidl::Encode(_encoder, array_array_uint8, 0 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_vector_uint8, 32 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_array_uint8, 112 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_vector_uint8, 128 + sizeof(fidl_message_header_t));
    

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage TwoWayResource(::fidl::MessageEncoder* _encoder, ::zx::handle* handle, ::zx::vmo* vmo, ::fidl::InterfaceHandle<::test::typesinprotocols::Protocol>* client_end, ::fidl::InterfaceRequest<::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::InterfaceHandle<::test::typesinprotocols::Protocol>* opt_client_end, ::fidl::InterfaceRequest<::test::typesinprotocols::Protocol>* opt_server_end, ::std::unique_ptr<::test::typesinprotocols::ResourceStruct>* opt_struct, ::std::unique_ptr<::test::typesinprotocols::ResourceUnion>* opt_union, ::std::array<::zx::handle, 5>* array_handle, ::std::array<::zx::vmo, 5>* array_vmo, ::std::array<::fidl::InterfaceHandle<::test::typesinprotocols::Protocol>, 5>* array_client_end, ::std::array<::fidl::InterfaceRequest<::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::InterfaceHandle<::test::typesinprotocols::Protocol>>* vector_client_end, ::std::vector<::fidl::InterfaceRequest<::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) {
    _encoder->Alloc(456);
    ::fidl::Encode(_encoder, handle, 0 + sizeof(fidl_message_header_t), ::fidl::HandleInformation {
      .object_type = ZX_OBJ_TYPE_NONE,
      .rights = 0x80000000,
    });
    
    ::fidl::Encode(_encoder, vmo, 4 + sizeof(fidl_message_header_t), ::fidl::HandleInformation {
      .object_type = ZX_OBJ_TYPE_VMO,
      .rights = 0x80000000,
    });
    
    ::fidl::Encode(_encoder, client_end, 8 + sizeof(fidl_message_header_t), ::fidl::HandleInformation {
      .object_type = ZX_OBJ_TYPE_CHANNEL,
      .rights = ZX_DEFAULT_CHANNEL_RIGHTS,
    });
    
    ::fidl::Encode(_encoder, server_end, 12 + sizeof(fidl_message_header_t), ::fidl::HandleInformation {
      .object_type = ZX_OBJ_TYPE_CHANNEL,
      .rights = ZX_DEFAULT_CHANNEL_RIGHTS,
    });
    
    ::fidl::Encode(_encoder, struct_, 16 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, table, 24 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, union_, 40 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, opt_handle, 56 + sizeof(fidl_message_header_t), ::fidl::HandleInformation {
      .object_type = ZX_OBJ_TYPE_NONE,
      .rights = 0x80000000,
    });
    
    ::fidl::Encode(_encoder, opt_vmo, 60 + sizeof(fidl_message_header_t), ::fidl::HandleInformation {
      .object_type = ZX_OBJ_TYPE_VMO,
      .rights = 0x80000000,
    });
    
    ::fidl::Encode(_encoder, opt_client_end, 64 + sizeof(fidl_message_header_t), ::fidl::HandleInformation {
      .object_type = ZX_OBJ_TYPE_CHANNEL,
      .rights = ZX_DEFAULT_CHANNEL_RIGHTS,
    });
    
    ::fidl::Encode(_encoder, opt_server_end, 68 + sizeof(fidl_message_header_t), ::fidl::HandleInformation {
      .object_type = ZX_OBJ_TYPE_CHANNEL,
      .rights = ZX_DEFAULT_CHANNEL_RIGHTS,
    });
    
    ::fidl::Encode(_encoder, opt_struct, 72 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, opt_union, 80 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_handle, 96 + sizeof(fidl_message_header_t), ::fidl::HandleInformation {
      .object_type = ZX_OBJ_TYPE_NONE,
      .rights = 0x80000000,
    });
    
    ::fidl::Encode(_encoder, array_vmo, 116 + sizeof(fidl_message_header_t), ::fidl::HandleInformation {
      .object_type = ZX_OBJ_TYPE_VMO,
      .rights = 0x80000000,
    });
    
    ::fidl::Encode(_encoder, array_client_end, 136 + sizeof(fidl_message_header_t), ::fidl::HandleInformation {
      .object_type = ZX_OBJ_TYPE_CHANNEL,
      .rights = ZX_DEFAULT_CHANNEL_RIGHTS,
    });
    
    ::fidl::Encode(_encoder, array_server_end, 156 + sizeof(fidl_message_header_t), ::fidl::HandleInformation {
      .object_type = ZX_OBJ_TYPE_CHANNEL,
      .rights = ZX_DEFAULT_CHANNEL_RIGHTS,
    });
    
    ::fidl::Encode(_encoder, array_struct, 176 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_table, 184 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_union, 264 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_handle, 344 + sizeof(fidl_message_header_t), ::fidl::HandleInformation {
      .object_type = ZX_OBJ_TYPE_NONE,
      .rights = 0x80000000,
    });
    
    ::fidl::Encode(_encoder, vector_vmo, 360 + sizeof(fidl_message_header_t), ::fidl::HandleInformation {
      .object_type = ZX_OBJ_TYPE_VMO,
      .rights = 0x80000000,
    });
    
    ::fidl::Encode(_encoder, vector_client_end, 376 + sizeof(fidl_message_header_t), ::fidl::HandleInformation {
      .object_type = ZX_OBJ_TYPE_CHANNEL,
      .rights = ZX_DEFAULT_CHANNEL_RIGHTS,
    });
    
    ::fidl::Encode(_encoder, vector_server_end, 392 + sizeof(fidl_message_header_t), ::fidl::HandleInformation {
      .object_type = ZX_OBJ_TYPE_CHANNEL,
      .rights = ZX_DEFAULT_CHANNEL_RIGHTS,
    });
    
    ::fidl::Encode(_encoder, vector_struct, 408 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_table, 424 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_union, 440 + sizeof(fidl_message_header_t));
    

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage ErrorResource(::fidl::MessageEncoder* _encoder, ::test::typesinprotocols::Protocol_ErrorResource_Result* Protocol_ErrorResource_Result) {
    _encoder->Alloc(16);
    ::fidl::Encode(_encoder, Protocol_ErrorResource_Result, 0 + sizeof(fidl_message_header_t));
    

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage EventResource(::fidl::MessageEncoder* _encoder, ::zx::handle* handle, ::zx::vmo* vmo, ::fidl::InterfaceHandle<::test::typesinprotocols::Protocol>* client_end, ::fidl::InterfaceRequest<::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::InterfaceHandle<::test::typesinprotocols::Protocol>* opt_client_end, ::fidl::InterfaceRequest<::test::typesinprotocols::Protocol>* opt_server_end, ::std::unique_ptr<::test::typesinprotocols::ResourceStruct>* opt_struct, ::std::unique_ptr<::test::typesinprotocols::ResourceUnion>* opt_union, ::std::array<::zx::handle, 5>* array_handle, ::std::array<::zx::vmo, 5>* array_vmo, ::std::array<::fidl::InterfaceHandle<::test::typesinprotocols::Protocol>, 5>* array_client_end, ::std::array<::fidl::InterfaceRequest<::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::InterfaceHandle<::test::typesinprotocols::Protocol>>* vector_client_end, ::std::vector<::fidl::InterfaceRequest<::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) {
    _encoder->Alloc(456);
    ::fidl::Encode(_encoder, handle, 0 + sizeof(fidl_message_header_t), ::fidl::HandleInformation {
      .object_type = ZX_OBJ_TYPE_NONE,
      .rights = 0x80000000,
    });
    
    ::fidl::Encode(_encoder, vmo, 4 + sizeof(fidl_message_header_t), ::fidl::HandleInformation {
      .object_type = ZX_OBJ_TYPE_VMO,
      .rights = 0x80000000,
    });
    
    ::fidl::Encode(_encoder, client_end, 8 + sizeof(fidl_message_header_t), ::fidl::HandleInformation {
      .object_type = ZX_OBJ_TYPE_CHANNEL,
      .rights = ZX_DEFAULT_CHANNEL_RIGHTS,
    });
    
    ::fidl::Encode(_encoder, server_end, 12 + sizeof(fidl_message_header_t), ::fidl::HandleInformation {
      .object_type = ZX_OBJ_TYPE_CHANNEL,
      .rights = ZX_DEFAULT_CHANNEL_RIGHTS,
    });
    
    ::fidl::Encode(_encoder, struct_, 16 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, table, 24 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, union_, 40 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, opt_handle, 56 + sizeof(fidl_message_header_t), ::fidl::HandleInformation {
      .object_type = ZX_OBJ_TYPE_NONE,
      .rights = 0x80000000,
    });
    
    ::fidl::Encode(_encoder, opt_vmo, 60 + sizeof(fidl_message_header_t), ::fidl::HandleInformation {
      .object_type = ZX_OBJ_TYPE_VMO,
      .rights = 0x80000000,
    });
    
    ::fidl::Encode(_encoder, opt_client_end, 64 + sizeof(fidl_message_header_t), ::fidl::HandleInformation {
      .object_type = ZX_OBJ_TYPE_CHANNEL,
      .rights = ZX_DEFAULT_CHANNEL_RIGHTS,
    });
    
    ::fidl::Encode(_encoder, opt_server_end, 68 + sizeof(fidl_message_header_t), ::fidl::HandleInformation {
      .object_type = ZX_OBJ_TYPE_CHANNEL,
      .rights = ZX_DEFAULT_CHANNEL_RIGHTS,
    });
    
    ::fidl::Encode(_encoder, opt_struct, 72 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, opt_union, 80 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_handle, 96 + sizeof(fidl_message_header_t), ::fidl::HandleInformation {
      .object_type = ZX_OBJ_TYPE_NONE,
      .rights = 0x80000000,
    });
    
    ::fidl::Encode(_encoder, array_vmo, 116 + sizeof(fidl_message_header_t), ::fidl::HandleInformation {
      .object_type = ZX_OBJ_TYPE_VMO,
      .rights = 0x80000000,
    });
    
    ::fidl::Encode(_encoder, array_client_end, 136 + sizeof(fidl_message_header_t), ::fidl::HandleInformation {
      .object_type = ZX_OBJ_TYPE_CHANNEL,
      .rights = ZX_DEFAULT_CHANNEL_RIGHTS,
    });
    
    ::fidl::Encode(_encoder, array_server_end, 156 + sizeof(fidl_message_header_t), ::fidl::HandleInformation {
      .object_type = ZX_OBJ_TYPE_CHANNEL,
      .rights = ZX_DEFAULT_CHANNEL_RIGHTS,
    });
    
    ::fidl::Encode(_encoder, array_struct, 176 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_table, 184 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, array_union, 264 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_handle, 344 + sizeof(fidl_message_header_t), ::fidl::HandleInformation {
      .object_type = ZX_OBJ_TYPE_NONE,
      .rights = 0x80000000,
    });
    
    ::fidl::Encode(_encoder, vector_vmo, 360 + sizeof(fidl_message_header_t), ::fidl::HandleInformation {
      .object_type = ZX_OBJ_TYPE_VMO,
      .rights = 0x80000000,
    });
    
    ::fidl::Encode(_encoder, vector_client_end, 376 + sizeof(fidl_message_header_t), ::fidl::HandleInformation {
      .object_type = ZX_OBJ_TYPE_CHANNEL,
      .rights = ZX_DEFAULT_CHANNEL_RIGHTS,
    });
    
    ::fidl::Encode(_encoder, vector_server_end, 392 + sizeof(fidl_message_header_t), ::fidl::HandleInformation {
      .object_type = ZX_OBJ_TYPE_CHANNEL,
      .rights = ZX_DEFAULT_CHANNEL_RIGHTS,
    });
    
    ::fidl::Encode(_encoder, vector_struct, 408 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_table, 424 + sizeof(fidl_message_header_t));
    
    ::fidl::Encode(_encoder, vector_union, 440 + sizeof(fidl_message_header_t));
    

    return _encoder->GetMessage();
  }
};

#endif  // __Fuchsia__


}  // namespace typesinprotocols
}  // namespace test
namespace fidl {

template <>
struct CodingTraits<::test::typesinprotocols::Bits> {
  static constexpr size_t kInlineSize = sizeof(::test::typesinprotocols::Bits);
  static void Encode(Encoder* encoder, ::test::typesinprotocols::Bits* value, size_t offset,
                     cpp17::optional<::fidl::HandleInformation> maybe_handle_info) {
    ZX_DEBUG_ASSERT(!maybe_handle_info);
    uint32_t underlying = static_cast<uint32_t>(*value);
    ::fidl::Encode(encoder, &underlying, offset);
  }
  static void Decode(Decoder* decoder, ::test::typesinprotocols::Bits* value, size_t offset) {
    uint32_t underlying = {};
    ::fidl::Decode(decoder, &underlying, offset);
    *value = static_cast<::test::typesinprotocols::Bits>(underlying);
  }
};

inline zx_status_t Clone(::test::typesinprotocols::Bits value,
                         ::test::typesinprotocols::Bits* result) {
  return ::test::typesinprotocols::Clone(value, result);
}

template<>
struct Equality<::test::typesinprotocols::Bits> {
  bool operator()(const ::test::typesinprotocols::Bits& _lhs, const ::test::typesinprotocols::Bits& _rhs) const {
    uint32_t _lhs_underlying = static_cast<uint32_t>(_lhs);
    uint32_t _rhs_underlying = static_cast<uint32_t>(_rhs);
    return ::fidl::Equals(_lhs_underlying, _rhs_underlying);
  }
};
template <>
struct CodingTraits<::test::typesinprotocols::Enum> {
  static constexpr size_t kInlineSize = sizeof(::test::typesinprotocols::Enum);
  static void Encode(Encoder* encoder, ::test::typesinprotocols::Enum* value, size_t offset,
                     cpp17::optional<::fidl::HandleInformation> maybe_handle_info) {
    ZX_DEBUG_ASSERT(!maybe_handle_info);
    uint32_t underlying = static_cast<uint32_t>(*value);
    ::fidl::Encode(encoder, &underlying, offset);
  }
  static void Decode(Decoder* decoder, ::test::typesinprotocols::Enum* value, size_t offset) {
    uint32_t underlying = {};
    ::fidl::Decode(decoder, &underlying, offset);
    *value = static_cast<::test::typesinprotocols::Enum>(underlying);
  }
};

inline zx_status_t Clone(::test::typesinprotocols::Enum value,
                         ::test::typesinprotocols::Enum* result) {
  return ::test::typesinprotocols::Clone(value, result);
}
template<>
struct Equality<::test::typesinprotocols::Enum> {
  bool operator()(const ::test::typesinprotocols::Enum& _lhs, const ::test::typesinprotocols::Enum& _rhs) const {
    return _lhs == _rhs;
  }
};


template <>
struct CodingTraits<::test::typesinprotocols::Struct>
    : public EncodableCodingTraits<::test::typesinprotocols::Struct, 1> {};


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


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

template<>
struct Equality<::test::typesinprotocols::Struct> {
  bool operator()(const ::test::typesinprotocols::Struct& _lhs, const ::test::typesinprotocols::Struct& _rhs) const {
    if (!::fidl::Equals(_lhs.__reserved, _rhs.__reserved)) {
      return false;
    }
    return true;
  }
};
template <>
struct CodingTraits<::test::typesinprotocols::Table>
    : public EncodableCodingTraits<::test::typesinprotocols::Table, 16> {};

inline zx_status_t Clone(const ::test::typesinprotocols::Table& _value,
                         ::test::typesinprotocols::Table* result) {
  return _value.Clone(result);
}
template<>
struct Equality<::test::typesinprotocols::Table> {
  bool operator()(const ::test::typesinprotocols::Table& _lhs, const ::test::typesinprotocols::Table& _rhs) const {
    return true;
  }
};
template <>
struct IsFidlXUnion<::test::typesinprotocols::Union> : public std::true_type {};

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

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

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

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

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

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

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::typesinprotocols::Union::Tag::Invalid):
        return true;
      case ::test::typesinprotocols::Union::Tag::kB:
        return ::fidl::Equals(_lhs.b_, _rhs.b_);
      default:
        return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_);
      }
    }
};
#ifdef __Fuchsia__

template <>
struct CodingTraits<::test::typesinprotocols::ResourceStruct>
    : public EncodableCodingTraits<::test::typesinprotocols::ResourceStruct, 1> {};


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


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

template<>
struct Equality<::test::typesinprotocols::ResourceStruct> {
  bool operator()(const ::test::typesinprotocols::ResourceStruct& _lhs, const ::test::typesinprotocols::ResourceStruct& _rhs) const {
    if (!::fidl::Equals(_lhs.__reserved, _rhs.__reserved)) {
      return false;
    }
    return true;
  }
};

#endif  // __Fuchsia__

#ifdef __Fuchsia__

template <>
struct CodingTraits<::test::typesinprotocols::ResourceTable>
    : public EncodableCodingTraits<::test::typesinprotocols::ResourceTable, 16> {};

inline zx_status_t Clone(const ::test::typesinprotocols::ResourceTable& _value,
                         ::test::typesinprotocols::ResourceTable* result) {
  return _value.Clone(result);
}
template<>
struct Equality<::test::typesinprotocols::ResourceTable> {
  bool operator()(const ::test::typesinprotocols::ResourceTable& _lhs, const ::test::typesinprotocols::ResourceTable& _rhs) const {
    return true;
  }
};

#endif  // __Fuchsia__

#ifdef __Fuchsia__

template <>
struct IsFidlXUnion<::test::typesinprotocols::ResourceUnion> : public std::true_type {};

template <>
struct CodingTraits<::test::typesinprotocols::ResourceUnion>
    : public EncodableCodingTraits<::test::typesinprotocols::ResourceUnion, 16> {};

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

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

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

    value->reset(new ::test::typesinprotocols::ResourceUnion);

    ::test::typesinprotocols::ResourceUnion::Decode(_decoder, value->get(), offset);
  }
};

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

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

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

#endif  // __Fuchsia__

template <>
struct CodingTraits<::test::typesinprotocols::Basic>
    : public EncodableCodingTraits<::test::typesinprotocols::Basic, 80> {};


template<>
struct HasPadding<::test::typesinprotocols::Basic> : public std::true_type {};


template<>
struct IsMemcpyCompatible<::test::typesinprotocols::Basic> : public internal::BoolConstant<
    !HasPadding<::test::typesinprotocols::Basic>::value
    && IsMemcpyCompatible<uint8_t>::value
    && IsMemcpyCompatible<uint16_t>::value
    && IsMemcpyCompatible<uint32_t>::value
    && IsMemcpyCompatible<uint64_t>::value
    && IsMemcpyCompatible<int8_t>::value
    && IsMemcpyCompatible<int16_t>::value
    && IsMemcpyCompatible<int32_t>::value
    && IsMemcpyCompatible<int64_t>::value
    && IsMemcpyCompatible<float>::value
    && IsMemcpyCompatible<double>::value
    && IsMemcpyCompatible<::std::string>::value
    && IsMemcpyCompatible<::fidl::StringPtr>::value> {};


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

template<>
struct Equality<::test::typesinprotocols::Basic> {
  bool operator()(const ::test::typesinprotocols::Basic& _lhs, const ::test::typesinprotocols::Basic& _rhs) const {
    if (!::fidl::Equals(_lhs.uint8, _rhs.uint8)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.uint16, _rhs.uint16)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.uint32, _rhs.uint32)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.uint64, _rhs.uint64)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.int8, _rhs.int8)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.int16, _rhs.int16)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.int32, _rhs.int32)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.int64, _rhs.int64)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.float32, _rhs.float32)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.float64, _rhs.float64)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.string, _rhs.string)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.opt_string, _rhs.opt_string)) {
      return false;
    }
    return true;
  }
};
template <>
struct CodingTraits<::test::typesinprotocols::Compound>
    : public EncodableCodingTraits<::test::typesinprotocols::Compound, 72> {};


template<>
struct HasPadding<::test::typesinprotocols::Compound> : public std::true_type {};


template<>
struct IsMemcpyCompatible<::test::typesinprotocols::Compound> : public internal::BoolConstant<
    !HasPadding<::test::typesinprotocols::Compound>::value
    && IsMemcpyCompatible<::test::typesinprotocols::Bits>::value
    && IsMemcpyCompatible<::test::typesinprotocols::Enum>::value
    && IsMemcpyCompatible<::test::typesinprotocols::Struct>::value
    && IsMemcpyCompatible<::test::typesinprotocols::Table>::value
    && IsMemcpyCompatible<::test::typesinprotocols::Union>::value
    && IsMemcpyCompatible<::std::unique_ptr<::test::typesinprotocols::Struct>>::value
    && IsMemcpyCompatible<::std::unique_ptr<::test::typesinprotocols::Union>>::value> {};


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

template<>
struct Equality<::test::typesinprotocols::Compound> {
  bool operator()(const ::test::typesinprotocols::Compound& _lhs, const ::test::typesinprotocols::Compound& _rhs) const {
    if (!::fidl::Equals(_lhs.bits, _rhs.bits)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.enum_, _rhs.enum_)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.struct_, _rhs.struct_)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.table, _rhs.table)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.union_, _rhs.union_)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.opt_struct, _rhs.opt_struct)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.opt_union, _rhs.opt_union)) {
      return false;
    }
    return true;
  }
};
template <>
struct CodingTraits<::test::typesinprotocols::ArrayBasic>
    : public EncodableCodingTraits<::test::typesinprotocols::ArrayBasic, 384> {};


template<>
struct HasPadding<::test::typesinprotocols::ArrayBasic> : public std::true_type {};


template<>
struct IsMemcpyCompatible<::test::typesinprotocols::ArrayBasic> : public internal::BoolConstant<
    !HasPadding<::test::typesinprotocols::ArrayBasic>::value
    && IsMemcpyCompatible<::std::array<uint8_t, 5>>::value
    && IsMemcpyCompatible<::std::array<uint16_t, 5>>::value
    && IsMemcpyCompatible<::std::array<uint32_t, 5>>::value
    && IsMemcpyCompatible<::std::array<uint64_t, 5>>::value
    && IsMemcpyCompatible<::std::array<int8_t, 5>>::value
    && IsMemcpyCompatible<::std::array<int16_t, 5>>::value
    && IsMemcpyCompatible<::std::array<int32_t, 5>>::value
    && IsMemcpyCompatible<::std::array<int64_t, 5>>::value
    && IsMemcpyCompatible<::std::array<float, 5>>::value
    && IsMemcpyCompatible<::std::array<double, 5>>::value
    && IsMemcpyCompatible<::std::array<::std::string, 5>>::value
    && IsMemcpyCompatible<::std::array<::fidl::StringPtr, 5>>::value> {};


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

template<>
struct Equality<::test::typesinprotocols::ArrayBasic> {
  bool operator()(const ::test::typesinprotocols::ArrayBasic& _lhs, const ::test::typesinprotocols::ArrayBasic& _rhs) const {
    if (!::fidl::Equals(_lhs.array_uint8, _rhs.array_uint8)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.array_uint16, _rhs.array_uint16)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.array_uint32, _rhs.array_uint32)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.array_uint64, _rhs.array_uint64)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.array_int8, _rhs.array_int8)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.array_int16, _rhs.array_int16)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.array_int32, _rhs.array_int32)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.array_int64, _rhs.array_int64)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.array_float32, _rhs.array_float32)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.array_float64, _rhs.array_float64)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.array_string, _rhs.array_string)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.array_opt_string, _rhs.array_opt_string)) {
      return false;
    }
    return true;
  }
};
template <>
struct CodingTraits<::test::typesinprotocols::ArrayCompound>
    : public EncodableCodingTraits<::test::typesinprotocols::ArrayCompound, 328> {};


template<>
struct HasPadding<::test::typesinprotocols::ArrayCompound> : public std::true_type {};


template<>
struct IsMemcpyCompatible<::test::typesinprotocols::ArrayCompound> : public internal::BoolConstant<
    !HasPadding<::test::typesinprotocols::ArrayCompound>::value
    && IsMemcpyCompatible<::std::array<::test::typesinprotocols::Bits, 5>>::value
    && IsMemcpyCompatible<::std::array<::test::typesinprotocols::Enum, 5>>::value
    && IsMemcpyCompatible<::std::array<::test::typesinprotocols::Struct, 5>>::value
    && IsMemcpyCompatible<::std::array<::test::typesinprotocols::Table, 5>>::value
    && IsMemcpyCompatible<::std::array<::test::typesinprotocols::Union, 5>>::value
    && IsMemcpyCompatible<::std::array<::std::unique_ptr<::test::typesinprotocols::Struct>, 5>>::value
    && IsMemcpyCompatible<::std::array<::std::unique_ptr<::test::typesinprotocols::Union>, 5>>::value> {};


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

template<>
struct Equality<::test::typesinprotocols::ArrayCompound> {
  bool operator()(const ::test::typesinprotocols::ArrayCompound& _lhs, const ::test::typesinprotocols::ArrayCompound& _rhs) const {
    if (!::fidl::Equals(_lhs.array_bits, _rhs.array_bits)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.array_enum, _rhs.array_enum)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.array_struct, _rhs.array_struct)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.array_table, _rhs.array_table)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.array_union, _rhs.array_union)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.array_opt_struct, _rhs.array_opt_struct)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.array_opt_union, _rhs.array_opt_union)) {
      return false;
    }
    return true;
  }
};
template <>
struct CodingTraits<::test::typesinprotocols::VectorBasic>
    : public EncodableCodingTraits<::test::typesinprotocols::VectorBasic, 192> {};


template<>
struct HasPadding<::test::typesinprotocols::VectorBasic> : public std::true_type {};


template<>
struct IsMemcpyCompatible<::test::typesinprotocols::VectorBasic> : public internal::BoolConstant<
    !HasPadding<::test::typesinprotocols::VectorBasic>::value
    && IsMemcpyCompatible<::std::vector<uint8_t>>::value
    && IsMemcpyCompatible<::std::vector<uint16_t>>::value
    && IsMemcpyCompatible<::std::vector<uint32_t>>::value
    && IsMemcpyCompatible<::std::vector<uint64_t>>::value
    && IsMemcpyCompatible<::std::vector<int8_t>>::value
    && IsMemcpyCompatible<::std::vector<int16_t>>::value
    && IsMemcpyCompatible<::std::vector<int32_t>>::value
    && IsMemcpyCompatible<::std::vector<int64_t>>::value
    && IsMemcpyCompatible<::std::vector<float>>::value
    && IsMemcpyCompatible<::std::vector<double>>::value
    && IsMemcpyCompatible<::std::vector<::std::string>>::value
    && IsMemcpyCompatible<::std::vector<::fidl::StringPtr>>::value> {};


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

template<>
struct Equality<::test::typesinprotocols::VectorBasic> {
  bool operator()(const ::test::typesinprotocols::VectorBasic& _lhs, const ::test::typesinprotocols::VectorBasic& _rhs) const {
    if (!::fidl::Equals(_lhs.vector_uint8, _rhs.vector_uint8)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.vector_uint16, _rhs.vector_uint16)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.vector_uint32, _rhs.vector_uint32)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.vector_uint64, _rhs.vector_uint64)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.vector_int8, _rhs.vector_int8)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.vector_int16, _rhs.vector_int16)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.vector_int32, _rhs.vector_int32)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.vector_int64, _rhs.vector_int64)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.vector_float32, _rhs.vector_float32)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.vector_float64, _rhs.vector_float64)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.vector_string, _rhs.vector_string)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.vector_opt_string, _rhs.vector_opt_string)) {
      return false;
    }
    return true;
  }
};
template <>
struct CodingTraits<::test::typesinprotocols::VectorCompound>
    : public EncodableCodingTraits<::test::typesinprotocols::VectorCompound, 112> {};


template<>
struct HasPadding<::test::typesinprotocols::VectorCompound> : public std::true_type {};


template<>
struct IsMemcpyCompatible<::test::typesinprotocols::VectorCompound> : public internal::BoolConstant<
    !HasPadding<::test::typesinprotocols::VectorCompound>::value
    && IsMemcpyCompatible<::std::vector<::test::typesinprotocols::Bits>>::value
    && IsMemcpyCompatible<::std::vector<::test::typesinprotocols::Enum>>::value
    && IsMemcpyCompatible<::std::vector<::test::typesinprotocols::Struct>>::value
    && IsMemcpyCompatible<::std::vector<::test::typesinprotocols::Table>>::value
    && IsMemcpyCompatible<::std::vector<::test::typesinprotocols::Union>>::value
    && IsMemcpyCompatible<::std::vector<::std::unique_ptr<::test::typesinprotocols::Struct>>>::value
    && IsMemcpyCompatible<::std::vector<::std::unique_ptr<::test::typesinprotocols::Union>>>::value> {};


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

template<>
struct Equality<::test::typesinprotocols::VectorCompound> {
  bool operator()(const ::test::typesinprotocols::VectorCompound& _lhs, const ::test::typesinprotocols::VectorCompound& _rhs) const {
    if (!::fidl::Equals(_lhs.vector_bits, _rhs.vector_bits)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.vector_enum, _rhs.vector_enum)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.vector_struct, _rhs.vector_struct)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.vector_table, _rhs.vector_table)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.vector_union, _rhs.vector_union)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.vector_opt_struct, _rhs.vector_opt_struct)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.vector_opt_union, _rhs.vector_opt_union)) {
      return false;
    }
    return true;
  }
};
template <>
struct CodingTraits<::test::typesinprotocols::VectorOptional>
    : public EncodableCodingTraits<::test::typesinprotocols::VectorOptional, 64> {};


template<>
struct HasPadding<::test::typesinprotocols::VectorOptional> : public std::true_type {};


template<>
struct IsMemcpyCompatible<::test::typesinprotocols::VectorOptional> : public internal::BoolConstant<
    !HasPadding<::test::typesinprotocols::VectorOptional>::value
    && IsMemcpyCompatible<::fidl::VectorPtr<uint8_t>>::value
    && IsMemcpyCompatible<::fidl::VectorPtr<::std::string>>::value
    && IsMemcpyCompatible<::fidl::VectorPtr<::std::unique_ptr<::test::typesinprotocols::Struct>>>::value> {};


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

template<>
struct Equality<::test::typesinprotocols::VectorOptional> {
  bool operator()(const ::test::typesinprotocols::VectorOptional& _lhs, const ::test::typesinprotocols::VectorOptional& _rhs) const {
    if (!::fidl::Equals(_lhs.opt_vector_uint8, _rhs.opt_vector_uint8)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.opt_vector_string, _rhs.opt_vector_string)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.opt_vector_opt_struct, _rhs.opt_vector_opt_struct)) {
      return false;
    }
    return true;
  }
};
template <>
struct CodingTraits<::test::typesinprotocols::ArrayVectorNested>
    : public EncodableCodingTraits<::test::typesinprotocols::ArrayVectorNested, 144> {};


template<>
struct HasPadding<::test::typesinprotocols::ArrayVectorNested> : public std::true_type {};


template<>
struct IsMemcpyCompatible<::test::typesinprotocols::ArrayVectorNested> : public internal::BoolConstant<
    !HasPadding<::test::typesinprotocols::ArrayVectorNested>::value
    && IsMemcpyCompatible<::std::array<::std::array<uint8_t, 5>, 5>>::value
    && IsMemcpyCompatible<::std::array<::std::vector<uint8_t>, 5>>::value
    && IsMemcpyCompatible<::std::vector<::std::array<uint8_t, 5>>>::value
    && IsMemcpyCompatible<::std::vector<::std::vector<uint8_t>>>::value> {};


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

template<>
struct Equality<::test::typesinprotocols::ArrayVectorNested> {
  bool operator()(const ::test::typesinprotocols::ArrayVectorNested& _lhs, const ::test::typesinprotocols::ArrayVectorNested& _rhs) const {
    if (!::fidl::Equals(_lhs.array_array_uint8, _rhs.array_array_uint8)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.array_vector_uint8, _rhs.array_vector_uint8)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.vector_array_uint8, _rhs.vector_array_uint8)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.vector_vector_uint8, _rhs.vector_vector_uint8)) {
      return false;
    }
    return true;
  }
};
#ifdef __Fuchsia__

template <>
struct CodingTraits<::test::typesinprotocols::Resource>
    : public EncodableCodingTraits<::test::typesinprotocols::Resource, 456> {};


template<>
struct HasPadding<::test::typesinprotocols::Resource> : public std::true_type {};


template<>
struct IsMemcpyCompatible<::test::typesinprotocols::Resource> : public internal::BoolConstant<
    !HasPadding<::test::typesinprotocols::Resource>::value
    && IsMemcpyCompatible<::zx::handle>::value
    && IsMemcpyCompatible<::zx::vmo>::value
    && IsMemcpyCompatible<::fidl::InterfaceHandle<::test::typesinprotocols::Protocol>>::value
    && IsMemcpyCompatible<::fidl::InterfaceRequest<::test::typesinprotocols::Protocol>>::value
    && IsMemcpyCompatible<::test::typesinprotocols::ResourceStruct>::value
    && IsMemcpyCompatible<::test::typesinprotocols::ResourceTable>::value
    && IsMemcpyCompatible<::test::typesinprotocols::ResourceUnion>::value
    && IsMemcpyCompatible<::std::unique_ptr<::test::typesinprotocols::ResourceStruct>>::value
    && IsMemcpyCompatible<::std::unique_ptr<::test::typesinprotocols::ResourceUnion>>::value
    && IsMemcpyCompatible<::std::array<::zx::handle, 5>>::value
    && IsMemcpyCompatible<::std::array<::zx::vmo, 5>>::value
    && IsMemcpyCompatible<::std::array<::fidl::InterfaceHandle<::test::typesinprotocols::Protocol>, 5>>::value
    && IsMemcpyCompatible<::std::array<::fidl::InterfaceRequest<::test::typesinprotocols::Protocol>, 5>>::value
    && IsMemcpyCompatible<::std::array<::test::typesinprotocols::ResourceStruct, 5>>::value
    && IsMemcpyCompatible<::std::array<::test::typesinprotocols::ResourceTable, 5>>::value
    && IsMemcpyCompatible<::std::array<::test::typesinprotocols::ResourceUnion, 5>>::value
    && IsMemcpyCompatible<::std::vector<::zx::handle>>::value
    && IsMemcpyCompatible<::std::vector<::zx::vmo>>::value
    && IsMemcpyCompatible<::std::vector<::fidl::InterfaceHandle<::test::typesinprotocols::Protocol>>>::value
    && IsMemcpyCompatible<::std::vector<::fidl::InterfaceRequest<::test::typesinprotocols::Protocol>>>::value
    && IsMemcpyCompatible<::std::vector<::test::typesinprotocols::ResourceStruct>>::value
    && IsMemcpyCompatible<::std::vector<::test::typesinprotocols::ResourceTable>>::value
    && IsMemcpyCompatible<::std::vector<::test::typesinprotocols::ResourceUnion>>::value> {};


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

template<>
struct Equality<::test::typesinprotocols::Resource> {
  bool operator()(const ::test::typesinprotocols::Resource& _lhs, const ::test::typesinprotocols::Resource& _rhs) const {
    if (!::fidl::Equals(_lhs.handle, _rhs.handle)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.vmo, _rhs.vmo)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.client_end, _rhs.client_end)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.server_end, _rhs.server_end)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.struct_, _rhs.struct_)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.table, _rhs.table)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.union_, _rhs.union_)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.opt_handle, _rhs.opt_handle)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.opt_vmo, _rhs.opt_vmo)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.opt_client_end, _rhs.opt_client_end)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.opt_server_end, _rhs.opt_server_end)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.opt_struct, _rhs.opt_struct)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.opt_union, _rhs.opt_union)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.array_handle, _rhs.array_handle)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.array_vmo, _rhs.array_vmo)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.array_client_end, _rhs.array_client_end)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.array_server_end, _rhs.array_server_end)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.array_struct, _rhs.array_struct)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.array_table, _rhs.array_table)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.array_union, _rhs.array_union)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.vector_handle, _rhs.vector_handle)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.vector_vmo, _rhs.vector_vmo)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.vector_client_end, _rhs.vector_client_end)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.vector_server_end, _rhs.vector_server_end)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.vector_struct, _rhs.vector_struct)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.vector_table, _rhs.vector_table)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.vector_union, _rhs.vector_union)) {
      return false;
    }
    return true;
  }
};

#endif  // __Fuchsia__

template <>
struct IsFidlXUnion<::test::typesinprotocols::Protocol_ErrorBasic_Result> : public std::true_type {};

template <>
struct CodingTraits<::test::typesinprotocols::Protocol_ErrorBasic_Result>
    : public EncodableCodingTraits<::test::typesinprotocols::Protocol_ErrorBasic_Result, 16> {};

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

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

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

    value->reset(new ::test::typesinprotocols::Protocol_ErrorBasic_Result);

    ::test::typesinprotocols::Protocol_ErrorBasic_Result::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::typesinprotocols::Protocol_ErrorBasic_Result::Tag::Invalid):
        return true;
      case ::test::typesinprotocols::Protocol_ErrorBasic_Result::Tag::kResponse:
        return ::fidl::Equals(_lhs.response_, _rhs.response_);
      case ::test::typesinprotocols::Protocol_ErrorBasic_Result::Tag::kErr:
        return ::fidl::Equals(_lhs.err_, _rhs.err_);
      
      default:
        return false;
      }
    }
};
template <>
struct IsFidlXUnion<::test::typesinprotocols::Protocol_ErrorCompound_Result> : public std::true_type {};

template <>
struct CodingTraits<::test::typesinprotocols::Protocol_ErrorCompound_Result>
    : public EncodableCodingTraits<::test::typesinprotocols::Protocol_ErrorCompound_Result, 16> {};

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

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

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

    value->reset(new ::test::typesinprotocols::Protocol_ErrorCompound_Result);

    ::test::typesinprotocols::Protocol_ErrorCompound_Result::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::typesinprotocols::Protocol_ErrorCompound_Result::Tag::Invalid):
        return true;
      case ::test::typesinprotocols::Protocol_ErrorCompound_Result::Tag::kResponse:
        return ::fidl::Equals(_lhs.response_, _rhs.response_);
      case ::test::typesinprotocols::Protocol_ErrorCompound_Result::Tag::kErr:
        return ::fidl::Equals(_lhs.err_, _rhs.err_);
      
      default:
        return false;
      }
    }
};
template <>
struct IsFidlXUnion<::test::typesinprotocols::Protocol_ErrorArrayBasic_Result> : public std::true_type {};

template <>
struct CodingTraits<::test::typesinprotocols::Protocol_ErrorArrayBasic_Result>
    : public EncodableCodingTraits<::test::typesinprotocols::Protocol_ErrorArrayBasic_Result, 16> {};

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

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

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

    value->reset(new ::test::typesinprotocols::Protocol_ErrorArrayBasic_Result);

    ::test::typesinprotocols::Protocol_ErrorArrayBasic_Result::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::typesinprotocols::Protocol_ErrorArrayBasic_Result::Tag::Invalid):
        return true;
      case ::test::typesinprotocols::Protocol_ErrorArrayBasic_Result::Tag::kResponse:
        return ::fidl::Equals(_lhs.response_, _rhs.response_);
      case ::test::typesinprotocols::Protocol_ErrorArrayBasic_Result::Tag::kErr:
        return ::fidl::Equals(_lhs.err_, _rhs.err_);
      
      default:
        return false;
      }
    }
};
template <>
struct IsFidlXUnion<::test::typesinprotocols::Protocol_ErrorArrayCompound_Result> : public std::true_type {};

template <>
struct CodingTraits<::test::typesinprotocols::Protocol_ErrorArrayCompound_Result>
    : public EncodableCodingTraits<::test::typesinprotocols::Protocol_ErrorArrayCompound_Result, 16> {};

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

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

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

    value->reset(new ::test::typesinprotocols::Protocol_ErrorArrayCompound_Result);

    ::test::typesinprotocols::Protocol_ErrorArrayCompound_Result::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::typesinprotocols::Protocol_ErrorArrayCompound_Result::Tag::Invalid):
        return true;
      case ::test::typesinprotocols::Protocol_ErrorArrayCompound_Result::Tag::kResponse:
        return ::fidl::Equals(_lhs.response_, _rhs.response_);
      case ::test::typesinprotocols::Protocol_ErrorArrayCompound_Result::Tag::kErr:
        return ::fidl::Equals(_lhs.err_, _rhs.err_);
      
      default:
        return false;
      }
    }
};
template <>
struct IsFidlXUnion<::test::typesinprotocols::Protocol_ErrorVectorBasic_Result> : public std::true_type {};

template <>
struct CodingTraits<::test::typesinprotocols::Protocol_ErrorVectorBasic_Result>
    : public EncodableCodingTraits<::test::typesinprotocols::Protocol_ErrorVectorBasic_Result, 16> {};

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

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

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

    value->reset(new ::test::typesinprotocols::Protocol_ErrorVectorBasic_Result);

    ::test::typesinprotocols::Protocol_ErrorVectorBasic_Result::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::typesinprotocols::Protocol_ErrorVectorBasic_Result::Tag::Invalid):
        return true;
      case ::test::typesinprotocols::Protocol_ErrorVectorBasic_Result::Tag::kResponse:
        return ::fidl::Equals(_lhs.response_, _rhs.response_);
      case ::test::typesinprotocols::Protocol_ErrorVectorBasic_Result::Tag::kErr:
        return ::fidl::Equals(_lhs.err_, _rhs.err_);
      
      default:
        return false;
      }
    }
};
template <>
struct IsFidlXUnion<::test::typesinprotocols::Protocol_ErrorVectorCompound_Result> : public std::true_type {};

template <>
struct CodingTraits<::test::typesinprotocols::Protocol_ErrorVectorCompound_Result>
    : public EncodableCodingTraits<::test::typesinprotocols::Protocol_ErrorVectorCompound_Result, 16> {};

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

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

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

    value->reset(new ::test::typesinprotocols::Protocol_ErrorVectorCompound_Result);

    ::test::typesinprotocols::Protocol_ErrorVectorCompound_Result::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::typesinprotocols::Protocol_ErrorVectorCompound_Result::Tag::Invalid):
        return true;
      case ::test::typesinprotocols::Protocol_ErrorVectorCompound_Result::Tag::kResponse:
        return ::fidl::Equals(_lhs.response_, _rhs.response_);
      case ::test::typesinprotocols::Protocol_ErrorVectorCompound_Result::Tag::kErr:
        return ::fidl::Equals(_lhs.err_, _rhs.err_);
      
      default:
        return false;
      }
    }
};
template <>
struct IsFidlXUnion<::test::typesinprotocols::Protocol_ErrorVectorOptional_Result> : public std::true_type {};

template <>
struct CodingTraits<::test::typesinprotocols::Protocol_ErrorVectorOptional_Result>
    : public EncodableCodingTraits<::test::typesinprotocols::Protocol_ErrorVectorOptional_Result, 16> {};

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

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

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

    value->reset(new ::test::typesinprotocols::Protocol_ErrorVectorOptional_Result);

    ::test::typesinprotocols::Protocol_ErrorVectorOptional_Result::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::typesinprotocols::Protocol_ErrorVectorOptional_Result::Tag::Invalid):
        return true;
      case ::test::typesinprotocols::Protocol_ErrorVectorOptional_Result::Tag::kResponse:
        return ::fidl::Equals(_lhs.response_, _rhs.response_);
      case ::test::typesinprotocols::Protocol_ErrorVectorOptional_Result::Tag::kErr:
        return ::fidl::Equals(_lhs.err_, _rhs.err_);
      
      default:
        return false;
      }
    }
};
template <>
struct IsFidlXUnion<::test::typesinprotocols::Protocol_ErrorArrayVectorNested_Result> : public std::true_type {};

template <>
struct CodingTraits<::test::typesinprotocols::Protocol_ErrorArrayVectorNested_Result>
    : public EncodableCodingTraits<::test::typesinprotocols::Protocol_ErrorArrayVectorNested_Result, 16> {};

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

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

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

    value->reset(new ::test::typesinprotocols::Protocol_ErrorArrayVectorNested_Result);

    ::test::typesinprotocols::Protocol_ErrorArrayVectorNested_Result::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::typesinprotocols::Protocol_ErrorArrayVectorNested_Result::Tag::Invalid):
        return true;
      case ::test::typesinprotocols::Protocol_ErrorArrayVectorNested_Result::Tag::kResponse:
        return ::fidl::Equals(_lhs.response_, _rhs.response_);
      case ::test::typesinprotocols::Protocol_ErrorArrayVectorNested_Result::Tag::kErr:
        return ::fidl::Equals(_lhs.err_, _rhs.err_);
      
      default:
        return false;
      }
    }
};
#ifdef __Fuchsia__

template <>
struct IsFidlXUnion<::test::typesinprotocols::Protocol_ErrorResource_Result> : public std::true_type {};

template <>
struct CodingTraits<::test::typesinprotocols::Protocol_ErrorResource_Result>
    : public EncodableCodingTraits<::test::typesinprotocols::Protocol_ErrorResource_Result, 16> {};

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

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

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

    value->reset(new ::test::typesinprotocols::Protocol_ErrorResource_Result);

    ::test::typesinprotocols::Protocol_ErrorResource_Result::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::typesinprotocols::Protocol_ErrorResource_Result::Tag::Invalid):
        return true;
      case ::test::typesinprotocols::Protocol_ErrorResource_Result::Tag::kResponse:
        return ::fidl::Equals(_lhs.response_, _rhs.response_);
      case ::test::typesinprotocols::Protocol_ErrorResource_Result::Tag::kErr:
        return ::fidl::Equals(_lhs.err_, _rhs.err_);
      
      default:
        return false;
      }
    }
};

#endif  // __Fuchsia__


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

#ifdef __Fuchsia__

using ProtocolPtr = ::fidl::InterfacePtr<Protocol>;
class Protocol_Proxy;
class Protocol_Stub;
class Protocol_EventSender;
class Protocol_Sync;
using ProtocolSyncPtr = ::fidl::SynchronousInterfacePtr<Protocol>;
class Protocol_SyncProxy;

namespace internal {

constexpr uint64_t kProtocol_OneWayBasic_Ordinal = 0x7c311f0d9e662df9lu;

constexpr ::fidl::MessageDynamicFlags kProtocol_OneWayBasic_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kProtocol_TwoWayBasic_Ordinal = 0x205b92db5139c88flu;

constexpr ::fidl::MessageDynamicFlags kProtocol_TwoWayBasic_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kProtocol_ErrorBasic_Ordinal = 0x459eaa5d11b9ff93lu;

constexpr ::fidl::MessageDynamicFlags kProtocol_ErrorBasic_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kProtocol_EventBasic_Ordinal = 0x51c5b06295c10c40lu;

constexpr ::fidl::MessageDynamicFlags kProtocol_EventBasic_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kProtocol_OneWayCompound_Ordinal = 0x2bc2bc3a9237c6cclu;

constexpr ::fidl::MessageDynamicFlags kProtocol_OneWayCompound_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kProtocol_TwoWayCompound_Ordinal = 0x79f279c7201da131lu;

constexpr ::fidl::MessageDynamicFlags kProtocol_TwoWayCompound_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kProtocol_ErrorCompound_Ordinal = 0x29817d89a19ec77dlu;

constexpr ::fidl::MessageDynamicFlags kProtocol_ErrorCompound_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kProtocol_EventCompound_Ordinal = 0x617c5410858734d5lu;

constexpr ::fidl::MessageDynamicFlags kProtocol_EventCompound_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kProtocol_OneWayArrayBasic_Ordinal = 0x62e2ebcadf35ca19lu;

constexpr ::fidl::MessageDynamicFlags kProtocol_OneWayArrayBasic_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kProtocol_TwoWayArrayBasic_Ordinal = 0x49ad7a74e28ba114lu;

constexpr ::fidl::MessageDynamicFlags kProtocol_TwoWayArrayBasic_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kProtocol_ErrorArrayBasic_Ordinal = 0xf0dbde9626fff79lu;

constexpr ::fidl::MessageDynamicFlags kProtocol_ErrorArrayBasic_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kProtocol_EventArrayBasic_Ordinal = 0x51b76208b148f02elu;

constexpr ::fidl::MessageDynamicFlags kProtocol_EventArrayBasic_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kProtocol_OneWayArrayCompound_Ordinal = 0x464948bae1bda09dlu;

constexpr ::fidl::MessageDynamicFlags kProtocol_OneWayArrayCompound_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kProtocol_TwoWayArrayCompound_Ordinal = 0xbcae616f8e1ea7blu;

constexpr ::fidl::MessageDynamicFlags kProtocol_TwoWayArrayCompound_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kProtocol_ErrorArrayCompound_Ordinal = 0x52257f80e29c1a04lu;

constexpr ::fidl::MessageDynamicFlags kProtocol_ErrorArrayCompound_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kProtocol_EventArrayCompound_Ordinal = 0x1e63a00079aa7415lu;

constexpr ::fidl::MessageDynamicFlags kProtocol_EventArrayCompound_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kProtocol_OneWayVectorBasic_Ordinal = 0x4f907dde77464657lu;

constexpr ::fidl::MessageDynamicFlags kProtocol_OneWayVectorBasic_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kProtocol_TwoWayVectorBasic_Ordinal = 0x7860cb3ed8362e74lu;

constexpr ::fidl::MessageDynamicFlags kProtocol_TwoWayVectorBasic_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kProtocol_ErrorVectorBasic_Ordinal = 0xc27f841d6313f72lu;

constexpr ::fidl::MessageDynamicFlags kProtocol_ErrorVectorBasic_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kProtocol_EventVectorBasic_Ordinal = 0x3f9d405e7191eff6lu;

constexpr ::fidl::MessageDynamicFlags kProtocol_EventVectorBasic_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kProtocol_OneWayVectorCompound_Ordinal = 0x19baae42829dbe90lu;

constexpr ::fidl::MessageDynamicFlags kProtocol_OneWayVectorCompound_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kProtocol_TwoWayVectorCompound_Ordinal = 0x371140db701b23b4lu;

constexpr ::fidl::MessageDynamicFlags kProtocol_TwoWayVectorCompound_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kProtocol_ErrorVectorCompound_Ordinal = 0x760e278628f7a985lu;

constexpr ::fidl::MessageDynamicFlags kProtocol_ErrorVectorCompound_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kProtocol_EventVectorCompound_Ordinal = 0x53a1fc56e8b3cff3lu;

constexpr ::fidl::MessageDynamicFlags kProtocol_EventVectorCompound_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kProtocol_OneWayVectorOptional_Ordinal = 0x153c6b333c21c52flu;

constexpr ::fidl::MessageDynamicFlags kProtocol_OneWayVectorOptional_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kProtocol_TwoWayVectorOptional_Ordinal = 0xe4b620aaafd73f3lu;

constexpr ::fidl::MessageDynamicFlags kProtocol_TwoWayVectorOptional_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kProtocol_ErrorVectorOptional_Ordinal = 0x58e75cf86e2d715elu;

constexpr ::fidl::MessageDynamicFlags kProtocol_ErrorVectorOptional_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kProtocol_EventVectorOptional_Ordinal = 0x17617b54dfa8d85dlu;

constexpr ::fidl::MessageDynamicFlags kProtocol_EventVectorOptional_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kProtocol_OneWayArrayVectorNested_Ordinal = 0x520dc9cb9b9b5ed7lu;

constexpr ::fidl::MessageDynamicFlags kProtocol_OneWayArrayVectorNested_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kProtocol_TwoWayArrayVectorNested_Ordinal = 0x4a438ce0948817dclu;

constexpr ::fidl::MessageDynamicFlags kProtocol_TwoWayArrayVectorNested_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kProtocol_ErrorArrayVectorNested_Ordinal = 0x7e168d89e1dac8a7lu;

constexpr ::fidl::MessageDynamicFlags kProtocol_ErrorArrayVectorNested_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kProtocol_EventArrayVectorNested_Ordinal = 0x110b72cfebc4037elu;

constexpr ::fidl::MessageDynamicFlags kProtocol_EventArrayVectorNested_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kProtocol_OneWayResource_Ordinal = 0x5af4795a9ed3a022lu;

constexpr ::fidl::MessageDynamicFlags kProtocol_OneWayResource_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kProtocol_TwoWayResource_Ordinal = 0x1904824a11c6ad5blu;

constexpr ::fidl::MessageDynamicFlags kProtocol_TwoWayResource_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kProtocol_ErrorResource_Ordinal = 0x5b28634d603175b6lu;

constexpr ::fidl::MessageDynamicFlags kProtocol_ErrorResource_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kProtocol_EventResource_Ordinal = 0x4fbde2864601698blu;

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

#endif  // __Fuchsia__

#ifdef __Fuchsia__

class Protocol {
 public:
  using Proxy_ = ::test::typesinprotocols::Protocol_Proxy;
  using Stub_ = ::test::typesinprotocols::Protocol_Stub;
  using EventSender_ = ::test::typesinprotocols::Protocol_EventSender;
  using Sync_ = ::test::typesinprotocols::Protocol_Sync;
  virtual ~Protocol();
      
  virtual void OneWayBasic(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, ::fidl::StringPtr opt_string) = 0;
  using TwoWayBasicCallback =
      fit::function<void(uint8_t, uint16_t, uint32_t, uint64_t, int8_t, int16_t, int32_t, int64_t, float, double, ::std::string, ::fidl::StringPtr)>;
      
  virtual void TwoWayBasic(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, ::fidl::StringPtr opt_string, TwoWayBasicCallback callback) = 0;
  using ErrorBasicCallback =
      fit::function<void(::test::typesinprotocols::Protocol_ErrorBasic_Result)>;
      
  virtual void ErrorBasic(ErrorBasicCallback callback) = 0;
  using EventBasicCallback =
      fit::function<void(uint8_t, uint16_t, uint32_t, uint64_t, int8_t, int16_t, int32_t, int64_t, float, double, ::std::string, ::fidl::StringPtr)>;
      
  virtual void OneWayCompound(::test::typesinprotocols::Bits bits, ::test::typesinprotocols::Enum enum_, ::test::typesinprotocols::Struct struct_, ::test::typesinprotocols::Table table, ::test::typesinprotocols::Union union_, ::std::unique_ptr<::test::typesinprotocols::Struct> opt_struct, ::std::unique_ptr<::test::typesinprotocols::Union> opt_union) = 0;
  using TwoWayCompoundCallback =
      fit::function<void(::test::typesinprotocols::Bits, ::test::typesinprotocols::Enum, ::test::typesinprotocols::Struct, ::test::typesinprotocols::Table, ::test::typesinprotocols::Union, ::std::unique_ptr<::test::typesinprotocols::Struct>, ::std::unique_ptr<::test::typesinprotocols::Union>)>;
      
  virtual void TwoWayCompound(::test::typesinprotocols::Bits bits, ::test::typesinprotocols::Enum enum_, ::test::typesinprotocols::Struct struct_, ::test::typesinprotocols::Table table, ::test::typesinprotocols::Union union_, ::std::unique_ptr<::test::typesinprotocols::Struct> opt_struct, ::std::unique_ptr<::test::typesinprotocols::Union> opt_union, TwoWayCompoundCallback callback) = 0;
  using ErrorCompoundCallback =
      fit::function<void(::test::typesinprotocols::Protocol_ErrorCompound_Result)>;
      
  virtual void ErrorCompound(ErrorCompoundCallback callback) = 0;
  using EventCompoundCallback =
      fit::function<void(::test::typesinprotocols::Bits, ::test::typesinprotocols::Enum, ::test::typesinprotocols::Struct, ::test::typesinprotocols::Table, ::test::typesinprotocols::Union, ::std::unique_ptr<::test::typesinprotocols::Struct>, ::std::unique_ptr<::test::typesinprotocols::Union>)>;
      
  virtual void OneWayArrayBasic(::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<::fidl::StringPtr, 5> array_opt_string) = 0;
  using TwoWayArrayBasicCallback =
      fit::function<void(::std::array<uint8_t, 5>, ::std::array<uint16_t, 5>, ::std::array<uint32_t, 5>, ::std::array<uint64_t, 5>, ::std::array<int8_t, 5>, ::std::array<int16_t, 5>, ::std::array<int32_t, 5>, ::std::array<int64_t, 5>, ::std::array<float, 5>, ::std::array<double, 5>, ::std::array<::std::string, 5>, ::std::array<::fidl::StringPtr, 5>)>;
      
  virtual void TwoWayArrayBasic(::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<::fidl::StringPtr, 5> array_opt_string, TwoWayArrayBasicCallback callback) = 0;
  using ErrorArrayBasicCallback =
      fit::function<void(::test::typesinprotocols::Protocol_ErrorArrayBasic_Result)>;
      
  virtual void ErrorArrayBasic(ErrorArrayBasicCallback callback) = 0;
  using EventArrayBasicCallback =
      fit::function<void(::std::array<uint8_t, 5>, ::std::array<uint16_t, 5>, ::std::array<uint32_t, 5>, ::std::array<uint64_t, 5>, ::std::array<int8_t, 5>, ::std::array<int16_t, 5>, ::std::array<int32_t, 5>, ::std::array<int64_t, 5>, ::std::array<float, 5>, ::std::array<double, 5>, ::std::array<::std::string, 5>, ::std::array<::fidl::StringPtr, 5>)>;
      
  virtual void OneWayArrayCompound(::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<::std::unique_ptr<::test::typesinprotocols::Struct>, 5> array_opt_struct, ::std::array<::std::unique_ptr<::test::typesinprotocols::Union>, 5> array_opt_union) = 0;
  using TwoWayArrayCompoundCallback =
      fit::function<void(::std::array<::test::typesinprotocols::Bits, 5>, ::std::array<::test::typesinprotocols::Enum, 5>, ::std::array<::test::typesinprotocols::Struct, 5>, ::std::array<::test::typesinprotocols::Table, 5>, ::std::array<::test::typesinprotocols::Union, 5>, ::std::array<::std::unique_ptr<::test::typesinprotocols::Struct>, 5>, ::std::array<::std::unique_ptr<::test::typesinprotocols::Union>, 5>)>;
      
  virtual void TwoWayArrayCompound(::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<::std::unique_ptr<::test::typesinprotocols::Struct>, 5> array_opt_struct, ::std::array<::std::unique_ptr<::test::typesinprotocols::Union>, 5> array_opt_union, TwoWayArrayCompoundCallback callback) = 0;
  using ErrorArrayCompoundCallback =
      fit::function<void(::test::typesinprotocols::Protocol_ErrorArrayCompound_Result)>;
      
  virtual void ErrorArrayCompound(ErrorArrayCompoundCallback callback) = 0;
  using EventArrayCompoundCallback =
      fit::function<void(::std::array<::test::typesinprotocols::Bits, 5>, ::std::array<::test::typesinprotocols::Enum, 5>, ::std::array<::test::typesinprotocols::Struct, 5>, ::std::array<::test::typesinprotocols::Table, 5>, ::std::array<::test::typesinprotocols::Union, 5>, ::std::array<::std::unique_ptr<::test::typesinprotocols::Struct>, 5>, ::std::array<::std::unique_ptr<::test::typesinprotocols::Union>, 5>)>;
      
  virtual void OneWayVectorBasic(::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<::fidl::StringPtr> vector_opt_string) = 0;
  using TwoWayVectorBasicCallback =
      fit::function<void(::std::vector<uint8_t>, ::std::vector<uint16_t>, ::std::vector<uint32_t>, ::std::vector<uint64_t>, ::std::vector<int8_t>, ::std::vector<int16_t>, ::std::vector<int32_t>, ::std::vector<int64_t>, ::std::vector<float>, ::std::vector<double>, ::std::vector<::std::string>, ::std::vector<::fidl::StringPtr>)>;
      
  virtual void TwoWayVectorBasic(::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<::fidl::StringPtr> vector_opt_string, TwoWayVectorBasicCallback callback) = 0;
  using ErrorVectorBasicCallback =
      fit::function<void(::test::typesinprotocols::Protocol_ErrorVectorBasic_Result)>;
      
  virtual void ErrorVectorBasic(ErrorVectorBasicCallback callback) = 0;
  using EventVectorBasicCallback =
      fit::function<void(::std::vector<uint8_t>, ::std::vector<uint16_t>, ::std::vector<uint32_t>, ::std::vector<uint64_t>, ::std::vector<int8_t>, ::std::vector<int16_t>, ::std::vector<int32_t>, ::std::vector<int64_t>, ::std::vector<float>, ::std::vector<double>, ::std::vector<::std::string>, ::std::vector<::fidl::StringPtr>)>;
      
  virtual void OneWayVectorCompound(::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<::std::unique_ptr<::test::typesinprotocols::Struct>> vector_opt_struct, ::std::vector<::std::unique_ptr<::test::typesinprotocols::Union>> vector_opt_union) = 0;
  using TwoWayVectorCompoundCallback =
      fit::function<void(::std::vector<::test::typesinprotocols::Bits>, ::std::vector<::test::typesinprotocols::Enum>, ::std::vector<::test::typesinprotocols::Struct>, ::std::vector<::test::typesinprotocols::Table>, ::std::vector<::test::typesinprotocols::Union>, ::std::vector<::std::unique_ptr<::test::typesinprotocols::Struct>>, ::std::vector<::std::unique_ptr<::test::typesinprotocols::Union>>)>;
      
  virtual void TwoWayVectorCompound(::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<::std::unique_ptr<::test::typesinprotocols::Struct>> vector_opt_struct, ::std::vector<::std::unique_ptr<::test::typesinprotocols::Union>> vector_opt_union, TwoWayVectorCompoundCallback callback) = 0;
  using ErrorVectorCompoundCallback =
      fit::function<void(::test::typesinprotocols::Protocol_ErrorVectorCompound_Result)>;
      
  virtual void ErrorVectorCompound(ErrorVectorCompoundCallback callback) = 0;
  using EventVectorCompoundCallback =
      fit::function<void(::std::vector<::test::typesinprotocols::Bits>, ::std::vector<::test::typesinprotocols::Enum>, ::std::vector<::test::typesinprotocols::Struct>, ::std::vector<::test::typesinprotocols::Table>, ::std::vector<::test::typesinprotocols::Union>, ::std::vector<::std::unique_ptr<::test::typesinprotocols::Struct>>, ::std::vector<::std::unique_ptr<::test::typesinprotocols::Union>>)>;
      
  virtual void OneWayVectorOptional(::fidl::VectorPtr<uint8_t> opt_vector_uint8, ::fidl::VectorPtr<::std::string> opt_vector_string, ::fidl::VectorPtr<::std::unique_ptr<::test::typesinprotocols::Struct>> opt_vector_opt_struct) = 0;
  using TwoWayVectorOptionalCallback =
      fit::function<void(::fidl::VectorPtr<uint8_t>, ::fidl::VectorPtr<::std::string>, ::fidl::VectorPtr<::std::unique_ptr<::test::typesinprotocols::Struct>>)>;
      
  virtual void TwoWayVectorOptional(::fidl::VectorPtr<uint8_t> opt_vector_uint8, ::fidl::VectorPtr<::std::string> opt_vector_string, ::fidl::VectorPtr<::std::unique_ptr<::test::typesinprotocols::Struct>> opt_vector_opt_struct, TwoWayVectorOptionalCallback callback) = 0;
  using ErrorVectorOptionalCallback =
      fit::function<void(::test::typesinprotocols::Protocol_ErrorVectorOptional_Result)>;
      
  virtual void ErrorVectorOptional(ErrorVectorOptionalCallback callback) = 0;
  using EventVectorOptionalCallback =
      fit::function<void(::fidl::VectorPtr<uint8_t>, ::fidl::VectorPtr<::std::string>, ::fidl::VectorPtr<::std::unique_ptr<::test::typesinprotocols::Struct>>)>;
      
  virtual void OneWayArrayVectorNested(::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) = 0;
  using TwoWayArrayVectorNestedCallback =
      fit::function<void(::std::array<::std::array<uint8_t, 5>, 5>, ::std::array<::std::vector<uint8_t>, 5>, ::std::vector<::std::array<uint8_t, 5>>, ::std::vector<::std::vector<uint8_t>>)>;
      
  virtual void TwoWayArrayVectorNested(::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, TwoWayArrayVectorNestedCallback callback) = 0;
  using ErrorArrayVectorNestedCallback =
      fit::function<void(::test::typesinprotocols::Protocol_ErrorArrayVectorNested_Result)>;
      
  virtual void ErrorArrayVectorNested(ErrorArrayVectorNestedCallback callback) = 0;
  using EventArrayVectorNestedCallback =
      fit::function<void(::std::array<::std::array<uint8_t, 5>, 5>, ::std::array<::std::vector<uint8_t>, 5>, ::std::vector<::std::array<uint8_t, 5>>, ::std::vector<::std::vector<uint8_t>>)>;
      
  virtual void OneWayResource(::zx::handle handle, ::zx::vmo vmo, ::fidl::InterfaceHandle<::test::typesinprotocols::Protocol> client_end, ::fidl::InterfaceRequest<::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::InterfaceHandle<::test::typesinprotocols::Protocol> opt_client_end, ::fidl::InterfaceRequest<::test::typesinprotocols::Protocol> opt_server_end, ::std::unique_ptr<::test::typesinprotocols::ResourceStruct> opt_struct, ::std::unique_ptr<::test::typesinprotocols::ResourceUnion> opt_union, ::std::array<::zx::handle, 5> array_handle, ::std::array<::zx::vmo, 5> array_vmo, ::std::array<::fidl::InterfaceHandle<::test::typesinprotocols::Protocol>, 5> array_client_end, ::std::array<::fidl::InterfaceRequest<::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::InterfaceHandle<::test::typesinprotocols::Protocol>> vector_client_end, ::std::vector<::fidl::InterfaceRequest<::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) = 0;
  using TwoWayResourceCallback =
      fit::function<void(::zx::handle, ::zx::vmo, ::fidl::InterfaceHandle<::test::typesinprotocols::Protocol>, ::fidl::InterfaceRequest<::test::typesinprotocols::Protocol>, ::test::typesinprotocols::ResourceStruct, ::test::typesinprotocols::ResourceTable, ::test::typesinprotocols::ResourceUnion, ::zx::handle, ::zx::vmo, ::fidl::InterfaceHandle<::test::typesinprotocols::Protocol>, ::fidl::InterfaceRequest<::test::typesinprotocols::Protocol>, ::std::unique_ptr<::test::typesinprotocols::ResourceStruct>, ::std::unique_ptr<::test::typesinprotocols::ResourceUnion>, ::std::array<::zx::handle, 5>, ::std::array<::zx::vmo, 5>, ::std::array<::fidl::InterfaceHandle<::test::typesinprotocols::Protocol>, 5>, ::std::array<::fidl::InterfaceRequest<::test::typesinprotocols::Protocol>, 5>, ::std::array<::test::typesinprotocols::ResourceStruct, 5>, ::std::array<::test::typesinprotocols::ResourceTable, 5>, ::std::array<::test::typesinprotocols::ResourceUnion, 5>, ::std::vector<::zx::handle>, ::std::vector<::zx::vmo>, ::std::vector<::fidl::InterfaceHandle<::test::typesinprotocols::Protocol>>, ::std::vector<::fidl::InterfaceRequest<::test::typesinprotocols::Protocol>>, ::std::vector<::test::typesinprotocols::ResourceStruct>, ::std::vector<::test::typesinprotocols::ResourceTable>, ::std::vector<::test::typesinprotocols::ResourceUnion>)>;
      
  virtual void TwoWayResource(::zx::handle handle, ::zx::vmo vmo, ::fidl::InterfaceHandle<::test::typesinprotocols::Protocol> client_end, ::fidl::InterfaceRequest<::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::InterfaceHandle<::test::typesinprotocols::Protocol> opt_client_end, ::fidl::InterfaceRequest<::test::typesinprotocols::Protocol> opt_server_end, ::std::unique_ptr<::test::typesinprotocols::ResourceStruct> opt_struct, ::std::unique_ptr<::test::typesinprotocols::ResourceUnion> opt_union, ::std::array<::zx::handle, 5> array_handle, ::std::array<::zx::vmo, 5> array_vmo, ::std::array<::fidl::InterfaceHandle<::test::typesinprotocols::Protocol>, 5> array_client_end, ::std::array<::fidl::InterfaceRequest<::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::InterfaceHandle<::test::typesinprotocols::Protocol>> vector_client_end, ::std::vector<::fidl::InterfaceRequest<::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, TwoWayResourceCallback callback) = 0;
  using ErrorResourceCallback =
      fit::function<void(::test::typesinprotocols::Protocol_ErrorResource_Result)>;
      
  virtual void ErrorResource(ErrorResourceCallback callback) = 0;
  using EventResourceCallback =
      fit::function<void(::zx::handle, ::zx::vmo, ::fidl::InterfaceHandle<::test::typesinprotocols::Protocol>, ::fidl::InterfaceRequest<::test::typesinprotocols::Protocol>, ::test::typesinprotocols::ResourceStruct, ::test::typesinprotocols::ResourceTable, ::test::typesinprotocols::ResourceUnion, ::zx::handle, ::zx::vmo, ::fidl::InterfaceHandle<::test::typesinprotocols::Protocol>, ::fidl::InterfaceRequest<::test::typesinprotocols::Protocol>, ::std::unique_ptr<::test::typesinprotocols::ResourceStruct>, ::std::unique_ptr<::test::typesinprotocols::ResourceUnion>, ::std::array<::zx::handle, 5>, ::std::array<::zx::vmo, 5>, ::std::array<::fidl::InterfaceHandle<::test::typesinprotocols::Protocol>, 5>, ::std::array<::fidl::InterfaceRequest<::test::typesinprotocols::Protocol>, 5>, ::std::array<::test::typesinprotocols::ResourceStruct, 5>, ::std::array<::test::typesinprotocols::ResourceTable, 5>, ::std::array<::test::typesinprotocols::ResourceUnion, 5>, ::std::vector<::zx::handle>, ::std::vector<::zx::vmo>, ::std::vector<::fidl::InterfaceHandle<::test::typesinprotocols::Protocol>>, ::std::vector<::fidl::InterfaceRequest<::test::typesinprotocols::Protocol>>, ::std::vector<::test::typesinprotocols::ResourceStruct>, ::std::vector<::test::typesinprotocols::ResourceTable>, ::std::vector<::test::typesinprotocols::ResourceUnion>)>;

  
};

class Protocol_RequestDecoder {
 public:
  Protocol_RequestDecoder() = default;
  virtual ~Protocol_RequestDecoder() = default;
  static const fidl_type_t* GetType(uint64_t ordinal, bool* out_needs_response, bool* is_known);
  virtual void OneWayBasic(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, ::fidl::StringPtr opt_string) = 0;
  virtual void TwoWayBasic(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, ::fidl::StringPtr opt_string) = 0;
  virtual void ErrorBasic() = 0;
  virtual void OneWayCompound(::test::typesinprotocols::Bits bits, ::test::typesinprotocols::Enum enum_, ::test::typesinprotocols::Struct struct_, ::test::typesinprotocols::Table table, ::test::typesinprotocols::Union union_, ::std::unique_ptr<::test::typesinprotocols::Struct> opt_struct, ::std::unique_ptr<::test::typesinprotocols::Union> opt_union) = 0;
  virtual void TwoWayCompound(::test::typesinprotocols::Bits bits, ::test::typesinprotocols::Enum enum_, ::test::typesinprotocols::Struct struct_, ::test::typesinprotocols::Table table, ::test::typesinprotocols::Union union_, ::std::unique_ptr<::test::typesinprotocols::Struct> opt_struct, ::std::unique_ptr<::test::typesinprotocols::Union> opt_union) = 0;
  virtual void ErrorCompound() = 0;
  virtual void OneWayArrayBasic(::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<::fidl::StringPtr, 5> array_opt_string) = 0;
  virtual void TwoWayArrayBasic(::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<::fidl::StringPtr, 5> array_opt_string) = 0;
  virtual void ErrorArrayBasic() = 0;
  virtual void OneWayArrayCompound(::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<::std::unique_ptr<::test::typesinprotocols::Struct>, 5> array_opt_struct, ::std::array<::std::unique_ptr<::test::typesinprotocols::Union>, 5> array_opt_union) = 0;
  virtual void TwoWayArrayCompound(::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<::std::unique_ptr<::test::typesinprotocols::Struct>, 5> array_opt_struct, ::std::array<::std::unique_ptr<::test::typesinprotocols::Union>, 5> array_opt_union) = 0;
  virtual void ErrorArrayCompound() = 0;
  virtual void OneWayVectorBasic(::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<::fidl::StringPtr> vector_opt_string) = 0;
  virtual void TwoWayVectorBasic(::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<::fidl::StringPtr> vector_opt_string) = 0;
  virtual void ErrorVectorBasic() = 0;
  virtual void OneWayVectorCompound(::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<::std::unique_ptr<::test::typesinprotocols::Struct>> vector_opt_struct, ::std::vector<::std::unique_ptr<::test::typesinprotocols::Union>> vector_opt_union) = 0;
  virtual void TwoWayVectorCompound(::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<::std::unique_ptr<::test::typesinprotocols::Struct>> vector_opt_struct, ::std::vector<::std::unique_ptr<::test::typesinprotocols::Union>> vector_opt_union) = 0;
  virtual void ErrorVectorCompound() = 0;
  virtual void OneWayVectorOptional(::fidl::VectorPtr<uint8_t> opt_vector_uint8, ::fidl::VectorPtr<::std::string> opt_vector_string, ::fidl::VectorPtr<::std::unique_ptr<::test::typesinprotocols::Struct>> opt_vector_opt_struct) = 0;
  virtual void TwoWayVectorOptional(::fidl::VectorPtr<uint8_t> opt_vector_uint8, ::fidl::VectorPtr<::std::string> opt_vector_string, ::fidl::VectorPtr<::std::unique_ptr<::test::typesinprotocols::Struct>> opt_vector_opt_struct) = 0;
  virtual void ErrorVectorOptional() = 0;
  virtual void OneWayArrayVectorNested(::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) = 0;
  virtual void TwoWayArrayVectorNested(::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) = 0;
  virtual void ErrorArrayVectorNested() = 0;
  virtual void OneWayResource(::zx::handle handle, ::zx::vmo vmo, ::fidl::InterfaceHandle<::test::typesinprotocols::Protocol> client_end, ::fidl::InterfaceRequest<::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::InterfaceHandle<::test::typesinprotocols::Protocol> opt_client_end, ::fidl::InterfaceRequest<::test::typesinprotocols::Protocol> opt_server_end, ::std::unique_ptr<::test::typesinprotocols::ResourceStruct> opt_struct, ::std::unique_ptr<::test::typesinprotocols::ResourceUnion> opt_union, ::std::array<::zx::handle, 5> array_handle, ::std::array<::zx::vmo, 5> array_vmo, ::std::array<::fidl::InterfaceHandle<::test::typesinprotocols::Protocol>, 5> array_client_end, ::std::array<::fidl::InterfaceRequest<::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::InterfaceHandle<::test::typesinprotocols::Protocol>> vector_client_end, ::std::vector<::fidl::InterfaceRequest<::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) = 0;
  virtual void TwoWayResource(::zx::handle handle, ::zx::vmo vmo, ::fidl::InterfaceHandle<::test::typesinprotocols::Protocol> client_end, ::fidl::InterfaceRequest<::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::InterfaceHandle<::test::typesinprotocols::Protocol> opt_client_end, ::fidl::InterfaceRequest<::test::typesinprotocols::Protocol> opt_server_end, ::std::unique_ptr<::test::typesinprotocols::ResourceStruct> opt_struct, ::std::unique_ptr<::test::typesinprotocols::ResourceUnion> opt_union, ::std::array<::zx::handle, 5> array_handle, ::std::array<::zx::vmo, 5> array_vmo, ::std::array<::fidl::InterfaceHandle<::test::typesinprotocols::Protocol>, 5> array_client_end, ::std::array<::fidl::InterfaceRequest<::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::InterfaceHandle<::test::typesinprotocols::Protocol>> vector_client_end, ::std::vector<::fidl::InterfaceRequest<::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) = 0;
  virtual void ErrorResource() = 0;
};

class Protocol_ResponseDecoder {
 public:
  Protocol_ResponseDecoder() = default;
  virtual ~Protocol_ResponseDecoder() = default;
  static const fidl_type_t* GetType(uint64_t ordinal);
  virtual void TwoWayBasic(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, ::fidl::StringPtr opt_string) = 0;
  virtual void ErrorBasic(::test::typesinprotocols::Protocol_ErrorBasic_Result Protocol_ErrorBasic_Result) = 0;
  virtual void EventBasic(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, ::fidl::StringPtr opt_string) = 0;
  virtual void TwoWayCompound(::test::typesinprotocols::Bits bits, ::test::typesinprotocols::Enum enum_, ::test::typesinprotocols::Struct struct_, ::test::typesinprotocols::Table table, ::test::typesinprotocols::Union union_, ::std::unique_ptr<::test::typesinprotocols::Struct> opt_struct, ::std::unique_ptr<::test::typesinprotocols::Union> opt_union) = 0;
  virtual void ErrorCompound(::test::typesinprotocols::Protocol_ErrorCompound_Result Protocol_ErrorCompound_Result) = 0;
  virtual void EventCompound(::test::typesinprotocols::Bits bits, ::test::typesinprotocols::Enum enum_, ::test::typesinprotocols::Struct struct_, ::test::typesinprotocols::Table table, ::test::typesinprotocols::Union union_, ::std::unique_ptr<::test::typesinprotocols::Struct> opt_struct, ::std::unique_ptr<::test::typesinprotocols::Union> opt_union) = 0;
  virtual void TwoWayArrayBasic(::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<::fidl::StringPtr, 5> array_opt_string) = 0;
  virtual void ErrorArrayBasic(::test::typesinprotocols::Protocol_ErrorArrayBasic_Result Protocol_ErrorArrayBasic_Result) = 0;
  virtual void EventArrayBasic(::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<::fidl::StringPtr, 5> array_opt_string) = 0;
  virtual void TwoWayArrayCompound(::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<::std::unique_ptr<::test::typesinprotocols::Struct>, 5> array_opt_struct, ::std::array<::std::unique_ptr<::test::typesinprotocols::Union>, 5> array_opt_union) = 0;
  virtual void ErrorArrayCompound(::test::typesinprotocols::Protocol_ErrorArrayCompound_Result Protocol_ErrorArrayCompound_Result) = 0;
  virtual void EventArrayCompound(::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<::std::unique_ptr<::test::typesinprotocols::Struct>, 5> array_opt_struct, ::std::array<::std::unique_ptr<::test::typesinprotocols::Union>, 5> array_opt_union) = 0;
  virtual void TwoWayVectorBasic(::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<::fidl::StringPtr> vector_opt_string) = 0;
  virtual void ErrorVectorBasic(::test::typesinprotocols::Protocol_ErrorVectorBasic_Result Protocol_ErrorVectorBasic_Result) = 0;
  virtual void EventVectorBasic(::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<::fidl::StringPtr> vector_opt_string) = 0;
  virtual void TwoWayVectorCompound(::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<::std::unique_ptr<::test::typesinprotocols::Struct>> vector_opt_struct, ::std::vector<::std::unique_ptr<::test::typesinprotocols::Union>> vector_opt_union) = 0;
  virtual void ErrorVectorCompound(::test::typesinprotocols::Protocol_ErrorVectorCompound_Result Protocol_ErrorVectorCompound_Result) = 0;
  virtual void EventVectorCompound(::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<::std::unique_ptr<::test::typesinprotocols::Struct>> vector_opt_struct, ::std::vector<::std::unique_ptr<::test::typesinprotocols::Union>> vector_opt_union) = 0;
  virtual void TwoWayVectorOptional(::fidl::VectorPtr<uint8_t> opt_vector_uint8, ::fidl::VectorPtr<::std::string> opt_vector_string, ::fidl::VectorPtr<::std::unique_ptr<::test::typesinprotocols::Struct>> opt_vector_opt_struct) = 0;
  virtual void ErrorVectorOptional(::test::typesinprotocols::Protocol_ErrorVectorOptional_Result Protocol_ErrorVectorOptional_Result) = 0;
  virtual void EventVectorOptional(::fidl::VectorPtr<uint8_t> opt_vector_uint8, ::fidl::VectorPtr<::std::string> opt_vector_string, ::fidl::VectorPtr<::std::unique_ptr<::test::typesinprotocols::Struct>> opt_vector_opt_struct) = 0;
  virtual void TwoWayArrayVectorNested(::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) = 0;
  virtual void ErrorArrayVectorNested(::test::typesinprotocols::Protocol_ErrorArrayVectorNested_Result Protocol_ErrorArrayVectorNested_Result) = 0;
  virtual void EventArrayVectorNested(::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) = 0;
  virtual void TwoWayResource(::zx::handle handle, ::zx::vmo vmo, ::fidl::InterfaceHandle<::test::typesinprotocols::Protocol> client_end, ::fidl::InterfaceRequest<::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::InterfaceHandle<::test::typesinprotocols::Protocol> opt_client_end, ::fidl::InterfaceRequest<::test::typesinprotocols::Protocol> opt_server_end, ::std::unique_ptr<::test::typesinprotocols::ResourceStruct> opt_struct, ::std::unique_ptr<::test::typesinprotocols::ResourceUnion> opt_union, ::std::array<::zx::handle, 5> array_handle, ::std::array<::zx::vmo, 5> array_vmo, ::std::array<::fidl::InterfaceHandle<::test::typesinprotocols::Protocol>, 5> array_client_end, ::std::array<::fidl::InterfaceRequest<::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::InterfaceHandle<::test::typesinprotocols::Protocol>> vector_client_end, ::std::vector<::fidl::InterfaceRequest<::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) = 0;
  virtual void ErrorResource(::test::typesinprotocols::Protocol_ErrorResource_Result Protocol_ErrorResource_Result) = 0;
  virtual void EventResource(::zx::handle handle, ::zx::vmo vmo, ::fidl::InterfaceHandle<::test::typesinprotocols::Protocol> client_end, ::fidl::InterfaceRequest<::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::InterfaceHandle<::test::typesinprotocols::Protocol> opt_client_end, ::fidl::InterfaceRequest<::test::typesinprotocols::Protocol> opt_server_end, ::std::unique_ptr<::test::typesinprotocols::ResourceStruct> opt_struct, ::std::unique_ptr<::test::typesinprotocols::ResourceUnion> opt_union, ::std::array<::zx::handle, 5> array_handle, ::std::array<::zx::vmo, 5> array_vmo, ::std::array<::fidl::InterfaceHandle<::test::typesinprotocols::Protocol>, 5> array_client_end, ::std::array<::fidl::InterfaceRequest<::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::InterfaceHandle<::test::typesinprotocols::Protocol>> vector_client_end, ::std::vector<::fidl::InterfaceRequest<::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) = 0;
};

class Protocol_EventSender {
 public:
  virtual ~Protocol_EventSender();
  virtual void EventBasic(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, ::fidl::StringPtr opt_string) = 0;
  virtual void EventCompound(::test::typesinprotocols::Bits bits, ::test::typesinprotocols::Enum enum_, ::test::typesinprotocols::Struct struct_, ::test::typesinprotocols::Table table, ::test::typesinprotocols::Union union_, ::std::unique_ptr<::test::typesinprotocols::Struct> opt_struct, ::std::unique_ptr<::test::typesinprotocols::Union> opt_union) = 0;
  virtual void EventArrayBasic(::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<::fidl::StringPtr, 5> array_opt_string) = 0;
  virtual void EventArrayCompound(::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<::std::unique_ptr<::test::typesinprotocols::Struct>, 5> array_opt_struct, ::std::array<::std::unique_ptr<::test::typesinprotocols::Union>, 5> array_opt_union) = 0;
  virtual void EventVectorBasic(::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<::fidl::StringPtr> vector_opt_string) = 0;
  virtual void EventVectorCompound(::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<::std::unique_ptr<::test::typesinprotocols::Struct>> vector_opt_struct, ::std::vector<::std::unique_ptr<::test::typesinprotocols::Union>> vector_opt_union) = 0;
  virtual void EventVectorOptional(::fidl::VectorPtr<uint8_t> opt_vector_uint8, ::fidl::VectorPtr<::std::string> opt_vector_string, ::fidl::VectorPtr<::std::unique_ptr<::test::typesinprotocols::Struct>> opt_vector_opt_struct) = 0;
  virtual void EventArrayVectorNested(::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) = 0;
  virtual void EventResource(::zx::handle handle, ::zx::vmo vmo, ::fidl::InterfaceHandle<::test::typesinprotocols::Protocol> client_end, ::fidl::InterfaceRequest<::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::InterfaceHandle<::test::typesinprotocols::Protocol> opt_client_end, ::fidl::InterfaceRequest<::test::typesinprotocols::Protocol> opt_server_end, ::std::unique_ptr<::test::typesinprotocols::ResourceStruct> opt_struct, ::std::unique_ptr<::test::typesinprotocols::ResourceUnion> opt_union, ::std::array<::zx::handle, 5> array_handle, ::std::array<::zx::vmo, 5> array_vmo, ::std::array<::fidl::InterfaceHandle<::test::typesinprotocols::Protocol>, 5> array_client_end, ::std::array<::fidl::InterfaceRequest<::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::InterfaceHandle<::test::typesinprotocols::Protocol>> vector_client_end, ::std::vector<::fidl::InterfaceRequest<::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) = 0;
};

class Protocol_Sync {
 public:
  using Proxy_ = ::test::typesinprotocols::Protocol_SyncProxy;
  virtual ~Protocol_Sync();
  virtual zx_status_t OneWayBasic(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, ::fidl::StringPtr opt_string) = 0;
  virtual zx_status_t TwoWayBasic(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, ::fidl::StringPtr opt_string, uint8_t* out_uint8, uint16_t* out_uint16, uint32_t* out_uint32, uint64_t* out_uint64, int8_t* out_int8, int16_t* out_int16, int32_t* out_int32, int64_t* out_int64, float* out_float32, double* out_float64, ::std::string* out_string, ::fidl::StringPtr* out_opt_string) = 0;
  virtual zx_status_t ErrorBasic(::test::typesinprotocols::Protocol_ErrorBasic_Result* out_Protocol_ErrorBasic_Result) = 0;
  virtual zx_status_t OneWayCompound(::test::typesinprotocols::Bits bits, ::test::typesinprotocols::Enum enum_, ::test::typesinprotocols::Struct struct_, ::test::typesinprotocols::Table table, ::test::typesinprotocols::Union union_, ::std::unique_ptr<::test::typesinprotocols::Struct> opt_struct, ::std::unique_ptr<::test::typesinprotocols::Union> opt_union) = 0;
  virtual zx_status_t TwoWayCompound(::test::typesinprotocols::Bits bits, ::test::typesinprotocols::Enum enum_, ::test::typesinprotocols::Struct struct_, ::test::typesinprotocols::Table table, ::test::typesinprotocols::Union union_, ::std::unique_ptr<::test::typesinprotocols::Struct> opt_struct, ::std::unique_ptr<::test::typesinprotocols::Union> opt_union, ::test::typesinprotocols::Bits* out_bits, ::test::typesinprotocols::Enum* out_enum_, ::test::typesinprotocols::Struct* out_struct_, ::test::typesinprotocols::Table* out_table, ::test::typesinprotocols::Union* out_union_, ::std::unique_ptr<::test::typesinprotocols::Struct>* out_opt_struct, ::std::unique_ptr<::test::typesinprotocols::Union>* out_opt_union) = 0;
  virtual zx_status_t ErrorCompound(::test::typesinprotocols::Protocol_ErrorCompound_Result* out_Protocol_ErrorCompound_Result) = 0;
  virtual zx_status_t OneWayArrayBasic(::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<::fidl::StringPtr, 5> array_opt_string) = 0;
  virtual zx_status_t TwoWayArrayBasic(::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<::fidl::StringPtr, 5> array_opt_string, ::std::array<uint8_t, 5>* out_array_uint8, ::std::array<uint16_t, 5>* out_array_uint16, ::std::array<uint32_t, 5>* out_array_uint32, ::std::array<uint64_t, 5>* out_array_uint64, ::std::array<int8_t, 5>* out_array_int8, ::std::array<int16_t, 5>* out_array_int16, ::std::array<int32_t, 5>* out_array_int32, ::std::array<int64_t, 5>* out_array_int64, ::std::array<float, 5>* out_array_float32, ::std::array<double, 5>* out_array_float64, ::std::array<::std::string, 5>* out_array_string, ::std::array<::fidl::StringPtr, 5>* out_array_opt_string) = 0;
  virtual zx_status_t ErrorArrayBasic(::test::typesinprotocols::Protocol_ErrorArrayBasic_Result* out_Protocol_ErrorArrayBasic_Result) = 0;
  virtual zx_status_t OneWayArrayCompound(::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<::std::unique_ptr<::test::typesinprotocols::Struct>, 5> array_opt_struct, ::std::array<::std::unique_ptr<::test::typesinprotocols::Union>, 5> array_opt_union) = 0;
  virtual zx_status_t TwoWayArrayCompound(::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<::std::unique_ptr<::test::typesinprotocols::Struct>, 5> array_opt_struct, ::std::array<::std::unique_ptr<::test::typesinprotocols::Union>, 5> array_opt_union, ::std::array<::test::typesinprotocols::Bits, 5>* out_array_bits, ::std::array<::test::typesinprotocols::Enum, 5>* out_array_enum, ::std::array<::test::typesinprotocols::Struct, 5>* out_array_struct, ::std::array<::test::typesinprotocols::Table, 5>* out_array_table, ::std::array<::test::typesinprotocols::Union, 5>* out_array_union, ::std::array<::std::unique_ptr<::test::typesinprotocols::Struct>, 5>* out_array_opt_struct, ::std::array<::std::unique_ptr<::test::typesinprotocols::Union>, 5>* out_array_opt_union) = 0;
  virtual zx_status_t ErrorArrayCompound(::test::typesinprotocols::Protocol_ErrorArrayCompound_Result* out_Protocol_ErrorArrayCompound_Result) = 0;
  virtual zx_status_t OneWayVectorBasic(::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<::fidl::StringPtr> vector_opt_string) = 0;
  virtual zx_status_t TwoWayVectorBasic(::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<::fidl::StringPtr> vector_opt_string, ::std::vector<uint8_t>* out_vector_uint8, ::std::vector<uint16_t>* out_vector_uint16, ::std::vector<uint32_t>* out_vector_uint32, ::std::vector<uint64_t>* out_vector_uint64, ::std::vector<int8_t>* out_vector_int8, ::std::vector<int16_t>* out_vector_int16, ::std::vector<int32_t>* out_vector_int32, ::std::vector<int64_t>* out_vector_int64, ::std::vector<float>* out_vector_float32, ::std::vector<double>* out_vector_float64, ::std::vector<::std::string>* out_vector_string, ::std::vector<::fidl::StringPtr>* out_vector_opt_string) = 0;
  virtual zx_status_t ErrorVectorBasic(::test::typesinprotocols::Protocol_ErrorVectorBasic_Result* out_Protocol_ErrorVectorBasic_Result) = 0;
  virtual zx_status_t OneWayVectorCompound(::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<::std::unique_ptr<::test::typesinprotocols::Struct>> vector_opt_struct, ::std::vector<::std::unique_ptr<::test::typesinprotocols::Union>> vector_opt_union) = 0;
  virtual zx_status_t TwoWayVectorCompound(::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<::std::unique_ptr<::test::typesinprotocols::Struct>> vector_opt_struct, ::std::vector<::std::unique_ptr<::test::typesinprotocols::Union>> vector_opt_union, ::std::vector<::test::typesinprotocols::Bits>* out_vector_bits, ::std::vector<::test::typesinprotocols::Enum>* out_vector_enum, ::std::vector<::test::typesinprotocols::Struct>* out_vector_struct, ::std::vector<::test::typesinprotocols::Table>* out_vector_table, ::std::vector<::test::typesinprotocols::Union>* out_vector_union, ::std::vector<::std::unique_ptr<::test::typesinprotocols::Struct>>* out_vector_opt_struct, ::std::vector<::std::unique_ptr<::test::typesinprotocols::Union>>* out_vector_opt_union) = 0;
  virtual zx_status_t ErrorVectorCompound(::test::typesinprotocols::Protocol_ErrorVectorCompound_Result* out_Protocol_ErrorVectorCompound_Result) = 0;
  virtual zx_status_t OneWayVectorOptional(::fidl::VectorPtr<uint8_t> opt_vector_uint8, ::fidl::VectorPtr<::std::string> opt_vector_string, ::fidl::VectorPtr<::std::unique_ptr<::test::typesinprotocols::Struct>> opt_vector_opt_struct) = 0;
  virtual zx_status_t TwoWayVectorOptional(::fidl::VectorPtr<uint8_t> opt_vector_uint8, ::fidl::VectorPtr<::std::string> opt_vector_string, ::fidl::VectorPtr<::std::unique_ptr<::test::typesinprotocols::Struct>> opt_vector_opt_struct, ::fidl::VectorPtr<uint8_t>* out_opt_vector_uint8, ::fidl::VectorPtr<::std::string>* out_opt_vector_string, ::fidl::VectorPtr<::std::unique_ptr<::test::typesinprotocols::Struct>>* out_opt_vector_opt_struct) = 0;
  virtual zx_status_t ErrorVectorOptional(::test::typesinprotocols::Protocol_ErrorVectorOptional_Result* out_Protocol_ErrorVectorOptional_Result) = 0;
  virtual zx_status_t OneWayArrayVectorNested(::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) = 0;
  virtual zx_status_t TwoWayArrayVectorNested(::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, ::std::array<::std::array<uint8_t, 5>, 5>* out_array_array_uint8, ::std::array<::std::vector<uint8_t>, 5>* out_array_vector_uint8, ::std::vector<::std::array<uint8_t, 5>>* out_vector_array_uint8, ::std::vector<::std::vector<uint8_t>>* out_vector_vector_uint8) = 0;
  virtual zx_status_t ErrorArrayVectorNested(::test::typesinprotocols::Protocol_ErrorArrayVectorNested_Result* out_Protocol_ErrorArrayVectorNested_Result) = 0;
  virtual zx_status_t OneWayResource(::zx::handle handle, ::zx::vmo vmo, ::fidl::InterfaceHandle<::test::typesinprotocols::Protocol> client_end, ::fidl::InterfaceRequest<::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::InterfaceHandle<::test::typesinprotocols::Protocol> opt_client_end, ::fidl::InterfaceRequest<::test::typesinprotocols::Protocol> opt_server_end, ::std::unique_ptr<::test::typesinprotocols::ResourceStruct> opt_struct, ::std::unique_ptr<::test::typesinprotocols::ResourceUnion> opt_union, ::std::array<::zx::handle, 5> array_handle, ::std::array<::zx::vmo, 5> array_vmo, ::std::array<::fidl::InterfaceHandle<::test::typesinprotocols::Protocol>, 5> array_client_end, ::std::array<::fidl::InterfaceRequest<::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::InterfaceHandle<::test::typesinprotocols::Protocol>> vector_client_end, ::std::vector<::fidl::InterfaceRequest<::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) = 0;
  virtual zx_status_t TwoWayResource(::zx::handle handle, ::zx::vmo vmo, ::fidl::InterfaceHandle<::test::typesinprotocols::Protocol> client_end, ::fidl::InterfaceRequest<::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::InterfaceHandle<::test::typesinprotocols::Protocol> opt_client_end, ::fidl::InterfaceRequest<::test::typesinprotocols::Protocol> opt_server_end, ::std::unique_ptr<::test::typesinprotocols::ResourceStruct> opt_struct, ::std::unique_ptr<::test::typesinprotocols::ResourceUnion> opt_union, ::std::array<::zx::handle, 5> array_handle, ::std::array<::zx::vmo, 5> array_vmo, ::std::array<::fidl::InterfaceHandle<::test::typesinprotocols::Protocol>, 5> array_client_end, ::std::array<::fidl::InterfaceRequest<::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::InterfaceHandle<::test::typesinprotocols::Protocol>> vector_client_end, ::std::vector<::fidl::InterfaceRequest<::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, ::zx::handle* out_handle, ::zx::vmo* out_vmo, ::fidl::InterfaceHandle<::test::typesinprotocols::Protocol>* out_client_end, ::fidl::InterfaceRequest<::test::typesinprotocols::Protocol>* out_server_end, ::test::typesinprotocols::ResourceStruct* out_struct_, ::test::typesinprotocols::ResourceTable* out_table, ::test::typesinprotocols::ResourceUnion* out_union_, ::zx::handle* out_opt_handle, ::zx::vmo* out_opt_vmo, ::fidl::InterfaceHandle<::test::typesinprotocols::Protocol>* out_opt_client_end, ::fidl::InterfaceRequest<::test::typesinprotocols::Protocol>* out_opt_server_end, ::std::unique_ptr<::test::typesinprotocols::ResourceStruct>* out_opt_struct, ::std::unique_ptr<::test::typesinprotocols::ResourceUnion>* out_opt_union, ::std::array<::zx::handle, 5>* out_array_handle, ::std::array<::zx::vmo, 5>* out_array_vmo, ::std::array<::fidl::InterfaceHandle<::test::typesinprotocols::Protocol>, 5>* out_array_client_end, ::std::array<::fidl::InterfaceRequest<::test::typesinprotocols::Protocol>, 5>* out_array_server_end, ::std::array<::test::typesinprotocols::ResourceStruct, 5>* out_array_struct, ::std::array<::test::typesinprotocols::ResourceTable, 5>* out_array_table, ::std::array<::test::typesinprotocols::ResourceUnion, 5>* out_array_union, ::std::vector<::zx::handle>* out_vector_handle, ::std::vector<::zx::vmo>* out_vector_vmo, ::std::vector<::fidl::InterfaceHandle<::test::typesinprotocols::Protocol>>* out_vector_client_end, ::std::vector<::fidl::InterfaceRequest<::test::typesinprotocols::Protocol>>* out_vector_server_end, ::std::vector<::test::typesinprotocols::ResourceStruct>* out_vector_struct, ::std::vector<::test::typesinprotocols::ResourceTable>* out_vector_table, ::std::vector<::test::typesinprotocols::ResourceUnion>* out_vector_union) = 0;
  virtual zx_status_t ErrorResource(::test::typesinprotocols::Protocol_ErrorResource_Result* out_Protocol_ErrorResource_Result) = 0;
};

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

  zx_status_t Dispatch_(::fidl::HLCPPIncomingMessage message) override;
  // cts-coverage-fidl-name:test.typesinprotocols/Protocol.OneWayBasic
  void OneWayBasic(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, ::fidl::StringPtr opt_string) override;
  // cts-coverage-fidl-name:test.typesinprotocols/Protocol.TwoWayBasic
  void TwoWayBasic(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, ::fidl::StringPtr opt_string, TwoWayBasicCallback callback) override;
  // cts-coverage-fidl-name:test.typesinprotocols/Protocol.ErrorBasic
  void ErrorBasic(ErrorBasicCallback callback) override;
  EventBasicCallback EventBasic;
  // cts-coverage-fidl-name:test.typesinprotocols/Protocol.OneWayCompound
  void OneWayCompound(::test::typesinprotocols::Bits bits, ::test::typesinprotocols::Enum enum_, ::test::typesinprotocols::Struct struct_, ::test::typesinprotocols::Table table, ::test::typesinprotocols::Union union_, ::std::unique_ptr<::test::typesinprotocols::Struct> opt_struct, ::std::unique_ptr<::test::typesinprotocols::Union> opt_union) override;
  // cts-coverage-fidl-name:test.typesinprotocols/Protocol.TwoWayCompound
  void TwoWayCompound(::test::typesinprotocols::Bits bits, ::test::typesinprotocols::Enum enum_, ::test::typesinprotocols::Struct struct_, ::test::typesinprotocols::Table table, ::test::typesinprotocols::Union union_, ::std::unique_ptr<::test::typesinprotocols::Struct> opt_struct, ::std::unique_ptr<::test::typesinprotocols::Union> opt_union, TwoWayCompoundCallback callback) override;
  // cts-coverage-fidl-name:test.typesinprotocols/Protocol.ErrorCompound
  void ErrorCompound(ErrorCompoundCallback callback) override;
  EventCompoundCallback EventCompound;
  // cts-coverage-fidl-name:test.typesinprotocols/Protocol.OneWayArrayBasic
  void OneWayArrayBasic(::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<::fidl::StringPtr, 5> array_opt_string) override;
  // cts-coverage-fidl-name:test.typesinprotocols/Protocol.TwoWayArrayBasic
  void TwoWayArrayBasic(::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<::fidl::StringPtr, 5> array_opt_string, TwoWayArrayBasicCallback callback) override;
  // cts-coverage-fidl-name:test.typesinprotocols/Protocol.ErrorArrayBasic
  void ErrorArrayBasic(ErrorArrayBasicCallback callback) override;
  EventArrayBasicCallback EventArrayBasic;
  // cts-coverage-fidl-name:test.typesinprotocols/Protocol.OneWayArrayCompound
  void OneWayArrayCompound(::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<::std::unique_ptr<::test::typesinprotocols::Struct>, 5> array_opt_struct, ::std::array<::std::unique_ptr<::test::typesinprotocols::Union>, 5> array_opt_union) override;
  // cts-coverage-fidl-name:test.typesinprotocols/Protocol.TwoWayArrayCompound
  void TwoWayArrayCompound(::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<::std::unique_ptr<::test::typesinprotocols::Struct>, 5> array_opt_struct, ::std::array<::std::unique_ptr<::test::typesinprotocols::Union>, 5> array_opt_union, TwoWayArrayCompoundCallback callback) override;
  // cts-coverage-fidl-name:test.typesinprotocols/Protocol.ErrorArrayCompound
  void ErrorArrayCompound(ErrorArrayCompoundCallback callback) override;
  EventArrayCompoundCallback EventArrayCompound;
  // cts-coverage-fidl-name:test.typesinprotocols/Protocol.OneWayVectorBasic
  void OneWayVectorBasic(::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<::fidl::StringPtr> vector_opt_string) override;
  // cts-coverage-fidl-name:test.typesinprotocols/Protocol.TwoWayVectorBasic
  void TwoWayVectorBasic(::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<::fidl::StringPtr> vector_opt_string, TwoWayVectorBasicCallback callback) override;
  // cts-coverage-fidl-name:test.typesinprotocols/Protocol.ErrorVectorBasic
  void ErrorVectorBasic(ErrorVectorBasicCallback callback) override;
  EventVectorBasicCallback EventVectorBasic;
  // cts-coverage-fidl-name:test.typesinprotocols/Protocol.OneWayVectorCompound
  void OneWayVectorCompound(::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<::std::unique_ptr<::test::typesinprotocols::Struct>> vector_opt_struct, ::std::vector<::std::unique_ptr<::test::typesinprotocols::Union>> vector_opt_union) override;
  // cts-coverage-fidl-name:test.typesinprotocols/Protocol.TwoWayVectorCompound
  void TwoWayVectorCompound(::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<::std::unique_ptr<::test::typesinprotocols::Struct>> vector_opt_struct, ::std::vector<::std::unique_ptr<::test::typesinprotocols::Union>> vector_opt_union, TwoWayVectorCompoundCallback callback) override;
  // cts-coverage-fidl-name:test.typesinprotocols/Protocol.ErrorVectorCompound
  void ErrorVectorCompound(ErrorVectorCompoundCallback callback) override;
  EventVectorCompoundCallback EventVectorCompound;
  // cts-coverage-fidl-name:test.typesinprotocols/Protocol.OneWayVectorOptional
  void OneWayVectorOptional(::fidl::VectorPtr<uint8_t> opt_vector_uint8, ::fidl::VectorPtr<::std::string> opt_vector_string, ::fidl::VectorPtr<::std::unique_ptr<::test::typesinprotocols::Struct>> opt_vector_opt_struct) override;
  // cts-coverage-fidl-name:test.typesinprotocols/Protocol.TwoWayVectorOptional
  void TwoWayVectorOptional(::fidl::VectorPtr<uint8_t> opt_vector_uint8, ::fidl::VectorPtr<::std::string> opt_vector_string, ::fidl::VectorPtr<::std::unique_ptr<::test::typesinprotocols::Struct>> opt_vector_opt_struct, TwoWayVectorOptionalCallback callback) override;
  // cts-coverage-fidl-name:test.typesinprotocols/Protocol.ErrorVectorOptional
  void ErrorVectorOptional(ErrorVectorOptionalCallback callback) override;
  EventVectorOptionalCallback EventVectorOptional;
  // cts-coverage-fidl-name:test.typesinprotocols/Protocol.OneWayArrayVectorNested
  void OneWayArrayVectorNested(::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) override;
  // cts-coverage-fidl-name:test.typesinprotocols/Protocol.TwoWayArrayVectorNested
  void TwoWayArrayVectorNested(::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, TwoWayArrayVectorNestedCallback callback) override;
  // cts-coverage-fidl-name:test.typesinprotocols/Protocol.ErrorArrayVectorNested
  void ErrorArrayVectorNested(ErrorArrayVectorNestedCallback callback) override;
  EventArrayVectorNestedCallback EventArrayVectorNested;
  // cts-coverage-fidl-name:test.typesinprotocols/Protocol.OneWayResource
  void OneWayResource(::zx::handle handle, ::zx::vmo vmo, ::fidl::InterfaceHandle<::test::typesinprotocols::Protocol> client_end, ::fidl::InterfaceRequest<::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::InterfaceHandle<::test::typesinprotocols::Protocol> opt_client_end, ::fidl::InterfaceRequest<::test::typesinprotocols::Protocol> opt_server_end, ::std::unique_ptr<::test::typesinprotocols::ResourceStruct> opt_struct, ::std::unique_ptr<::test::typesinprotocols::ResourceUnion> opt_union, ::std::array<::zx::handle, 5> array_handle, ::std::array<::zx::vmo, 5> array_vmo, ::std::array<::fidl::InterfaceHandle<::test::typesinprotocols::Protocol>, 5> array_client_end, ::std::array<::fidl::InterfaceRequest<::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::InterfaceHandle<::test::typesinprotocols::Protocol>> vector_client_end, ::std::vector<::fidl::InterfaceRequest<::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) override;
  // cts-coverage-fidl-name:test.typesinprotocols/Protocol.TwoWayResource
  void TwoWayResource(::zx::handle handle, ::zx::vmo vmo, ::fidl::InterfaceHandle<::test::typesinprotocols::Protocol> client_end, ::fidl::InterfaceRequest<::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::InterfaceHandle<::test::typesinprotocols::Protocol> opt_client_end, ::fidl::InterfaceRequest<::test::typesinprotocols::Protocol> opt_server_end, ::std::unique_ptr<::test::typesinprotocols::ResourceStruct> opt_struct, ::std::unique_ptr<::test::typesinprotocols::ResourceUnion> opt_union, ::std::array<::zx::handle, 5> array_handle, ::std::array<::zx::vmo, 5> array_vmo, ::std::array<::fidl::InterfaceHandle<::test::typesinprotocols::Protocol>, 5> array_client_end, ::std::array<::fidl::InterfaceRequest<::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::InterfaceHandle<::test::typesinprotocols::Protocol>> vector_client_end, ::std::vector<::fidl::InterfaceRequest<::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, TwoWayResourceCallback callback) override;
  // cts-coverage-fidl-name:test.typesinprotocols/Protocol.ErrorResource
  void ErrorResource(ErrorResourceCallback callback) override;
  EventResourceCallback EventResource;

  
 private:
  Protocol_Proxy(const ::test::typesinprotocols::Protocol_Proxy&) = delete;
  Protocol_Proxy& operator=(const ::test::typesinprotocols::Protocol_Proxy&) = delete;

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

class Protocol_Stub final : public ::fidl::internal::Stub, public ::test::typesinprotocols::Protocol_EventSender {
 public:
  typedef class ::test::typesinprotocols::Protocol Protocol_clazz;
  explicit Protocol_Stub(::test::typesinprotocols::Protocol_Stub::Protocol_clazz* impl);
  ~Protocol_Stub() override;

  zx_status_t Dispatch_(::fidl::HLCPPIncomingMessage message,
                        ::fidl::internal::PendingResponse response) override;
  void EventBasic(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, ::fidl::StringPtr opt_string) override;
  void EventCompound(::test::typesinprotocols::Bits bits, ::test::typesinprotocols::Enum enum_, ::test::typesinprotocols::Struct struct_, ::test::typesinprotocols::Table table, ::test::typesinprotocols::Union union_, ::std::unique_ptr<::test::typesinprotocols::Struct> opt_struct, ::std::unique_ptr<::test::typesinprotocols::Union> opt_union) override;
  void EventArrayBasic(::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<::fidl::StringPtr, 5> array_opt_string) override;
  void EventArrayCompound(::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<::std::unique_ptr<::test::typesinprotocols::Struct>, 5> array_opt_struct, ::std::array<::std::unique_ptr<::test::typesinprotocols::Union>, 5> array_opt_union) override;
  void EventVectorBasic(::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<::fidl::StringPtr> vector_opt_string) override;
  void EventVectorCompound(::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<::std::unique_ptr<::test::typesinprotocols::Struct>> vector_opt_struct, ::std::vector<::std::unique_ptr<::test::typesinprotocols::Union>> vector_opt_union) override;
  void EventVectorOptional(::fidl::VectorPtr<uint8_t> opt_vector_uint8, ::fidl::VectorPtr<::std::string> opt_vector_string, ::fidl::VectorPtr<::std::unique_ptr<::test::typesinprotocols::Struct>> opt_vector_opt_struct) override;
  void EventArrayVectorNested(::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) override;
  void EventResource(::zx::handle handle, ::zx::vmo vmo, ::fidl::InterfaceHandle<::test::typesinprotocols::Protocol> client_end, ::fidl::InterfaceRequest<::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::InterfaceHandle<::test::typesinprotocols::Protocol> opt_client_end, ::fidl::InterfaceRequest<::test::typesinprotocols::Protocol> opt_server_end, ::std::unique_ptr<::test::typesinprotocols::ResourceStruct> opt_struct, ::std::unique_ptr<::test::typesinprotocols::ResourceUnion> opt_union, ::std::array<::zx::handle, 5> array_handle, ::std::array<::zx::vmo, 5> array_vmo, ::std::array<::fidl::InterfaceHandle<::test::typesinprotocols::Protocol>, 5> array_client_end, ::std::array<::fidl::InterfaceRequest<::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::InterfaceHandle<::test::typesinprotocols::Protocol>> vector_client_end, ::std::vector<::fidl::InterfaceRequest<::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) override;

 private:
  ::test::typesinprotocols::Protocol_Stub::Protocol_clazz* impl_;
};

class Protocol_SyncProxy : public ::test::typesinprotocols::Protocol_Sync {
 public:
  explicit Protocol_SyncProxy(::zx::channel channel);
  ~Protocol_SyncProxy() override;
  // cts-coverage-fidl-name:test.typesinprotocols/Protocol.OneWayBasic
  zx_status_t OneWayBasic(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, ::fidl::StringPtr opt_string) override;
  // cts-coverage-fidl-name:test.typesinprotocols/Protocol.TwoWayBasic
  zx_status_t TwoWayBasic(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, ::fidl::StringPtr opt_string, uint8_t* out_uint8, uint16_t* out_uint16, uint32_t* out_uint32, uint64_t* out_uint64, int8_t* out_int8, int16_t* out_int16, int32_t* out_int32, int64_t* out_int64, float* out_float32, double* out_float64, ::std::string* out_string, ::fidl::StringPtr* out_opt_string) override;
  // cts-coverage-fidl-name:test.typesinprotocols/Protocol.ErrorBasic
  zx_status_t ErrorBasic(::test::typesinprotocols::Protocol_ErrorBasic_Result* out_Protocol_ErrorBasic_Result) override;
  // cts-coverage-fidl-name:test.typesinprotocols/Protocol.OneWayCompound
  zx_status_t OneWayCompound(::test::typesinprotocols::Bits bits, ::test::typesinprotocols::Enum enum_, ::test::typesinprotocols::Struct struct_, ::test::typesinprotocols::Table table, ::test::typesinprotocols::Union union_, ::std::unique_ptr<::test::typesinprotocols::Struct> opt_struct, ::std::unique_ptr<::test::typesinprotocols::Union> opt_union) override;
  // cts-coverage-fidl-name:test.typesinprotocols/Protocol.TwoWayCompound
  zx_status_t TwoWayCompound(::test::typesinprotocols::Bits bits, ::test::typesinprotocols::Enum enum_, ::test::typesinprotocols::Struct struct_, ::test::typesinprotocols::Table table, ::test::typesinprotocols::Union union_, ::std::unique_ptr<::test::typesinprotocols::Struct> opt_struct, ::std::unique_ptr<::test::typesinprotocols::Union> opt_union, ::test::typesinprotocols::Bits* out_bits, ::test::typesinprotocols::Enum* out_enum_, ::test::typesinprotocols::Struct* out_struct_, ::test::typesinprotocols::Table* out_table, ::test::typesinprotocols::Union* out_union_, ::std::unique_ptr<::test::typesinprotocols::Struct>* out_opt_struct, ::std::unique_ptr<::test::typesinprotocols::Union>* out_opt_union) override;
  // cts-coverage-fidl-name:test.typesinprotocols/Protocol.ErrorCompound
  zx_status_t ErrorCompound(::test::typesinprotocols::Protocol_ErrorCompound_Result* out_Protocol_ErrorCompound_Result) override;
  // cts-coverage-fidl-name:test.typesinprotocols/Protocol.OneWayArrayBasic
  zx_status_t OneWayArrayBasic(::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<::fidl::StringPtr, 5> array_opt_string) override;
  // cts-coverage-fidl-name:test.typesinprotocols/Protocol.TwoWayArrayBasic
  zx_status_t TwoWayArrayBasic(::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<::fidl::StringPtr, 5> array_opt_string, ::std::array<uint8_t, 5>* out_array_uint8, ::std::array<uint16_t, 5>* out_array_uint16, ::std::array<uint32_t, 5>* out_array_uint32, ::std::array<uint64_t, 5>* out_array_uint64, ::std::array<int8_t, 5>* out_array_int8, ::std::array<int16_t, 5>* out_array_int16, ::std::array<int32_t, 5>* out_array_int32, ::std::array<int64_t, 5>* out_array_int64, ::std::array<float, 5>* out_array_float32, ::std::array<double, 5>* out_array_float64, ::std::array<::std::string, 5>* out_array_string, ::std::array<::fidl::StringPtr, 5>* out_array_opt_string) override;
  // cts-coverage-fidl-name:test.typesinprotocols/Protocol.ErrorArrayBasic
  zx_status_t ErrorArrayBasic(::test::typesinprotocols::Protocol_ErrorArrayBasic_Result* out_Protocol_ErrorArrayBasic_Result) override;
  // cts-coverage-fidl-name:test.typesinprotocols/Protocol.OneWayArrayCompound
  zx_status_t OneWayArrayCompound(::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<::std::unique_ptr<::test::typesinprotocols::Struct>, 5> array_opt_struct, ::std::array<::std::unique_ptr<::test::typesinprotocols::Union>, 5> array_opt_union) override;
  // cts-coverage-fidl-name:test.typesinprotocols/Protocol.TwoWayArrayCompound
  zx_status_t TwoWayArrayCompound(::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<::std::unique_ptr<::test::typesinprotocols::Struct>, 5> array_opt_struct, ::std::array<::std::unique_ptr<::test::typesinprotocols::Union>, 5> array_opt_union, ::std::array<::test::typesinprotocols::Bits, 5>* out_array_bits, ::std::array<::test::typesinprotocols::Enum, 5>* out_array_enum, ::std::array<::test::typesinprotocols::Struct, 5>* out_array_struct, ::std::array<::test::typesinprotocols::Table, 5>* out_array_table, ::std::array<::test::typesinprotocols::Union, 5>* out_array_union, ::std::array<::std::unique_ptr<::test::typesinprotocols::Struct>, 5>* out_array_opt_struct, ::std::array<::std::unique_ptr<::test::typesinprotocols::Union>, 5>* out_array_opt_union) override;
  // cts-coverage-fidl-name:test.typesinprotocols/Protocol.ErrorArrayCompound
  zx_status_t ErrorArrayCompound(::test::typesinprotocols::Protocol_ErrorArrayCompound_Result* out_Protocol_ErrorArrayCompound_Result) override;
  // cts-coverage-fidl-name:test.typesinprotocols/Protocol.OneWayVectorBasic
  zx_status_t OneWayVectorBasic(::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<::fidl::StringPtr> vector_opt_string) override;
  // cts-coverage-fidl-name:test.typesinprotocols/Protocol.TwoWayVectorBasic
  zx_status_t TwoWayVectorBasic(::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<::fidl::StringPtr> vector_opt_string, ::std::vector<uint8_t>* out_vector_uint8, ::std::vector<uint16_t>* out_vector_uint16, ::std::vector<uint32_t>* out_vector_uint32, ::std::vector<uint64_t>* out_vector_uint64, ::std::vector<int8_t>* out_vector_int8, ::std::vector<int16_t>* out_vector_int16, ::std::vector<int32_t>* out_vector_int32, ::std::vector<int64_t>* out_vector_int64, ::std::vector<float>* out_vector_float32, ::std::vector<double>* out_vector_float64, ::std::vector<::std::string>* out_vector_string, ::std::vector<::fidl::StringPtr>* out_vector_opt_string) override;
  // cts-coverage-fidl-name:test.typesinprotocols/Protocol.ErrorVectorBasic
  zx_status_t ErrorVectorBasic(::test::typesinprotocols::Protocol_ErrorVectorBasic_Result* out_Protocol_ErrorVectorBasic_Result) override;
  // cts-coverage-fidl-name:test.typesinprotocols/Protocol.OneWayVectorCompound
  zx_status_t OneWayVectorCompound(::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<::std::unique_ptr<::test::typesinprotocols::Struct>> vector_opt_struct, ::std::vector<::std::unique_ptr<::test::typesinprotocols::Union>> vector_opt_union) override;
  // cts-coverage-fidl-name:test.typesinprotocols/Protocol.TwoWayVectorCompound
  zx_status_t TwoWayVectorCompound(::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<::std::unique_ptr<::test::typesinprotocols::Struct>> vector_opt_struct, ::std::vector<::std::unique_ptr<::test::typesinprotocols::Union>> vector_opt_union, ::std::vector<::test::typesinprotocols::Bits>* out_vector_bits, ::std::vector<::test::typesinprotocols::Enum>* out_vector_enum, ::std::vector<::test::typesinprotocols::Struct>* out_vector_struct, ::std::vector<::test::typesinprotocols::Table>* out_vector_table, ::std::vector<::test::typesinprotocols::Union>* out_vector_union, ::std::vector<::std::unique_ptr<::test::typesinprotocols::Struct>>* out_vector_opt_struct, ::std::vector<::std::unique_ptr<::test::typesinprotocols::Union>>* out_vector_opt_union) override;
  // cts-coverage-fidl-name:test.typesinprotocols/Protocol.ErrorVectorCompound
  zx_status_t ErrorVectorCompound(::test::typesinprotocols::Protocol_ErrorVectorCompound_Result* out_Protocol_ErrorVectorCompound_Result) override;
  // cts-coverage-fidl-name:test.typesinprotocols/Protocol.OneWayVectorOptional
  zx_status_t OneWayVectorOptional(::fidl::VectorPtr<uint8_t> opt_vector_uint8, ::fidl::VectorPtr<::std::string> opt_vector_string, ::fidl::VectorPtr<::std::unique_ptr<::test::typesinprotocols::Struct>> opt_vector_opt_struct) override;
  // cts-coverage-fidl-name:test.typesinprotocols/Protocol.TwoWayVectorOptional
  zx_status_t TwoWayVectorOptional(::fidl::VectorPtr<uint8_t> opt_vector_uint8, ::fidl::VectorPtr<::std::string> opt_vector_string, ::fidl::VectorPtr<::std::unique_ptr<::test::typesinprotocols::Struct>> opt_vector_opt_struct, ::fidl::VectorPtr<uint8_t>* out_opt_vector_uint8, ::fidl::VectorPtr<::std::string>* out_opt_vector_string, ::fidl::VectorPtr<::std::unique_ptr<::test::typesinprotocols::Struct>>* out_opt_vector_opt_struct) override;
  // cts-coverage-fidl-name:test.typesinprotocols/Protocol.ErrorVectorOptional
  zx_status_t ErrorVectorOptional(::test::typesinprotocols::Protocol_ErrorVectorOptional_Result* out_Protocol_ErrorVectorOptional_Result) override;
  // cts-coverage-fidl-name:test.typesinprotocols/Protocol.OneWayArrayVectorNested
  zx_status_t OneWayArrayVectorNested(::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) override;
  // cts-coverage-fidl-name:test.typesinprotocols/Protocol.TwoWayArrayVectorNested
  zx_status_t TwoWayArrayVectorNested(::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, ::std::array<::std::array<uint8_t, 5>, 5>* out_array_array_uint8, ::std::array<::std::vector<uint8_t>, 5>* out_array_vector_uint8, ::std::vector<::std::array<uint8_t, 5>>* out_vector_array_uint8, ::std::vector<::std::vector<uint8_t>>* out_vector_vector_uint8) override;
  // cts-coverage-fidl-name:test.typesinprotocols/Protocol.ErrorArrayVectorNested
  zx_status_t ErrorArrayVectorNested(::test::typesinprotocols::Protocol_ErrorArrayVectorNested_Result* out_Protocol_ErrorArrayVectorNested_Result) override;
  // cts-coverage-fidl-name:test.typesinprotocols/Protocol.OneWayResource
  zx_status_t OneWayResource(::zx::handle handle, ::zx::vmo vmo, ::fidl::InterfaceHandle<::test::typesinprotocols::Protocol> client_end, ::fidl::InterfaceRequest<::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::InterfaceHandle<::test::typesinprotocols::Protocol> opt_client_end, ::fidl::InterfaceRequest<::test::typesinprotocols::Protocol> opt_server_end, ::std::unique_ptr<::test::typesinprotocols::ResourceStruct> opt_struct, ::std::unique_ptr<::test::typesinprotocols::ResourceUnion> opt_union, ::std::array<::zx::handle, 5> array_handle, ::std::array<::zx::vmo, 5> array_vmo, ::std::array<::fidl::InterfaceHandle<::test::typesinprotocols::Protocol>, 5> array_client_end, ::std::array<::fidl::InterfaceRequest<::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::InterfaceHandle<::test::typesinprotocols::Protocol>> vector_client_end, ::std::vector<::fidl::InterfaceRequest<::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) override;
  // cts-coverage-fidl-name:test.typesinprotocols/Protocol.TwoWayResource
  zx_status_t TwoWayResource(::zx::handle handle, ::zx::vmo vmo, ::fidl::InterfaceHandle<::test::typesinprotocols::Protocol> client_end, ::fidl::InterfaceRequest<::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::InterfaceHandle<::test::typesinprotocols::Protocol> opt_client_end, ::fidl::InterfaceRequest<::test::typesinprotocols::Protocol> opt_server_end, ::std::unique_ptr<::test::typesinprotocols::ResourceStruct> opt_struct, ::std::unique_ptr<::test::typesinprotocols::ResourceUnion> opt_union, ::std::array<::zx::handle, 5> array_handle, ::std::array<::zx::vmo, 5> array_vmo, ::std::array<::fidl::InterfaceHandle<::test::typesinprotocols::Protocol>, 5> array_client_end, ::std::array<::fidl::InterfaceRequest<::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::InterfaceHandle<::test::typesinprotocols::Protocol>> vector_client_end, ::std::vector<::fidl::InterfaceRequest<::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, ::zx::handle* out_handle, ::zx::vmo* out_vmo, ::fidl::InterfaceHandle<::test::typesinprotocols::Protocol>* out_client_end, ::fidl::InterfaceRequest<::test::typesinprotocols::Protocol>* out_server_end, ::test::typesinprotocols::ResourceStruct* out_struct_, ::test::typesinprotocols::ResourceTable* out_table, ::test::typesinprotocols::ResourceUnion* out_union_, ::zx::handle* out_opt_handle, ::zx::vmo* out_opt_vmo, ::fidl::InterfaceHandle<::test::typesinprotocols::Protocol>* out_opt_client_end, ::fidl::InterfaceRequest<::test::typesinprotocols::Protocol>* out_opt_server_end, ::std::unique_ptr<::test::typesinprotocols::ResourceStruct>* out_opt_struct, ::std::unique_ptr<::test::typesinprotocols::ResourceUnion>* out_opt_union, ::std::array<::zx::handle, 5>* out_array_handle, ::std::array<::zx::vmo, 5>* out_array_vmo, ::std::array<::fidl::InterfaceHandle<::test::typesinprotocols::Protocol>, 5>* out_array_client_end, ::std::array<::fidl::InterfaceRequest<::test::typesinprotocols::Protocol>, 5>* out_array_server_end, ::std::array<::test::typesinprotocols::ResourceStruct, 5>* out_array_struct, ::std::array<::test::typesinprotocols::ResourceTable, 5>* out_array_table, ::std::array<::test::typesinprotocols::ResourceUnion, 5>* out_array_union, ::std::vector<::zx::handle>* out_vector_handle, ::std::vector<::zx::vmo>* out_vector_vmo, ::std::vector<::fidl::InterfaceHandle<::test::typesinprotocols::Protocol>>* out_vector_client_end, ::std::vector<::fidl::InterfaceRequest<::test::typesinprotocols::Protocol>>* out_vector_server_end, ::std::vector<::test::typesinprotocols::ResourceStruct>* out_vector_struct, ::std::vector<::test::typesinprotocols::ResourceTable>* out_vector_table, ::std::vector<::test::typesinprotocols::ResourceUnion>* out_vector_union) override;
  // cts-coverage-fidl-name:test.typesinprotocols/Protocol.ErrorResource
  zx_status_t ErrorResource(::test::typesinprotocols::Protocol_ErrorResource_Result* out_Protocol_ErrorResource_Result) override;

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

#endif  // __Fuchsia__

}  // namespace typesinprotocols
}  // namespace test