// 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 protocollayoutssamelibrary {


//
// Domain objects declarations
//


class TablePayload;


class UnionPayload;


class ComposedProtocolOneWayAnonComposedRequest;


class ComposedProtocolTwoWayAnonComposedRequest;


class ComposedProtocolTwoWayAnonComposedResponse;


class ComposedProtocolTwoWayAnonComposedWithErrorRequest;


class ComposedProtocol_TwoWayAnonComposedWithError_Response;


class ComposedProtocol_TwoWayAnonComposedWithError_Result;


class ComposedProtocolOnAnonComposedRequest;


class ComposedProtocol_TwoWayNamedComposedWithError_Result;


#ifdef __Fuchsia__

class ComposedProtocol;
using ComposedProtocolHandle = ::fidl::InterfaceHandle<ComposedProtocol>;

#endif  // __Fuchsia__


class MainProtocol_TwoWayLocalWithError_Result;


class MainProtocolOneWayAnonRequest;


class MainProtocolTwoWayAnonRequest;


class MainProtocolTwoWayAnonResponse;


class MainProtocolTwoWayAnonWithErrorRequest;


class MainProtocol_TwoWayAnonWithError_Response;


class MainProtocol_TwoWayAnonWithError_Result;


class MainProtocolOnAnonRequest;


#ifdef __Fuchsia__

class MainProtocol;
using MainProtocolHandle = ::fidl::InterfaceHandle<MainProtocol>;

#endif  // __Fuchsia__


class TablePayload final {
 public:
  static const fidl_type_t* FidlType;
  /// Returns whether no field is set.
  bool IsEmpty() const;
  
  const uint16_t& a() const {
    ZX_ASSERT(field_presence_.IsSet<0>());
    return a_value_.value;
  }
  bool has_a() const {
    return field_presence_.IsSet<0>();
  }
  
  uint16_t* mutable_a() {
    if (!field_presence_.IsSet<0>()) {
      field_presence_.Set<0>();
      Construct(&a_value_.value);
    }
    return &a_value_.value;
  }
  TablePayload& set_a(uint16_t _value);
  void clear_a() {
    if (!field_presence_.IsSet<0>()) {
      return;
    }
    field_presence_.Clear<0>();
    Destruct(&a_value_.value);
  }

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

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

  void Encode(::fidl::Encoder* _encoder, size_t _offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, TablePayload* _value, size_t _offset);
  zx_status_t Clone(TablePayload* _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) {
    case 1:
      return true;
    default:
      return false;
    }
  }

  ::fidl::internal::BitSet<1> field_presence_;
  union ValueUnion_a {
    ValueUnion_a() {}
    ~ValueUnion_a() {}

    uint16_t value;
  };
  ValueUnion_a a_value_;
};

using TablePayloadPtr = ::std::unique_ptr<TablePayload>;


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

  UnionPayload();
  ~UnionPayload();

  UnionPayload(UnionPayload&&);
  UnionPayload& operator=(UnionPayload&&);

  
  static UnionPayload WithB(bool&&);

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

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

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

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

  bool is_b() const { return tag_ == ::test::protocollayoutssamelibrary::UnionPayload::Tag::kB; }
  
  bool& b() {
    EnsureStorageInitialized(::test::protocollayoutssamelibrary::UnionPayload::Tag::kB);
    return b_;
  }
  
  const bool& b() const {
    ZX_ASSERT(is_b());
    return b_;
  }
  UnionPayload& set_b(bool value);

  ::test::protocollayoutssamelibrary::UnionPayload::Tag Which() const {
    
    return ::test::protocollayoutssamelibrary::UnionPayload::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::protocollayoutssamelibrary::UnionPayload>;

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

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::protocollayoutssamelibrary::UnionPayload::Tag::Invalid);
  union {
    bool b_;
  };
};

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

using UnionPayloadPtr = ::std::unique_ptr<UnionPayload>;


class ComposedProtocolOneWayAnonComposedRequest final {
 public:
  static const fidl_type_t* FidlType;
  /// Returns whether no field is set.
  bool IsEmpty() const;
  
  const uint16_t& a() const {
    ZX_ASSERT(field_presence_.IsSet<0>());
    return a_value_.value;
  }
  bool has_a() const {
    return field_presence_.IsSet<0>();
  }
  
  uint16_t* mutable_a() {
    if (!field_presence_.IsSet<0>()) {
      field_presence_.Set<0>();
      Construct(&a_value_.value);
    }
    return &a_value_.value;
  }
  ComposedProtocolOneWayAnonComposedRequest& set_a(uint16_t _value);
  void clear_a() {
    if (!field_presence_.IsSet<0>()) {
      return;
    }
    field_presence_.Clear<0>();
    Destruct(&a_value_.value);
  }

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

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

  void Encode(::fidl::Encoder* _encoder, size_t _offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, ComposedProtocolOneWayAnonComposedRequest* _value, size_t _offset);
  zx_status_t Clone(ComposedProtocolOneWayAnonComposedRequest* _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) {
    case 1:
      return true;
    default:
      return false;
    }
  }

  ::fidl::internal::BitSet<1> field_presence_;
  union ValueUnion_a {
    ValueUnion_a() {}
    ~ValueUnion_a() {}

    uint16_t value;
  };
  ValueUnion_a a_value_;
};

using ComposedProtocolOneWayAnonComposedRequestPtr = ::std::unique_ptr<ComposedProtocolOneWayAnonComposedRequest>;


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

  ComposedProtocolTwoWayAnonComposedRequest();
  ~ComposedProtocolTwoWayAnonComposedRequest();

  ComposedProtocolTwoWayAnonComposedRequest(ComposedProtocolTwoWayAnonComposedRequest&&);
  ComposedProtocolTwoWayAnonComposedRequest& operator=(ComposedProtocolTwoWayAnonComposedRequest&&);

  
  static ComposedProtocolTwoWayAnonComposedRequest WithB(bool&&);

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

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

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

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

  bool is_b() const { return tag_ == ::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedRequest::Tag::kB; }
  
  bool& b() {
    EnsureStorageInitialized(::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedRequest::Tag::kB);
    return b_;
  }
  
  const bool& b() const {
    ZX_ASSERT(is_b());
    return b_;
  }
  ComposedProtocolTwoWayAnonComposedRequest& set_b(bool value);

  ::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedRequest::Tag Which() const {
    
    return ::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedRequest::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::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedRequest>;

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

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedRequest::Tag::Invalid);
  union {
    bool b_;
  };
};

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

using ComposedProtocolTwoWayAnonComposedRequestPtr = ::std::unique_ptr<ComposedProtocolTwoWayAnonComposedRequest>;


class ComposedProtocolTwoWayAnonComposedResponse final {
 public:
  static const fidl_type_t* FidlType;
  /// Returns whether no field is set.
  bool IsEmpty() const;
  
  const uint16_t& a() const {
    ZX_ASSERT(field_presence_.IsSet<0>());
    return a_value_.value;
  }
  bool has_a() const {
    return field_presence_.IsSet<0>();
  }
  
  uint16_t* mutable_a() {
    if (!field_presence_.IsSet<0>()) {
      field_presence_.Set<0>();
      Construct(&a_value_.value);
    }
    return &a_value_.value;
  }
  ComposedProtocolTwoWayAnonComposedResponse& set_a(uint16_t _value);
  void clear_a() {
    if (!field_presence_.IsSet<0>()) {
      return;
    }
    field_presence_.Clear<0>();
    Destruct(&a_value_.value);
  }

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

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

  void Encode(::fidl::Encoder* _encoder, size_t _offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, ComposedProtocolTwoWayAnonComposedResponse* _value, size_t _offset);
  zx_status_t Clone(ComposedProtocolTwoWayAnonComposedResponse* _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) {
    case 1:
      return true;
    default:
      return false;
    }
  }

  ::fidl::internal::BitSet<1> field_presence_;
  union ValueUnion_a {
    ValueUnion_a() {}
    ~ValueUnion_a() {}

    uint16_t value;
  };
  ValueUnion_a a_value_;
};

using ComposedProtocolTwoWayAnonComposedResponsePtr = ::std::unique_ptr<ComposedProtocolTwoWayAnonComposedResponse>;


class ComposedProtocolTwoWayAnonComposedWithErrorRequest final {
 public:
  static const fidl_type_t* FidlType;
  /// Returns whether no field is set.
  bool IsEmpty() const;
  
  const uint16_t& a() const {
    ZX_ASSERT(field_presence_.IsSet<0>());
    return a_value_.value;
  }
  bool has_a() const {
    return field_presence_.IsSet<0>();
  }
  
  uint16_t* mutable_a() {
    if (!field_presence_.IsSet<0>()) {
      field_presence_.Set<0>();
      Construct(&a_value_.value);
    }
    return &a_value_.value;
  }
  ComposedProtocolTwoWayAnonComposedWithErrorRequest& set_a(uint16_t _value);
  void clear_a() {
    if (!field_presence_.IsSet<0>()) {
      return;
    }
    field_presence_.Clear<0>();
    Destruct(&a_value_.value);
  }

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

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

  void Encode(::fidl::Encoder* _encoder, size_t _offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, ComposedProtocolTwoWayAnonComposedWithErrorRequest* _value, size_t _offset);
  zx_status_t Clone(ComposedProtocolTwoWayAnonComposedWithErrorRequest* _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) {
    case 1:
      return true;
    default:
      return false;
    }
  }

  ::fidl::internal::BitSet<1> field_presence_;
  union ValueUnion_a {
    ValueUnion_a() {}
    ~ValueUnion_a() {}

    uint16_t value;
  };
  ValueUnion_a a_value_;
};

using ComposedProtocolTwoWayAnonComposedWithErrorRequestPtr = ::std::unique_ptr<ComposedProtocolTwoWayAnonComposedWithErrorRequest>;


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

  ComposedProtocol_TwoWayAnonComposedWithError_Response();
  ~ComposedProtocol_TwoWayAnonComposedWithError_Response();

  ComposedProtocol_TwoWayAnonComposedWithError_Response(ComposedProtocol_TwoWayAnonComposedWithError_Response&&);
  ComposedProtocol_TwoWayAnonComposedWithError_Response& operator=(ComposedProtocol_TwoWayAnonComposedWithError_Response&&);

  
  static ComposedProtocol_TwoWayAnonComposedWithError_Response WithB(bool&&);

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

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

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

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

  bool is_b() const { return tag_ == ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Response::Tag::kB; }
  
  bool& b() {
    EnsureStorageInitialized(::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Response::Tag::kB);
    return b_;
  }
  
  const bool& b() const {
    ZX_ASSERT(is_b());
    return b_;
  }
  ComposedProtocol_TwoWayAnonComposedWithError_Response& set_b(bool value);

  ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Response::Tag Which() const {
    
    return ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Response::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::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Response>;

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

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Response::Tag::Invalid);
  union {
    bool b_;
  };
};

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

using ComposedProtocol_TwoWayAnonComposedWithError_ResponsePtr = ::std::unique_ptr<ComposedProtocol_TwoWayAnonComposedWithError_Response>;


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

  ComposedProtocol_TwoWayAnonComposedWithError_Result();
  ~ComposedProtocol_TwoWayAnonComposedWithError_Result();

  ComposedProtocol_TwoWayAnonComposedWithError_Result(ComposedProtocol_TwoWayAnonComposedWithError_Result&&);
  ComposedProtocol_TwoWayAnonComposedWithError_Result& operator=(ComposedProtocol_TwoWayAnonComposedWithError_Result&&);

  
  static ComposedProtocol_TwoWayAnonComposedWithError_Result WithResponse(::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Response&&);
  static ComposedProtocol_TwoWayAnonComposedWithError_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<ComposedProtocol_TwoWayAnonComposedWithError_Result> New() { return ::std::make_unique<ComposedProtocol_TwoWayAnonComposedWithError_Result>(); }

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

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

  bool is_response() const { return tag_ == ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Result::Tag::kResponse; }
  
  ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Response& response() {
    EnsureStorageInitialized(::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Result::Tag::kResponse);
    return response_;
  }
  
  const ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Response& response() const {
    ZX_ASSERT(is_response());
    return response_;
  }
  ComposedProtocol_TwoWayAnonComposedWithError_Result& set_response(::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Response value);

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

  ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Result::Tag Which() const {
    
    return ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_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::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Result>;
  ComposedProtocol_TwoWayAnonComposedWithError_Result(fpromise::ok_result<::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Response>&& result) {
    set_response(::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Response{std::move(result.value)});
  }
  ComposedProtocol_TwoWayAnonComposedWithError_Result(fpromise::error_result<uint32_t>&& result) {
      set_err(std::move(result.error));
  }
  ComposedProtocol_TwoWayAnonComposedWithError_Result(fpromise::result<::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Response, uint32_t>&& result) {
    ZX_ASSERT(!result.is_pending());
    if (result.is_ok()) {
      set_response(::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Response{result.take_value()});
    } else {
      set_err(result.take_error());
    }
  }
  operator fpromise::result<::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Response, uint32_t>() && {
    if (is_err()) {
      return fpromise::error(err());
    }
    ::std::tuple<::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Response> value_tuple = std::move(response());
    return fpromise::ok(std::move(std::get<0>(value_tuple)));
  }

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

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Result::Tag::Invalid);
  union {
    ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Response response_;
    uint32_t err_;
  };
};

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

using ComposedProtocol_TwoWayAnonComposedWithError_ResultPtr = ::std::unique_ptr<ComposedProtocol_TwoWayAnonComposedWithError_Result>;


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

  ComposedProtocolOnAnonComposedRequest();
  ~ComposedProtocolOnAnonComposedRequest();

  ComposedProtocolOnAnonComposedRequest(ComposedProtocolOnAnonComposedRequest&&);
  ComposedProtocolOnAnonComposedRequest& operator=(ComposedProtocolOnAnonComposedRequest&&);

  
  static ComposedProtocolOnAnonComposedRequest WithB(bool&&);

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

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

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

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

  bool is_b() const { return tag_ == ::test::protocollayoutssamelibrary::ComposedProtocolOnAnonComposedRequest::Tag::kB; }
  
  bool& b() {
    EnsureStorageInitialized(::test::protocollayoutssamelibrary::ComposedProtocolOnAnonComposedRequest::Tag::kB);
    return b_;
  }
  
  const bool& b() const {
    ZX_ASSERT(is_b());
    return b_;
  }
  ComposedProtocolOnAnonComposedRequest& set_b(bool value);

  ::test::protocollayoutssamelibrary::ComposedProtocolOnAnonComposedRequest::Tag Which() const {
    
    return ::test::protocollayoutssamelibrary::ComposedProtocolOnAnonComposedRequest::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::protocollayoutssamelibrary::ComposedProtocolOnAnonComposedRequest>;

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

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::protocollayoutssamelibrary::ComposedProtocolOnAnonComposedRequest::Tag::Invalid);
  union {
    bool b_;
  };
};

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

using ComposedProtocolOnAnonComposedRequestPtr = ::std::unique_ptr<ComposedProtocolOnAnonComposedRequest>;


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

  ComposedProtocol_TwoWayNamedComposedWithError_Result();
  ~ComposedProtocol_TwoWayNamedComposedWithError_Result();

  ComposedProtocol_TwoWayNamedComposedWithError_Result(ComposedProtocol_TwoWayNamedComposedWithError_Result&&);
  ComposedProtocol_TwoWayNamedComposedWithError_Result& operator=(ComposedProtocol_TwoWayNamedComposedWithError_Result&&);

  
  static ComposedProtocol_TwoWayNamedComposedWithError_Result WithResponse(::test::protocollayoutssamelibrary::UnionPayload&&);
  static ComposedProtocol_TwoWayNamedComposedWithError_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<ComposedProtocol_TwoWayNamedComposedWithError_Result> New() { return ::std::make_unique<ComposedProtocol_TwoWayNamedComposedWithError_Result>(); }

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

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

  bool is_response() const { return tag_ == ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayNamedComposedWithError_Result::Tag::kResponse; }
  
  ::test::protocollayoutssamelibrary::UnionPayload& response() {
    EnsureStorageInitialized(::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayNamedComposedWithError_Result::Tag::kResponse);
    return response_;
  }
  
  const ::test::protocollayoutssamelibrary::UnionPayload& response() const {
    ZX_ASSERT(is_response());
    return response_;
  }
  ComposedProtocol_TwoWayNamedComposedWithError_Result& set_response(::test::protocollayoutssamelibrary::UnionPayload value);

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

  ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayNamedComposedWithError_Result::Tag Which() const {
    
    return ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayNamedComposedWithError_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::protocollayoutssamelibrary::ComposedProtocol_TwoWayNamedComposedWithError_Result>;
  ComposedProtocol_TwoWayNamedComposedWithError_Result(fpromise::ok_result<::test::protocollayoutssamelibrary::UnionPayload>&& result) {
    set_response(::test::protocollayoutssamelibrary::UnionPayload{std::move(result.value)});
  }
  ComposedProtocol_TwoWayNamedComposedWithError_Result(fpromise::error_result<uint32_t>&& result) {
      set_err(std::move(result.error));
  }
  ComposedProtocol_TwoWayNamedComposedWithError_Result(fpromise::result<::test::protocollayoutssamelibrary::UnionPayload, uint32_t>&& result) {
    ZX_ASSERT(!result.is_pending());
    if (result.is_ok()) {
      set_response(::test::protocollayoutssamelibrary::UnionPayload{result.take_value()});
    } else {
      set_err(result.take_error());
    }
  }
  operator fpromise::result<::test::protocollayoutssamelibrary::UnionPayload, uint32_t>() && {
    if (is_err()) {
      return fpromise::error(err());
    }
    ::std::tuple<::test::protocollayoutssamelibrary::UnionPayload> value_tuple = std::move(response());
    return fpromise::ok(std::move(std::get<0>(value_tuple)));
  }

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

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayNamedComposedWithError_Result::Tag::Invalid);
  union {
    ::test::protocollayoutssamelibrary::UnionPayload response_;
    uint32_t err_;
  };
};

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

using ComposedProtocol_TwoWayNamedComposedWithError_ResultPtr = ::std::unique_ptr<ComposedProtocol_TwoWayNamedComposedWithError_Result>;


#ifdef __Fuchsia__

  namespace _internal {
__LOCAL extern "C" const fidl_type_t test_protocollayoutssamelibrary_ComposedProtocolOneWayAnonComposedRequestTable;
  
__LOCAL extern "C" const fidl_type_t test_protocollayoutssamelibrary_ComposedProtocolTwoWayAnonComposedRequestTable;
  
__LOCAL extern "C" const fidl_type_t test_protocollayoutssamelibrary_ComposedProtocolTwoWayAnonComposedWithErrorRequestTable;
  
  
__LOCAL extern "C" const fidl_type_t test_protocollayoutssamelibrary_TablePayloadTable;
  
__LOCAL extern "C" const fidl_type_t test_protocollayoutssamelibrary_UnionPayloadTable;
  
  
}  // namespace _internal

class ComposedProtocol_RequestEncoder {
 public:
  static ::fidl::HLCPPOutgoingMessage OneWayAnonComposed(::fidl::MessageEncoder* _encoder, ::test::protocollayoutssamelibrary::ComposedProtocolOneWayAnonComposedRequest* ComposedProtocolOneWayAnonComposedRequest) {
    _encoder->Alloc(16);
    ::fidl::Encode(_encoder, ComposedProtocolOneWayAnonComposedRequest, 0 + sizeof(fidl_message_header_t));
    

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

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

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

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

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

    return _encoder->GetMessage();
  }
};
  
  namespace _internal {
__LOCAL extern "C" const fidl_type_t test_protocollayoutssamelibrary_ComposedProtocolTwoWayAnonComposedResponseTable;
  
__LOCAL extern "C" const fidl_type_t test_protocollayoutssamelibrary_ComposedProtocol_TwoWayAnonComposedWithError_ResultTable;
  
__LOCAL extern "C" const fidl_type_t test_protocollayoutssamelibrary_ComposedProtocolOnAnonComposedRequestTable;
  
  
__LOCAL extern "C" const fidl_type_t test_protocollayoutssamelibrary_ComposedProtocol_TwoWayNamedComposedWithError_ResultTable;
  

}  // namespace _internal

class ComposedProtocol_ResponseEncoder {
 public:
  static ::fidl::HLCPPOutgoingMessage TwoWayAnonComposed(::fidl::MessageEncoder* _encoder, ::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedResponse* ComposedProtocolTwoWayAnonComposedResponse) {
    _encoder->Alloc(16);
    ::fidl::Encode(_encoder, ComposedProtocolTwoWayAnonComposedResponse, 0 + sizeof(fidl_message_header_t));
    

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

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

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

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

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

    return _encoder->GetMessage();
  }
};

#endif  // __Fuchsia__


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

  MainProtocol_TwoWayLocalWithError_Result();
  ~MainProtocol_TwoWayLocalWithError_Result();

  MainProtocol_TwoWayLocalWithError_Result(MainProtocol_TwoWayLocalWithError_Result&&);
  MainProtocol_TwoWayLocalWithError_Result& operator=(MainProtocol_TwoWayLocalWithError_Result&&);

  
  static MainProtocol_TwoWayLocalWithError_Result WithResponse(::test::protocollayoutssamelibrary::UnionPayload&&);
  static MainProtocol_TwoWayLocalWithError_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<MainProtocol_TwoWayLocalWithError_Result> New() { return ::std::make_unique<MainProtocol_TwoWayLocalWithError_Result>(); }

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

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

  bool is_response() const { return tag_ == ::test::protocollayoutssamelibrary::MainProtocol_TwoWayLocalWithError_Result::Tag::kResponse; }
  
  ::test::protocollayoutssamelibrary::UnionPayload& response() {
    EnsureStorageInitialized(::test::protocollayoutssamelibrary::MainProtocol_TwoWayLocalWithError_Result::Tag::kResponse);
    return response_;
  }
  
  const ::test::protocollayoutssamelibrary::UnionPayload& response() const {
    ZX_ASSERT(is_response());
    return response_;
  }
  MainProtocol_TwoWayLocalWithError_Result& set_response(::test::protocollayoutssamelibrary::UnionPayload value);

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

  ::test::protocollayoutssamelibrary::MainProtocol_TwoWayLocalWithError_Result::Tag Which() const {
    
    return ::test::protocollayoutssamelibrary::MainProtocol_TwoWayLocalWithError_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::protocollayoutssamelibrary::MainProtocol_TwoWayLocalWithError_Result>;
  MainProtocol_TwoWayLocalWithError_Result(fpromise::ok_result<::test::protocollayoutssamelibrary::UnionPayload>&& result) {
    set_response(::test::protocollayoutssamelibrary::UnionPayload{std::move(result.value)});
  }
  MainProtocol_TwoWayLocalWithError_Result(fpromise::error_result<uint32_t>&& result) {
      set_err(std::move(result.error));
  }
  MainProtocol_TwoWayLocalWithError_Result(fpromise::result<::test::protocollayoutssamelibrary::UnionPayload, uint32_t>&& result) {
    ZX_ASSERT(!result.is_pending());
    if (result.is_ok()) {
      set_response(::test::protocollayoutssamelibrary::UnionPayload{result.take_value()});
    } else {
      set_err(result.take_error());
    }
  }
  operator fpromise::result<::test::protocollayoutssamelibrary::UnionPayload, uint32_t>() && {
    if (is_err()) {
      return fpromise::error(err());
    }
    ::std::tuple<::test::protocollayoutssamelibrary::UnionPayload> value_tuple = std::move(response());
    return fpromise::ok(std::move(std::get<0>(value_tuple)));
  }

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

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::protocollayoutssamelibrary::MainProtocol_TwoWayLocalWithError_Result::Tag::Invalid);
  union {
    ::test::protocollayoutssamelibrary::UnionPayload response_;
    uint32_t err_;
  };
};

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

using MainProtocol_TwoWayLocalWithError_ResultPtr = ::std::unique_ptr<MainProtocol_TwoWayLocalWithError_Result>;


class MainProtocolOneWayAnonRequest final {
 public:
  static const fidl_type_t* FidlType;
  /// Returns whether no field is set.
  bool IsEmpty() const;
  
  const uint16_t& a() const {
    ZX_ASSERT(field_presence_.IsSet<0>());
    return a_value_.value;
  }
  bool has_a() const {
    return field_presence_.IsSet<0>();
  }
  
  uint16_t* mutable_a() {
    if (!field_presence_.IsSet<0>()) {
      field_presence_.Set<0>();
      Construct(&a_value_.value);
    }
    return &a_value_.value;
  }
  MainProtocolOneWayAnonRequest& set_a(uint16_t _value);
  void clear_a() {
    if (!field_presence_.IsSet<0>()) {
      return;
    }
    field_presence_.Clear<0>();
    Destruct(&a_value_.value);
  }

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

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

  void Encode(::fidl::Encoder* _encoder, size_t _offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, MainProtocolOneWayAnonRequest* _value, size_t _offset);
  zx_status_t Clone(MainProtocolOneWayAnonRequest* _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) {
    case 1:
      return true;
    default:
      return false;
    }
  }

  ::fidl::internal::BitSet<1> field_presence_;
  union ValueUnion_a {
    ValueUnion_a() {}
    ~ValueUnion_a() {}

    uint16_t value;
  };
  ValueUnion_a a_value_;
};

using MainProtocolOneWayAnonRequestPtr = ::std::unique_ptr<MainProtocolOneWayAnonRequest>;


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

  MainProtocolTwoWayAnonRequest();
  ~MainProtocolTwoWayAnonRequest();

  MainProtocolTwoWayAnonRequest(MainProtocolTwoWayAnonRequest&&);
  MainProtocolTwoWayAnonRequest& operator=(MainProtocolTwoWayAnonRequest&&);

  
  static MainProtocolTwoWayAnonRequest 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<MainProtocolTwoWayAnonRequest> New() { return ::std::make_unique<MainProtocolTwoWayAnonRequest>(); }

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

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

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

  ::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonRequest::Tag Which() const {
    
    switch (tag_) {
      case ::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonRequest::Tag::Invalid:
      case ::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonRequest::Tag::kB:
        return ::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonRequest::Tag(tag_);
      default:
        return ::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonRequest::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::protocollayoutssamelibrary::MainProtocolTwoWayAnonRequest::Tag::kUnknown) {
      return nullptr;
    }
    return &unknown_data_;
  }

  friend ::fidl::Equality<::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonRequest>;

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

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

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

using MainProtocolTwoWayAnonRequestPtr = ::std::unique_ptr<MainProtocolTwoWayAnonRequest>;


class MainProtocolTwoWayAnonResponse final {
 public:
  static const fidl_type_t* FidlType;
  /// Returns whether no field is set.
  bool IsEmpty() const;
  
  const uint16_t& a() const {
    ZX_ASSERT(field_presence_.IsSet<0>());
    return a_value_.value;
  }
  bool has_a() const {
    return field_presence_.IsSet<0>();
  }
  
  uint16_t* mutable_a() {
    if (!field_presence_.IsSet<0>()) {
      field_presence_.Set<0>();
      Construct(&a_value_.value);
    }
    return &a_value_.value;
  }
  MainProtocolTwoWayAnonResponse& set_a(uint16_t _value);
  void clear_a() {
    if (!field_presence_.IsSet<0>()) {
      return;
    }
    field_presence_.Clear<0>();
    Destruct(&a_value_.value);
  }

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

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

  void Encode(::fidl::Encoder* _encoder, size_t _offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, MainProtocolTwoWayAnonResponse* _value, size_t _offset);
  zx_status_t Clone(MainProtocolTwoWayAnonResponse* _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) {
    case 1:
      return true;
    default:
      return false;
    }
  }

  ::fidl::internal::BitSet<1> field_presence_;
  union ValueUnion_a {
    ValueUnion_a() {}
    ~ValueUnion_a() {}

    uint16_t value;
  };
  ValueUnion_a a_value_;
};

using MainProtocolTwoWayAnonResponsePtr = ::std::unique_ptr<MainProtocolTwoWayAnonResponse>;


class MainProtocolTwoWayAnonWithErrorRequest final {
 public:
  static const fidl_type_t* FidlType;
  /// Returns whether no field is set.
  bool IsEmpty() const;
  
  const uint16_t& a() const {
    ZX_ASSERT(field_presence_.IsSet<0>());
    return a_value_.value;
  }
  bool has_a() const {
    return field_presence_.IsSet<0>();
  }
  
  uint16_t* mutable_a() {
    if (!field_presence_.IsSet<0>()) {
      field_presence_.Set<0>();
      Construct(&a_value_.value);
    }
    return &a_value_.value;
  }
  MainProtocolTwoWayAnonWithErrorRequest& set_a(uint16_t _value);
  void clear_a() {
    if (!field_presence_.IsSet<0>()) {
      return;
    }
    field_presence_.Clear<0>();
    Destruct(&a_value_.value);
  }

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

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

  void Encode(::fidl::Encoder* _encoder, size_t _offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, MainProtocolTwoWayAnonWithErrorRequest* _value, size_t _offset);
  zx_status_t Clone(MainProtocolTwoWayAnonWithErrorRequest* _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) {
    case 1:
      return true;
    default:
      return false;
    }
  }

  ::fidl::internal::BitSet<1> field_presence_;
  union ValueUnion_a {
    ValueUnion_a() {}
    ~ValueUnion_a() {}

    uint16_t value;
  };
  ValueUnion_a a_value_;
};

using MainProtocolTwoWayAnonWithErrorRequestPtr = ::std::unique_ptr<MainProtocolTwoWayAnonWithErrorRequest>;


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

  MainProtocol_TwoWayAnonWithError_Response();
  ~MainProtocol_TwoWayAnonWithError_Response();

  MainProtocol_TwoWayAnonWithError_Response(MainProtocol_TwoWayAnonWithError_Response&&);
  MainProtocol_TwoWayAnonWithError_Response& operator=(MainProtocol_TwoWayAnonWithError_Response&&);

  
  static MainProtocol_TwoWayAnonWithError_Response 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<MainProtocol_TwoWayAnonWithError_Response> New() { return ::std::make_unique<MainProtocol_TwoWayAnonWithError_Response>(); }

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

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

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

  ::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Response::Tag Which() const {
    
    switch (tag_) {
      case ::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Response::Tag::Invalid:
      case ::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Response::Tag::kB:
        return ::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Response::Tag(tag_);
      default:
        return ::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Response::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::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Response::Tag::kUnknown) {
      return nullptr;
    }
    return &unknown_data_;
  }

  friend ::fidl::Equality<::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Response>;

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

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

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

using MainProtocol_TwoWayAnonWithError_ResponsePtr = ::std::unique_ptr<MainProtocol_TwoWayAnonWithError_Response>;


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

  MainProtocol_TwoWayAnonWithError_Result();
  ~MainProtocol_TwoWayAnonWithError_Result();

  MainProtocol_TwoWayAnonWithError_Result(MainProtocol_TwoWayAnonWithError_Result&&);
  MainProtocol_TwoWayAnonWithError_Result& operator=(MainProtocol_TwoWayAnonWithError_Result&&);

  
  static MainProtocol_TwoWayAnonWithError_Result WithResponse(::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Response&&);
  static MainProtocol_TwoWayAnonWithError_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<MainProtocol_TwoWayAnonWithError_Result> New() { return ::std::make_unique<MainProtocol_TwoWayAnonWithError_Result>(); }

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

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

  bool is_response() const { return tag_ == ::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Result::Tag::kResponse; }
  
  ::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Response& response() {
    EnsureStorageInitialized(::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Result::Tag::kResponse);
    return response_;
  }
  
  const ::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Response& response() const {
    ZX_ASSERT(is_response());
    return response_;
  }
  MainProtocol_TwoWayAnonWithError_Result& set_response(::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Response value);

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

  ::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Result::Tag Which() const {
    
    return ::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_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::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Result>;
  MainProtocol_TwoWayAnonWithError_Result(fpromise::ok_result<::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Response>&& result) {
    set_response(::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Response{std::move(result.value)});
  }
  MainProtocol_TwoWayAnonWithError_Result(fpromise::error_result<uint32_t>&& result) {
      set_err(std::move(result.error));
  }
  MainProtocol_TwoWayAnonWithError_Result(fpromise::result<::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Response, uint32_t>&& result) {
    ZX_ASSERT(!result.is_pending());
    if (result.is_ok()) {
      set_response(::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Response{result.take_value()});
    } else {
      set_err(result.take_error());
    }
  }
  operator fpromise::result<::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Response, uint32_t>() && {
    if (is_err()) {
      return fpromise::error(err());
    }
    ::std::tuple<::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Response> value_tuple = std::move(response());
    return fpromise::ok(std::move(std::get<0>(value_tuple)));
  }

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

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Result::Tag::Invalid);
  union {
    ::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Response response_;
    uint32_t err_;
  };
};

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

using MainProtocol_TwoWayAnonWithError_ResultPtr = ::std::unique_ptr<MainProtocol_TwoWayAnonWithError_Result>;


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

  MainProtocolOnAnonRequest();
  ~MainProtocolOnAnonRequest();

  MainProtocolOnAnonRequest(MainProtocolOnAnonRequest&&);
  MainProtocolOnAnonRequest& operator=(MainProtocolOnAnonRequest&&);

  
  static MainProtocolOnAnonRequest 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<MainProtocolOnAnonRequest> New() { return ::std::make_unique<MainProtocolOnAnonRequest>(); }

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

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

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

  ::test::protocollayoutssamelibrary::MainProtocolOnAnonRequest::Tag Which() const {
    
    switch (tag_) {
      case ::test::protocollayoutssamelibrary::MainProtocolOnAnonRequest::Tag::Invalid:
      case ::test::protocollayoutssamelibrary::MainProtocolOnAnonRequest::Tag::kB:
        return ::test::protocollayoutssamelibrary::MainProtocolOnAnonRequest::Tag(tag_);
      default:
        return ::test::protocollayoutssamelibrary::MainProtocolOnAnonRequest::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::protocollayoutssamelibrary::MainProtocolOnAnonRequest::Tag::kUnknown) {
      return nullptr;
    }
    return &unknown_data_;
  }

  friend ::fidl::Equality<::test::protocollayoutssamelibrary::MainProtocolOnAnonRequest>;

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

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

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

using MainProtocolOnAnonRequestPtr = ::std::unique_ptr<MainProtocolOnAnonRequest>;


#ifdef __Fuchsia__

  
  namespace _internal {
__LOCAL extern "C" const fidl_type_t test_protocollayoutssamelibrary_MainProtocolOneWayAnonRequestTable;
  
__LOCAL extern "C" const fidl_type_t test_protocollayoutssamelibrary_MainProtocolTwoWayAnonRequestTable;
  
__LOCAL extern "C" const fidl_type_t test_protocollayoutssamelibrary_MainProtocolTwoWayAnonWithErrorRequestTable;
  

}  // namespace _internal

class MainProtocol_RequestEncoder {
 public:
  static ::fidl::HLCPPOutgoingMessage OneWayAnonComposed(::fidl::MessageEncoder* _encoder, ::test::protocollayoutssamelibrary::ComposedProtocolOneWayAnonComposedRequest* ComposedProtocolOneWayAnonComposedRequest) {
    _encoder->Alloc(16);
    ::fidl::Encode(_encoder, ComposedProtocolOneWayAnonComposedRequest, 0 + sizeof(fidl_message_header_t));
    

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

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

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

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

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

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

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

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

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

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

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

    return _encoder->GetMessage();
  }
};
  
  
  namespace _internal {
__LOCAL extern "C" const fidl_type_t test_protocollayoutssamelibrary_MainProtocol_TwoWayLocalWithError_ResultTable;
  
  
__LOCAL extern "C" const fidl_type_t test_protocollayoutssamelibrary_MainProtocolTwoWayAnonResponseTable;
  
__LOCAL extern "C" const fidl_type_t test_protocollayoutssamelibrary_MainProtocol_TwoWayAnonWithError_ResultTable;
  
__LOCAL extern "C" const fidl_type_t test_protocollayoutssamelibrary_MainProtocolOnAnonRequestTable;

}  // namespace _internal

class MainProtocol_ResponseEncoder {
 public:
  static ::fidl::HLCPPOutgoingMessage TwoWayAnonComposed(::fidl::MessageEncoder* _encoder, ::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedResponse* ComposedProtocolTwoWayAnonComposedResponse) {
    _encoder->Alloc(16);
    ::fidl::Encode(_encoder, ComposedProtocolTwoWayAnonComposedResponse, 0 + sizeof(fidl_message_header_t));
    

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

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

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

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

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

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

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

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

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

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

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

    return _encoder->GetMessage();
  }
};

#endif  // __Fuchsia__


}  // namespace protocollayoutssamelibrary
}  // namespace test
namespace fidl {

template <>
struct CodingTraits<::test::protocollayoutssamelibrary::TablePayload>
    : public EncodableCodingTraits<::test::protocollayoutssamelibrary::TablePayload, 16> {};

inline zx_status_t Clone(const ::test::protocollayoutssamelibrary::TablePayload& _value,
                         ::test::protocollayoutssamelibrary::TablePayload* result) {
  return _value.Clone(result);
}
template<>
struct Equality<::test::protocollayoutssamelibrary::TablePayload> {
  bool operator()(const ::test::protocollayoutssamelibrary::TablePayload& _lhs, const ::test::protocollayoutssamelibrary::TablePayload& _rhs) const {
    if (_lhs.has_a()) {
      if (!_rhs.has_a()) {
        return false;
      }
      if (!::fidl::Equals(_lhs.a(), _rhs.a())) {
        return false;
      }
    } else if (_rhs.has_a()) {
      return false;
    }
    return true;
  }
};
template <>
struct IsFidlXUnion<::test::protocollayoutssamelibrary::UnionPayload> : public std::true_type {};

template <>
struct CodingTraits<::test::protocollayoutssamelibrary::UnionPayload>
    : public EncodableCodingTraits<::test::protocollayoutssamelibrary::UnionPayload, 16> {};

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

  static void Encode(Encoder* encoder, std::unique_ptr<::test::protocollayoutssamelibrary::UnionPayload>* 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::protocollayoutssamelibrary::UnionPayload>* 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::protocollayoutssamelibrary::UnionPayload);

    ::test::protocollayoutssamelibrary::UnionPayload::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::protocollayoutssamelibrary::UnionPayload::Tag::Invalid):
        return true;
      case ::test::protocollayoutssamelibrary::UnionPayload::Tag::kB:
        return ::fidl::Equals(_lhs.b_, _rhs.b_);
      
      default:
        return false;
      }
    }
};
template <>
struct CodingTraits<::test::protocollayoutssamelibrary::ComposedProtocolOneWayAnonComposedRequest>
    : public EncodableCodingTraits<::test::protocollayoutssamelibrary::ComposedProtocolOneWayAnonComposedRequest, 16> {};

inline zx_status_t Clone(const ::test::protocollayoutssamelibrary::ComposedProtocolOneWayAnonComposedRequest& _value,
                         ::test::protocollayoutssamelibrary::ComposedProtocolOneWayAnonComposedRequest* result) {
  return _value.Clone(result);
}
template<>
struct Equality<::test::protocollayoutssamelibrary::ComposedProtocolOneWayAnonComposedRequest> {
  bool operator()(const ::test::protocollayoutssamelibrary::ComposedProtocolOneWayAnonComposedRequest& _lhs, const ::test::protocollayoutssamelibrary::ComposedProtocolOneWayAnonComposedRequest& _rhs) const {
    if (_lhs.has_a()) {
      if (!_rhs.has_a()) {
        return false;
      }
      if (!::fidl::Equals(_lhs.a(), _rhs.a())) {
        return false;
      }
    } else if (_rhs.has_a()) {
      return false;
    }
    return true;
  }
};
template <>
struct IsFidlXUnion<::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedRequest> : public std::true_type {};

template <>
struct CodingTraits<::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedRequest>
    : public EncodableCodingTraits<::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedRequest, 16> {};

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

  static void Encode(Encoder* encoder, std::unique_ptr<::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedRequest>* 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::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedRequest>* 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::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedRequest);

    ::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedRequest::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedRequest::Tag::Invalid):
        return true;
      case ::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedRequest::Tag::kB:
        return ::fidl::Equals(_lhs.b_, _rhs.b_);
      
      default:
        return false;
      }
    }
};
template <>
struct CodingTraits<::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedResponse>
    : public EncodableCodingTraits<::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedResponse, 16> {};

inline zx_status_t Clone(const ::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedResponse& _value,
                         ::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedResponse* result) {
  return _value.Clone(result);
}
template<>
struct Equality<::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedResponse> {
  bool operator()(const ::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedResponse& _lhs, const ::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedResponse& _rhs) const {
    if (_lhs.has_a()) {
      if (!_rhs.has_a()) {
        return false;
      }
      if (!::fidl::Equals(_lhs.a(), _rhs.a())) {
        return false;
      }
    } else if (_rhs.has_a()) {
      return false;
    }
    return true;
  }
};
template <>
struct CodingTraits<::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedWithErrorRequest>
    : public EncodableCodingTraits<::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedWithErrorRequest, 16> {};

inline zx_status_t Clone(const ::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedWithErrorRequest& _value,
                         ::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedWithErrorRequest* result) {
  return _value.Clone(result);
}
template<>
struct Equality<::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedWithErrorRequest> {
  bool operator()(const ::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedWithErrorRequest& _lhs, const ::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedWithErrorRequest& _rhs) const {
    if (_lhs.has_a()) {
      if (!_rhs.has_a()) {
        return false;
      }
      if (!::fidl::Equals(_lhs.a(), _rhs.a())) {
        return false;
      }
    } else if (_rhs.has_a()) {
      return false;
    }
    return true;
  }
};
template <>
struct IsFidlXUnion<::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Response> : public std::true_type {};

template <>
struct CodingTraits<::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Response>
    : public EncodableCodingTraits<::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Response, 16> {};

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

  static void Encode(Encoder* encoder, std::unique_ptr<::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Response>* 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::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Response>* 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::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Response);

    ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Response::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Response::Tag::Invalid):
        return true;
      case ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Response::Tag::kB:
        return ::fidl::Equals(_lhs.b_, _rhs.b_);
      
      default:
        return false;
      }
    }
};
template <>
struct IsFidlXUnion<::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Result> : public std::true_type {};

template <>
struct CodingTraits<::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Result>
    : public EncodableCodingTraits<::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Result, 16> {};

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

  static void Encode(Encoder* encoder, std::unique_ptr<::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_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::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_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::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Result);

    ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Result::Decode(_decoder, value->get(), offset);
  }
};

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

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

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

template <>
struct CodingTraits<::test::protocollayoutssamelibrary::ComposedProtocolOnAnonComposedRequest>
    : public EncodableCodingTraits<::test::protocollayoutssamelibrary::ComposedProtocolOnAnonComposedRequest, 16> {};

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

  static void Encode(Encoder* encoder, std::unique_ptr<::test::protocollayoutssamelibrary::ComposedProtocolOnAnonComposedRequest>* 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::protocollayoutssamelibrary::ComposedProtocolOnAnonComposedRequest>* 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::protocollayoutssamelibrary::ComposedProtocolOnAnonComposedRequest);

    ::test::protocollayoutssamelibrary::ComposedProtocolOnAnonComposedRequest::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::protocollayoutssamelibrary::ComposedProtocolOnAnonComposedRequest::Tag::Invalid):
        return true;
      case ::test::protocollayoutssamelibrary::ComposedProtocolOnAnonComposedRequest::Tag::kB:
        return ::fidl::Equals(_lhs.b_, _rhs.b_);
      
      default:
        return false;
      }
    }
};
template <>
struct IsFidlXUnion<::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayNamedComposedWithError_Result> : public std::true_type {};

template <>
struct CodingTraits<::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayNamedComposedWithError_Result>
    : public EncodableCodingTraits<::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayNamedComposedWithError_Result, 16> {};

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

  static void Encode(Encoder* encoder, std::unique_ptr<::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayNamedComposedWithError_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::protocollayoutssamelibrary::ComposedProtocol_TwoWayNamedComposedWithError_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::protocollayoutssamelibrary::ComposedProtocol_TwoWayNamedComposedWithError_Result);

    ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayNamedComposedWithError_Result::Decode(_decoder, value->get(), offset);
  }
};

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

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

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

template <>
struct CodingTraits<::test::protocollayoutssamelibrary::MainProtocol_TwoWayLocalWithError_Result>
    : public EncodableCodingTraits<::test::protocollayoutssamelibrary::MainProtocol_TwoWayLocalWithError_Result, 16> {};

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

  static void Encode(Encoder* encoder, std::unique_ptr<::test::protocollayoutssamelibrary::MainProtocol_TwoWayLocalWithError_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::protocollayoutssamelibrary::MainProtocol_TwoWayLocalWithError_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::protocollayoutssamelibrary::MainProtocol_TwoWayLocalWithError_Result);

    ::test::protocollayoutssamelibrary::MainProtocol_TwoWayLocalWithError_Result::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::protocollayoutssamelibrary::MainProtocol_TwoWayLocalWithError_Result::Tag::Invalid):
        return true;
      case ::test::protocollayoutssamelibrary::MainProtocol_TwoWayLocalWithError_Result::Tag::kResponse:
        return ::fidl::Equals(_lhs.response_, _rhs.response_);
      case ::test::protocollayoutssamelibrary::MainProtocol_TwoWayLocalWithError_Result::Tag::kErr:
        return ::fidl::Equals(_lhs.err_, _rhs.err_);
      
      default:
        return false;
      }
    }
};
template <>
struct CodingTraits<::test::protocollayoutssamelibrary::MainProtocolOneWayAnonRequest>
    : public EncodableCodingTraits<::test::protocollayoutssamelibrary::MainProtocolOneWayAnonRequest, 16> {};

inline zx_status_t Clone(const ::test::protocollayoutssamelibrary::MainProtocolOneWayAnonRequest& _value,
                         ::test::protocollayoutssamelibrary::MainProtocolOneWayAnonRequest* result) {
  return _value.Clone(result);
}
template<>
struct Equality<::test::protocollayoutssamelibrary::MainProtocolOneWayAnonRequest> {
  bool operator()(const ::test::protocollayoutssamelibrary::MainProtocolOneWayAnonRequest& _lhs, const ::test::protocollayoutssamelibrary::MainProtocolOneWayAnonRequest& _rhs) const {
    if (_lhs.has_a()) {
      if (!_rhs.has_a()) {
        return false;
      }
      if (!::fidl::Equals(_lhs.a(), _rhs.a())) {
        return false;
      }
    } else if (_rhs.has_a()) {
      return false;
    }
    return true;
  }
};
template <>
struct IsFidlXUnion<::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonRequest> : public std::true_type {};

template <>
struct CodingTraits<::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonRequest>
    : public EncodableCodingTraits<::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonRequest, 16> {};

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

  static void Encode(Encoder* encoder, std::unique_ptr<::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonRequest>* 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::protocollayoutssamelibrary::MainProtocolTwoWayAnonRequest>* 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::protocollayoutssamelibrary::MainProtocolTwoWayAnonRequest);

    ::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonRequest::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonRequest::Tag::Invalid):
        return true;
      case ::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonRequest::Tag::kB:
        return ::fidl::Equals(_lhs.b_, _rhs.b_);
      default:
        return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_);
      }
    }
};
template <>
struct CodingTraits<::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonResponse>
    : public EncodableCodingTraits<::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonResponse, 16> {};

inline zx_status_t Clone(const ::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonResponse& _value,
                         ::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonResponse* result) {
  return _value.Clone(result);
}
template<>
struct Equality<::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonResponse> {
  bool operator()(const ::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonResponse& _lhs, const ::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonResponse& _rhs) const {
    if (_lhs.has_a()) {
      if (!_rhs.has_a()) {
        return false;
      }
      if (!::fidl::Equals(_lhs.a(), _rhs.a())) {
        return false;
      }
    } else if (_rhs.has_a()) {
      return false;
    }
    return true;
  }
};
template <>
struct CodingTraits<::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonWithErrorRequest>
    : public EncodableCodingTraits<::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonWithErrorRequest, 16> {};

inline zx_status_t Clone(const ::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonWithErrorRequest& _value,
                         ::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonWithErrorRequest* result) {
  return _value.Clone(result);
}
template<>
struct Equality<::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonWithErrorRequest> {
  bool operator()(const ::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonWithErrorRequest& _lhs, const ::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonWithErrorRequest& _rhs) const {
    if (_lhs.has_a()) {
      if (!_rhs.has_a()) {
        return false;
      }
      if (!::fidl::Equals(_lhs.a(), _rhs.a())) {
        return false;
      }
    } else if (_rhs.has_a()) {
      return false;
    }
    return true;
  }
};
template <>
struct IsFidlXUnion<::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Response> : public std::true_type {};

template <>
struct CodingTraits<::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Response>
    : public EncodableCodingTraits<::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Response, 16> {};

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

  static void Encode(Encoder* encoder, std::unique_ptr<::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Response>* 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::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Response>* 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::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Response);

    ::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Response::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Response::Tag::Invalid):
        return true;
      case ::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Response::Tag::kB:
        return ::fidl::Equals(_lhs.b_, _rhs.b_);
      default:
        return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_);
      }
    }
};
template <>
struct IsFidlXUnion<::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Result> : public std::true_type {};

template <>
struct CodingTraits<::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Result>
    : public EncodableCodingTraits<::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Result, 16> {};

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

  static void Encode(Encoder* encoder, std::unique_ptr<::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_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::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_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::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Result);

    ::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Result::Decode(_decoder, value->get(), offset);
  }
};

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

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

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

template <>
struct CodingTraits<::test::protocollayoutssamelibrary::MainProtocolOnAnonRequest>
    : public EncodableCodingTraits<::test::protocollayoutssamelibrary::MainProtocolOnAnonRequest, 16> {};

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

  static void Encode(Encoder* encoder, std::unique_ptr<::test::protocollayoutssamelibrary::MainProtocolOnAnonRequest>* 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::protocollayoutssamelibrary::MainProtocolOnAnonRequest>* 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::protocollayoutssamelibrary::MainProtocolOnAnonRequest);

    ::test::protocollayoutssamelibrary::MainProtocolOnAnonRequest::Decode(_decoder, value->get(), offset);
  }
};

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

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

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

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

#ifdef __Fuchsia__

using ComposedProtocolPtr = ::fidl::InterfacePtr<ComposedProtocol>;
class ComposedProtocol_Proxy;
class ComposedProtocol_Stub;
class ComposedProtocol_EventSender;
class ComposedProtocol_Sync;
using ComposedProtocolSyncPtr = ::fidl::SynchronousInterfacePtr<ComposedProtocol>;
class ComposedProtocol_SyncProxy;

namespace internal {

constexpr uint64_t kComposedProtocol_OneWayAnonComposed_Ordinal = 0x6e7a205bdad7941flu;

constexpr ::fidl::MessageDynamicFlags kComposedProtocol_OneWayAnonComposed_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kComposedProtocol_TwoWayAnonComposed_Ordinal = 0x7083713dee9435f4lu;

constexpr ::fidl::MessageDynamicFlags kComposedProtocol_TwoWayAnonComposed_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kComposedProtocol_TwoWayAnonComposedWithError_Ordinal = 0x4fd32c5e2ffa6828lu;

constexpr ::fidl::MessageDynamicFlags kComposedProtocol_TwoWayAnonComposedWithError_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kComposedProtocol_OnAnonComposed_Ordinal = 0x49a6eee3a0300e28lu;

constexpr ::fidl::MessageDynamicFlags kComposedProtocol_OnAnonComposed_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kComposedProtocol_OneWayNamedComposed_Ordinal = 0x101636a8fa3e69b8lu;

constexpr ::fidl::MessageDynamicFlags kComposedProtocol_OneWayNamedComposed_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kComposedProtocol_TwoWayNamedComposed_Ordinal = 0x45b4d3d31b374054lu;

constexpr ::fidl::MessageDynamicFlags kComposedProtocol_TwoWayNamedComposed_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kComposedProtocol_TwoWayNamedComposedWithError_Ordinal = 0x450531e2d20c52eflu;

constexpr ::fidl::MessageDynamicFlags kComposedProtocol_TwoWayNamedComposedWithError_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kComposedProtocol_OnNamedComposed_Ordinal = 0x17c4edb4a4a36d7blu;

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

#endif  // __Fuchsia__


#ifdef __Fuchsia__

using MainProtocolPtr = ::fidl::InterfacePtr<MainProtocol>;
class MainProtocol_Proxy;
class MainProtocol_Stub;
class MainProtocol_EventSender;
class MainProtocol_Sync;
using MainProtocolSyncPtr = ::fidl::SynchronousInterfacePtr<MainProtocol>;
class MainProtocol_SyncProxy;

namespace internal {

constexpr uint64_t kMainProtocol_OneWayAnonComposed_Ordinal = 0x6e7a205bdad7941flu;

constexpr ::fidl::MessageDynamicFlags kMainProtocol_OneWayAnonComposed_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kMainProtocol_TwoWayAnonComposed_Ordinal = 0x7083713dee9435f4lu;

constexpr ::fidl::MessageDynamicFlags kMainProtocol_TwoWayAnonComposed_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kMainProtocol_TwoWayAnonComposedWithError_Ordinal = 0x4fd32c5e2ffa6828lu;

constexpr ::fidl::MessageDynamicFlags kMainProtocol_TwoWayAnonComposedWithError_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kMainProtocol_OnAnonComposed_Ordinal = 0x49a6eee3a0300e28lu;

constexpr ::fidl::MessageDynamicFlags kMainProtocol_OnAnonComposed_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kMainProtocol_OneWayNamedComposed_Ordinal = 0x101636a8fa3e69b8lu;

constexpr ::fidl::MessageDynamicFlags kMainProtocol_OneWayNamedComposed_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kMainProtocol_TwoWayNamedComposed_Ordinal = 0x45b4d3d31b374054lu;

constexpr ::fidl::MessageDynamicFlags kMainProtocol_TwoWayNamedComposed_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kMainProtocol_TwoWayNamedComposedWithError_Ordinal = 0x450531e2d20c52eflu;

constexpr ::fidl::MessageDynamicFlags kMainProtocol_TwoWayNamedComposedWithError_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kMainProtocol_OnNamedComposed_Ordinal = 0x17c4edb4a4a36d7blu;

constexpr ::fidl::MessageDynamicFlags kMainProtocol_OnNamedComposed_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kMainProtocol_OneWayLocal_Ordinal = 0x3954b4c6b80956c1lu;

constexpr ::fidl::MessageDynamicFlags kMainProtocol_OneWayLocal_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kMainProtocol_TwoWayLocal_Ordinal = 0x26998b4c1e8a9a57lu;

constexpr ::fidl::MessageDynamicFlags kMainProtocol_TwoWayLocal_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kMainProtocol_TwoWayLocalWithError_Ordinal = 0x4a7bf9ce881afde7lu;

constexpr ::fidl::MessageDynamicFlags kMainProtocol_TwoWayLocalWithError_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kMainProtocol_OnLocal_Ordinal = 0x71e90a3d364d2e8dlu;

constexpr ::fidl::MessageDynamicFlags kMainProtocol_OnLocal_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kMainProtocol_OneWayAnon_Ordinal = 0x774bf445f584ce2clu;

constexpr ::fidl::MessageDynamicFlags kMainProtocol_OneWayAnon_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kMainProtocol_TwoWayAnon_Ordinal = 0x3fd7ad8e52b07e2elu;

constexpr ::fidl::MessageDynamicFlags kMainProtocol_TwoWayAnon_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kMainProtocol_TwoWayAnonWithError_Ordinal = 0x1d33061a424eb245lu;

constexpr ::fidl::MessageDynamicFlags kMainProtocol_TwoWayAnonWithError_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kMainProtocol_OnAnon_Ordinal = 0xd8fa6d0f5fabb94lu;

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

#endif  // __Fuchsia__

#ifdef __Fuchsia__

class ComposedProtocol {
 public:
  using Proxy_ = ::test::protocollayoutssamelibrary::ComposedProtocol_Proxy;
  using Stub_ = ::test::protocollayoutssamelibrary::ComposedProtocol_Stub;
  using EventSender_ = ::test::protocollayoutssamelibrary::ComposedProtocol_EventSender;
  using Sync_ = ::test::protocollayoutssamelibrary::ComposedProtocol_Sync;
  virtual ~ComposedProtocol();
      
  virtual void OneWayAnonComposed(::test::protocollayoutssamelibrary::ComposedProtocolOneWayAnonComposedRequest ComposedProtocolOneWayAnonComposedRequest) = 0;
  using TwoWayAnonComposedCallback =
      fit::function<void(::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedResponse)>;
      
  virtual void TwoWayAnonComposed(::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedRequest ComposedProtocolTwoWayAnonComposedRequest, TwoWayAnonComposedCallback callback) = 0;
  using TwoWayAnonComposedWithErrorCallback =
      fit::function<void(::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Result)>;
      
  virtual void TwoWayAnonComposedWithError(::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedWithErrorRequest ComposedProtocolTwoWayAnonComposedWithErrorRequest, TwoWayAnonComposedWithErrorCallback callback) = 0;
  using OnAnonComposedCallback =
      fit::function<void(::test::protocollayoutssamelibrary::ComposedProtocolOnAnonComposedRequest)>;
      
  virtual void OneWayNamedComposed(::test::protocollayoutssamelibrary::TablePayload TablePayload) = 0;
  using TwoWayNamedComposedCallback =
      fit::function<void(::test::protocollayoutssamelibrary::TablePayload)>;
      
  virtual void TwoWayNamedComposed(::test::protocollayoutssamelibrary::UnionPayload UnionPayload, TwoWayNamedComposedCallback callback) = 0;
  using TwoWayNamedComposedWithErrorCallback =
      fit::function<void(::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayNamedComposedWithError_Result)>;
      
  virtual void TwoWayNamedComposedWithError(::test::protocollayoutssamelibrary::TablePayload TablePayload, TwoWayNamedComposedWithErrorCallback callback) = 0;
  using OnNamedComposedCallback =
      fit::function<void(::test::protocollayoutssamelibrary::UnionPayload)>;

  
};

class ComposedProtocol_RequestDecoder {
 public:
  ComposedProtocol_RequestDecoder() = default;
  virtual ~ComposedProtocol_RequestDecoder() = default;
  static const fidl_type_t* GetType(uint64_t ordinal, bool* out_needs_response, bool* is_known);
  virtual void OneWayAnonComposed(::test::protocollayoutssamelibrary::ComposedProtocolOneWayAnonComposedRequest ComposedProtocolOneWayAnonComposedRequest) = 0;
  virtual void TwoWayAnonComposed(::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedRequest ComposedProtocolTwoWayAnonComposedRequest) = 0;
  virtual void TwoWayAnonComposedWithError(::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedWithErrorRequest ComposedProtocolTwoWayAnonComposedWithErrorRequest) = 0;
  virtual void OneWayNamedComposed(::test::protocollayoutssamelibrary::TablePayload TablePayload) = 0;
  virtual void TwoWayNamedComposed(::test::protocollayoutssamelibrary::UnionPayload UnionPayload) = 0;
  virtual void TwoWayNamedComposedWithError(::test::protocollayoutssamelibrary::TablePayload TablePayload) = 0;
};

class ComposedProtocol_ResponseDecoder {
 public:
  ComposedProtocol_ResponseDecoder() = default;
  virtual ~ComposedProtocol_ResponseDecoder() = default;
  static const fidl_type_t* GetType(uint64_t ordinal);
  virtual void TwoWayAnonComposed(::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedResponse ComposedProtocolTwoWayAnonComposedResponse) = 0;
  virtual void TwoWayAnonComposedWithError(::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Result ComposedProtocol_TwoWayAnonComposedWithError_Result) = 0;
  virtual void OnAnonComposed(::test::protocollayoutssamelibrary::ComposedProtocolOnAnonComposedRequest ComposedProtocolOnAnonComposedRequest) = 0;
  virtual void TwoWayNamedComposed(::test::protocollayoutssamelibrary::TablePayload TablePayload) = 0;
  virtual void TwoWayNamedComposedWithError(::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayNamedComposedWithError_Result ComposedProtocol_TwoWayNamedComposedWithError_Result) = 0;
  virtual void OnNamedComposed(::test::protocollayoutssamelibrary::UnionPayload UnionPayload) = 0;
};

class ComposedProtocol_EventSender {
 public:
  virtual ~ComposedProtocol_EventSender();
  virtual void OnAnonComposed(::test::protocollayoutssamelibrary::ComposedProtocolOnAnonComposedRequest ComposedProtocolOnAnonComposedRequest) = 0;
  virtual void OnNamedComposed(::test::protocollayoutssamelibrary::UnionPayload UnionPayload) = 0;
};

class ComposedProtocol_Sync {
 public:
  using Proxy_ = ::test::protocollayoutssamelibrary::ComposedProtocol_SyncProxy;
  virtual ~ComposedProtocol_Sync();
  virtual zx_status_t OneWayAnonComposed(::test::protocollayoutssamelibrary::ComposedProtocolOneWayAnonComposedRequest ComposedProtocolOneWayAnonComposedRequest) = 0;
  virtual zx_status_t TwoWayAnonComposed(::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedRequest ComposedProtocolTwoWayAnonComposedRequest, ::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedResponse* out_ComposedProtocolTwoWayAnonComposedResponse) = 0;
  virtual zx_status_t TwoWayAnonComposedWithError(::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedWithErrorRequest ComposedProtocolTwoWayAnonComposedWithErrorRequest, ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Result* out_ComposedProtocol_TwoWayAnonComposedWithError_Result) = 0;
  virtual zx_status_t OneWayNamedComposed(::test::protocollayoutssamelibrary::TablePayload TablePayload) = 0;
  virtual zx_status_t TwoWayNamedComposed(::test::protocollayoutssamelibrary::UnionPayload UnionPayload, ::test::protocollayoutssamelibrary::TablePayload* out_TablePayload) = 0;
  virtual zx_status_t TwoWayNamedComposedWithError(::test::protocollayoutssamelibrary::TablePayload TablePayload, ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayNamedComposedWithError_Result* out_ComposedProtocol_TwoWayNamedComposedWithError_Result) = 0;
};

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

  zx_status_t Dispatch_(::fidl::HLCPPIncomingMessage message) override;
  // cts-coverage-fidl-name:test.protocollayoutssamelibrary/ComposedProtocol.OneWayAnonComposed
  void OneWayAnonComposed(::test::protocollayoutssamelibrary::ComposedProtocolOneWayAnonComposedRequest ComposedProtocolOneWayAnonComposedRequest) override;
  // cts-coverage-fidl-name:test.protocollayoutssamelibrary/ComposedProtocol.TwoWayAnonComposed
  void TwoWayAnonComposed(::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedRequest ComposedProtocolTwoWayAnonComposedRequest, TwoWayAnonComposedCallback callback) override;
  // cts-coverage-fidl-name:test.protocollayoutssamelibrary/ComposedProtocol.TwoWayAnonComposedWithError
  void TwoWayAnonComposedWithError(::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedWithErrorRequest ComposedProtocolTwoWayAnonComposedWithErrorRequest, TwoWayAnonComposedWithErrorCallback callback) override;
  OnAnonComposedCallback OnAnonComposed;
  // cts-coverage-fidl-name:test.protocollayoutssamelibrary/ComposedProtocol.OneWayNamedComposed
  void OneWayNamedComposed(::test::protocollayoutssamelibrary::TablePayload TablePayload) override;
  // cts-coverage-fidl-name:test.protocollayoutssamelibrary/ComposedProtocol.TwoWayNamedComposed
  void TwoWayNamedComposed(::test::protocollayoutssamelibrary::UnionPayload UnionPayload, TwoWayNamedComposedCallback callback) override;
  // cts-coverage-fidl-name:test.protocollayoutssamelibrary/ComposedProtocol.TwoWayNamedComposedWithError
  void TwoWayNamedComposedWithError(::test::protocollayoutssamelibrary::TablePayload TablePayload, TwoWayNamedComposedWithErrorCallback callback) override;
  OnNamedComposedCallback OnNamedComposed;

  
 private:
  ComposedProtocol_Proxy(const ::test::protocollayoutssamelibrary::ComposedProtocol_Proxy&) = delete;
  ComposedProtocol_Proxy& operator=(const ::test::protocollayoutssamelibrary::ComposedProtocol_Proxy&) = delete;

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

class ComposedProtocol_Stub final : public ::fidl::internal::Stub, public ::test::protocollayoutssamelibrary::ComposedProtocol_EventSender {
 public:
  typedef class ::test::protocollayoutssamelibrary::ComposedProtocol ComposedProtocol_clazz;
  explicit ComposedProtocol_Stub(::test::protocollayoutssamelibrary::ComposedProtocol_Stub::ComposedProtocol_clazz* impl);
  ~ComposedProtocol_Stub() override;

  zx_status_t Dispatch_(::fidl::HLCPPIncomingMessage message,
                        ::fidl::internal::PendingResponse response) override;
  void OnAnonComposed(::test::protocollayoutssamelibrary::ComposedProtocolOnAnonComposedRequest ComposedProtocolOnAnonComposedRequest) override;
  void OnNamedComposed(::test::protocollayoutssamelibrary::UnionPayload UnionPayload) override;

 private:
  ::test::protocollayoutssamelibrary::ComposedProtocol_Stub::ComposedProtocol_clazz* impl_;
};

class ComposedProtocol_SyncProxy : public ::test::protocollayoutssamelibrary::ComposedProtocol_Sync {
 public:
  explicit ComposedProtocol_SyncProxy(::zx::channel channel);
  ~ComposedProtocol_SyncProxy() override;
  // cts-coverage-fidl-name:test.protocollayoutssamelibrary/ComposedProtocol.OneWayAnonComposed
  zx_status_t OneWayAnonComposed(::test::protocollayoutssamelibrary::ComposedProtocolOneWayAnonComposedRequest ComposedProtocolOneWayAnonComposedRequest) override;
  // cts-coverage-fidl-name:test.protocollayoutssamelibrary/ComposedProtocol.TwoWayAnonComposed
  zx_status_t TwoWayAnonComposed(::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedRequest ComposedProtocolTwoWayAnonComposedRequest, ::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedResponse* out_ComposedProtocolTwoWayAnonComposedResponse) override;
  // cts-coverage-fidl-name:test.protocollayoutssamelibrary/ComposedProtocol.TwoWayAnonComposedWithError
  zx_status_t TwoWayAnonComposedWithError(::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedWithErrorRequest ComposedProtocolTwoWayAnonComposedWithErrorRequest, ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Result* out_ComposedProtocol_TwoWayAnonComposedWithError_Result) override;
  // cts-coverage-fidl-name:test.protocollayoutssamelibrary/ComposedProtocol.OneWayNamedComposed
  zx_status_t OneWayNamedComposed(::test::protocollayoutssamelibrary::TablePayload TablePayload) override;
  // cts-coverage-fidl-name:test.protocollayoutssamelibrary/ComposedProtocol.TwoWayNamedComposed
  zx_status_t TwoWayNamedComposed(::test::protocollayoutssamelibrary::UnionPayload UnionPayload, ::test::protocollayoutssamelibrary::TablePayload* out_TablePayload) override;
  // cts-coverage-fidl-name:test.protocollayoutssamelibrary/ComposedProtocol.TwoWayNamedComposedWithError
  zx_status_t TwoWayNamedComposedWithError(::test::protocollayoutssamelibrary::TablePayload TablePayload, ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayNamedComposedWithError_Result* out_ComposedProtocol_TwoWayNamedComposedWithError_Result) override;

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

#endif  // __Fuchsia__

#ifdef __Fuchsia__

class MainProtocol {
 public:
  using Proxy_ = ::test::protocollayoutssamelibrary::MainProtocol_Proxy;
  using Stub_ = ::test::protocollayoutssamelibrary::MainProtocol_Stub;
  using EventSender_ = ::test::protocollayoutssamelibrary::MainProtocol_EventSender;
  using Sync_ = ::test::protocollayoutssamelibrary::MainProtocol_Sync;
  virtual ~MainProtocol();
      
  virtual void OneWayAnonComposed(::test::protocollayoutssamelibrary::ComposedProtocolOneWayAnonComposedRequest ComposedProtocolOneWayAnonComposedRequest) = 0;
  using TwoWayAnonComposedCallback =
      fit::function<void(::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedResponse)>;
      
  virtual void TwoWayAnonComposed(::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedRequest ComposedProtocolTwoWayAnonComposedRequest, TwoWayAnonComposedCallback callback) = 0;
  using TwoWayAnonComposedWithErrorCallback =
      fit::function<void(::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Result)>;
      
  virtual void TwoWayAnonComposedWithError(::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedWithErrorRequest ComposedProtocolTwoWayAnonComposedWithErrorRequest, TwoWayAnonComposedWithErrorCallback callback) = 0;
  using OnAnonComposedCallback =
      fit::function<void(::test::protocollayoutssamelibrary::ComposedProtocolOnAnonComposedRequest)>;
      
  virtual void OneWayNamedComposed(::test::protocollayoutssamelibrary::TablePayload TablePayload) = 0;
  using TwoWayNamedComposedCallback =
      fit::function<void(::test::protocollayoutssamelibrary::TablePayload)>;
      
  virtual void TwoWayNamedComposed(::test::protocollayoutssamelibrary::UnionPayload UnionPayload, TwoWayNamedComposedCallback callback) = 0;
  using TwoWayNamedComposedWithErrorCallback =
      fit::function<void(::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayNamedComposedWithError_Result)>;
      
  virtual void TwoWayNamedComposedWithError(::test::protocollayoutssamelibrary::TablePayload TablePayload, TwoWayNamedComposedWithErrorCallback callback) = 0;
  using OnNamedComposedCallback =
      fit::function<void(::test::protocollayoutssamelibrary::UnionPayload)>;
      
  virtual void OneWayLocal(::test::protocollayoutssamelibrary::TablePayload TablePayload) = 0;
  using TwoWayLocalCallback =
      fit::function<void(::test::protocollayoutssamelibrary::TablePayload)>;
      
  virtual void TwoWayLocal(::test::protocollayoutssamelibrary::UnionPayload UnionPayload, TwoWayLocalCallback callback) = 0;
  using TwoWayLocalWithErrorCallback =
      fit::function<void(::test::protocollayoutssamelibrary::MainProtocol_TwoWayLocalWithError_Result)>;
      
  virtual void TwoWayLocalWithError(::test::protocollayoutssamelibrary::TablePayload TablePayload, TwoWayLocalWithErrorCallback callback) = 0;
  using OnLocalCallback =
      fit::function<void(::test::protocollayoutssamelibrary::UnionPayload)>;
      
  virtual void OneWayAnon(::test::protocollayoutssamelibrary::MainProtocolOneWayAnonRequest MainProtocolOneWayAnonRequest) = 0;
  using TwoWayAnonCallback =
      fit::function<void(::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonResponse)>;
      
  virtual void TwoWayAnon(::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonRequest MainProtocolTwoWayAnonRequest, TwoWayAnonCallback callback) = 0;
  using TwoWayAnonWithErrorCallback =
      fit::function<void(::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Result)>;
      
  virtual void TwoWayAnonWithError(::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonWithErrorRequest MainProtocolTwoWayAnonWithErrorRequest, TwoWayAnonWithErrorCallback callback) = 0;
  using OnAnonCallback =
      fit::function<void(::test::protocollayoutssamelibrary::MainProtocolOnAnonRequest)>;

  
};

class MainProtocol_RequestDecoder {
 public:
  MainProtocol_RequestDecoder() = default;
  virtual ~MainProtocol_RequestDecoder() = default;
  static const fidl_type_t* GetType(uint64_t ordinal, bool* out_needs_response, bool* is_known);
  virtual void OneWayAnonComposed(::test::protocollayoutssamelibrary::ComposedProtocolOneWayAnonComposedRequest ComposedProtocolOneWayAnonComposedRequest) = 0;
  virtual void TwoWayAnonComposed(::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedRequest ComposedProtocolTwoWayAnonComposedRequest) = 0;
  virtual void TwoWayAnonComposedWithError(::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedWithErrorRequest ComposedProtocolTwoWayAnonComposedWithErrorRequest) = 0;
  virtual void OneWayNamedComposed(::test::protocollayoutssamelibrary::TablePayload TablePayload) = 0;
  virtual void TwoWayNamedComposed(::test::protocollayoutssamelibrary::UnionPayload UnionPayload) = 0;
  virtual void TwoWayNamedComposedWithError(::test::protocollayoutssamelibrary::TablePayload TablePayload) = 0;
  virtual void OneWayLocal(::test::protocollayoutssamelibrary::TablePayload TablePayload) = 0;
  virtual void TwoWayLocal(::test::protocollayoutssamelibrary::UnionPayload UnionPayload) = 0;
  virtual void TwoWayLocalWithError(::test::protocollayoutssamelibrary::TablePayload TablePayload) = 0;
  virtual void OneWayAnon(::test::protocollayoutssamelibrary::MainProtocolOneWayAnonRequest MainProtocolOneWayAnonRequest) = 0;
  virtual void TwoWayAnon(::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonRequest MainProtocolTwoWayAnonRequest) = 0;
  virtual void TwoWayAnonWithError(::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonWithErrorRequest MainProtocolTwoWayAnonWithErrorRequest) = 0;
};

class MainProtocol_ResponseDecoder {
 public:
  MainProtocol_ResponseDecoder() = default;
  virtual ~MainProtocol_ResponseDecoder() = default;
  static const fidl_type_t* GetType(uint64_t ordinal);
  virtual void TwoWayAnonComposed(::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedResponse ComposedProtocolTwoWayAnonComposedResponse) = 0;
  virtual void TwoWayAnonComposedWithError(::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Result ComposedProtocol_TwoWayAnonComposedWithError_Result) = 0;
  virtual void OnAnonComposed(::test::protocollayoutssamelibrary::ComposedProtocolOnAnonComposedRequest ComposedProtocolOnAnonComposedRequest) = 0;
  virtual void TwoWayNamedComposed(::test::protocollayoutssamelibrary::TablePayload TablePayload) = 0;
  virtual void TwoWayNamedComposedWithError(::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayNamedComposedWithError_Result ComposedProtocol_TwoWayNamedComposedWithError_Result) = 0;
  virtual void OnNamedComposed(::test::protocollayoutssamelibrary::UnionPayload UnionPayload) = 0;
  virtual void TwoWayLocal(::test::protocollayoutssamelibrary::TablePayload TablePayload) = 0;
  virtual void TwoWayLocalWithError(::test::protocollayoutssamelibrary::MainProtocol_TwoWayLocalWithError_Result MainProtocol_TwoWayLocalWithError_Result) = 0;
  virtual void OnLocal(::test::protocollayoutssamelibrary::UnionPayload UnionPayload) = 0;
  virtual void TwoWayAnon(::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonResponse MainProtocolTwoWayAnonResponse) = 0;
  virtual void TwoWayAnonWithError(::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Result MainProtocol_TwoWayAnonWithError_Result) = 0;
  virtual void OnAnon(::test::protocollayoutssamelibrary::MainProtocolOnAnonRequest MainProtocolOnAnonRequest) = 0;
};

class MainProtocol_EventSender {
 public:
  virtual ~MainProtocol_EventSender();
  virtual void OnAnonComposed(::test::protocollayoutssamelibrary::ComposedProtocolOnAnonComposedRequest ComposedProtocolOnAnonComposedRequest) = 0;
  virtual void OnNamedComposed(::test::protocollayoutssamelibrary::UnionPayload UnionPayload) = 0;
  virtual void OnLocal(::test::protocollayoutssamelibrary::UnionPayload UnionPayload) = 0;
  virtual void OnAnon(::test::protocollayoutssamelibrary::MainProtocolOnAnonRequest MainProtocolOnAnonRequest) = 0;
};

class MainProtocol_Sync {
 public:
  using Proxy_ = ::test::protocollayoutssamelibrary::MainProtocol_SyncProxy;
  virtual ~MainProtocol_Sync();
  virtual zx_status_t OneWayAnonComposed(::test::protocollayoutssamelibrary::ComposedProtocolOneWayAnonComposedRequest ComposedProtocolOneWayAnonComposedRequest) = 0;
  virtual zx_status_t TwoWayAnonComposed(::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedRequest ComposedProtocolTwoWayAnonComposedRequest, ::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedResponse* out_ComposedProtocolTwoWayAnonComposedResponse) = 0;
  virtual zx_status_t TwoWayAnonComposedWithError(::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedWithErrorRequest ComposedProtocolTwoWayAnonComposedWithErrorRequest, ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Result* out_ComposedProtocol_TwoWayAnonComposedWithError_Result) = 0;
  virtual zx_status_t OneWayNamedComposed(::test::protocollayoutssamelibrary::TablePayload TablePayload) = 0;
  virtual zx_status_t TwoWayNamedComposed(::test::protocollayoutssamelibrary::UnionPayload UnionPayload, ::test::protocollayoutssamelibrary::TablePayload* out_TablePayload) = 0;
  virtual zx_status_t TwoWayNamedComposedWithError(::test::protocollayoutssamelibrary::TablePayload TablePayload, ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayNamedComposedWithError_Result* out_ComposedProtocol_TwoWayNamedComposedWithError_Result) = 0;
  virtual zx_status_t OneWayLocal(::test::protocollayoutssamelibrary::TablePayload TablePayload) = 0;
  virtual zx_status_t TwoWayLocal(::test::protocollayoutssamelibrary::UnionPayload UnionPayload, ::test::protocollayoutssamelibrary::TablePayload* out_TablePayload) = 0;
  virtual zx_status_t TwoWayLocalWithError(::test::protocollayoutssamelibrary::TablePayload TablePayload, ::test::protocollayoutssamelibrary::MainProtocol_TwoWayLocalWithError_Result* out_MainProtocol_TwoWayLocalWithError_Result) = 0;
  virtual zx_status_t OneWayAnon(::test::protocollayoutssamelibrary::MainProtocolOneWayAnonRequest MainProtocolOneWayAnonRequest) = 0;
  virtual zx_status_t TwoWayAnon(::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonRequest MainProtocolTwoWayAnonRequest, ::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonResponse* out_MainProtocolTwoWayAnonResponse) = 0;
  virtual zx_status_t TwoWayAnonWithError(::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonWithErrorRequest MainProtocolTwoWayAnonWithErrorRequest, ::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Result* out_MainProtocol_TwoWayAnonWithError_Result) = 0;
};

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

  zx_status_t Dispatch_(::fidl::HLCPPIncomingMessage message) override;
  // cts-coverage-fidl-name:test.protocollayoutssamelibrary/MainProtocol.OneWayAnonComposed
  void OneWayAnonComposed(::test::protocollayoutssamelibrary::ComposedProtocolOneWayAnonComposedRequest ComposedProtocolOneWayAnonComposedRequest) override;
  // cts-coverage-fidl-name:test.protocollayoutssamelibrary/MainProtocol.TwoWayAnonComposed
  void TwoWayAnonComposed(::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedRequest ComposedProtocolTwoWayAnonComposedRequest, TwoWayAnonComposedCallback callback) override;
  // cts-coverage-fidl-name:test.protocollayoutssamelibrary/MainProtocol.TwoWayAnonComposedWithError
  void TwoWayAnonComposedWithError(::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedWithErrorRequest ComposedProtocolTwoWayAnonComposedWithErrorRequest, TwoWayAnonComposedWithErrorCallback callback) override;
  OnAnonComposedCallback OnAnonComposed;
  // cts-coverage-fidl-name:test.protocollayoutssamelibrary/MainProtocol.OneWayNamedComposed
  void OneWayNamedComposed(::test::protocollayoutssamelibrary::TablePayload TablePayload) override;
  // cts-coverage-fidl-name:test.protocollayoutssamelibrary/MainProtocol.TwoWayNamedComposed
  void TwoWayNamedComposed(::test::protocollayoutssamelibrary::UnionPayload UnionPayload, TwoWayNamedComposedCallback callback) override;
  // cts-coverage-fidl-name:test.protocollayoutssamelibrary/MainProtocol.TwoWayNamedComposedWithError
  void TwoWayNamedComposedWithError(::test::protocollayoutssamelibrary::TablePayload TablePayload, TwoWayNamedComposedWithErrorCallback callback) override;
  OnNamedComposedCallback OnNamedComposed;
  // cts-coverage-fidl-name:test.protocollayoutssamelibrary/MainProtocol.OneWayLocal
  void OneWayLocal(::test::protocollayoutssamelibrary::TablePayload TablePayload) override;
  // cts-coverage-fidl-name:test.protocollayoutssamelibrary/MainProtocol.TwoWayLocal
  void TwoWayLocal(::test::protocollayoutssamelibrary::UnionPayload UnionPayload, TwoWayLocalCallback callback) override;
  // cts-coverage-fidl-name:test.protocollayoutssamelibrary/MainProtocol.TwoWayLocalWithError
  void TwoWayLocalWithError(::test::protocollayoutssamelibrary::TablePayload TablePayload, TwoWayLocalWithErrorCallback callback) override;
  OnLocalCallback OnLocal;
  // cts-coverage-fidl-name:test.protocollayoutssamelibrary/MainProtocol.OneWayAnon
  void OneWayAnon(::test::protocollayoutssamelibrary::MainProtocolOneWayAnonRequest MainProtocolOneWayAnonRequest) override;
  // cts-coverage-fidl-name:test.protocollayoutssamelibrary/MainProtocol.TwoWayAnon
  void TwoWayAnon(::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonRequest MainProtocolTwoWayAnonRequest, TwoWayAnonCallback callback) override;
  // cts-coverage-fidl-name:test.protocollayoutssamelibrary/MainProtocol.TwoWayAnonWithError
  void TwoWayAnonWithError(::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonWithErrorRequest MainProtocolTwoWayAnonWithErrorRequest, TwoWayAnonWithErrorCallback callback) override;
  OnAnonCallback OnAnon;

  
 private:
  MainProtocol_Proxy(const ::test::protocollayoutssamelibrary::MainProtocol_Proxy&) = delete;
  MainProtocol_Proxy& operator=(const ::test::protocollayoutssamelibrary::MainProtocol_Proxy&) = delete;

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

class MainProtocol_Stub final : public ::fidl::internal::Stub, public ::test::protocollayoutssamelibrary::MainProtocol_EventSender {
 public:
  typedef class ::test::protocollayoutssamelibrary::MainProtocol MainProtocol_clazz;
  explicit MainProtocol_Stub(::test::protocollayoutssamelibrary::MainProtocol_Stub::MainProtocol_clazz* impl);
  ~MainProtocol_Stub() override;

  zx_status_t Dispatch_(::fidl::HLCPPIncomingMessage message,
                        ::fidl::internal::PendingResponse response) override;
  void OnAnonComposed(::test::protocollayoutssamelibrary::ComposedProtocolOnAnonComposedRequest ComposedProtocolOnAnonComposedRequest) override;
  void OnNamedComposed(::test::protocollayoutssamelibrary::UnionPayload UnionPayload) override;
  void OnLocal(::test::protocollayoutssamelibrary::UnionPayload UnionPayload) override;
  void OnAnon(::test::protocollayoutssamelibrary::MainProtocolOnAnonRequest MainProtocolOnAnonRequest) override;

 private:
  ::test::protocollayoutssamelibrary::MainProtocol_Stub::MainProtocol_clazz* impl_;
};

class MainProtocol_SyncProxy : public ::test::protocollayoutssamelibrary::MainProtocol_Sync {
 public:
  explicit MainProtocol_SyncProxy(::zx::channel channel);
  ~MainProtocol_SyncProxy() override;
  // cts-coverage-fidl-name:test.protocollayoutssamelibrary/MainProtocol.OneWayAnonComposed
  zx_status_t OneWayAnonComposed(::test::protocollayoutssamelibrary::ComposedProtocolOneWayAnonComposedRequest ComposedProtocolOneWayAnonComposedRequest) override;
  // cts-coverage-fidl-name:test.protocollayoutssamelibrary/MainProtocol.TwoWayAnonComposed
  zx_status_t TwoWayAnonComposed(::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedRequest ComposedProtocolTwoWayAnonComposedRequest, ::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedResponse* out_ComposedProtocolTwoWayAnonComposedResponse) override;
  // cts-coverage-fidl-name:test.protocollayoutssamelibrary/MainProtocol.TwoWayAnonComposedWithError
  zx_status_t TwoWayAnonComposedWithError(::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedWithErrorRequest ComposedProtocolTwoWayAnonComposedWithErrorRequest, ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Result* out_ComposedProtocol_TwoWayAnonComposedWithError_Result) override;
  // cts-coverage-fidl-name:test.protocollayoutssamelibrary/MainProtocol.OneWayNamedComposed
  zx_status_t OneWayNamedComposed(::test::protocollayoutssamelibrary::TablePayload TablePayload) override;
  // cts-coverage-fidl-name:test.protocollayoutssamelibrary/MainProtocol.TwoWayNamedComposed
  zx_status_t TwoWayNamedComposed(::test::protocollayoutssamelibrary::UnionPayload UnionPayload, ::test::protocollayoutssamelibrary::TablePayload* out_TablePayload) override;
  // cts-coverage-fidl-name:test.protocollayoutssamelibrary/MainProtocol.TwoWayNamedComposedWithError
  zx_status_t TwoWayNamedComposedWithError(::test::protocollayoutssamelibrary::TablePayload TablePayload, ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayNamedComposedWithError_Result* out_ComposedProtocol_TwoWayNamedComposedWithError_Result) override;
  // cts-coverage-fidl-name:test.protocollayoutssamelibrary/MainProtocol.OneWayLocal
  zx_status_t OneWayLocal(::test::protocollayoutssamelibrary::TablePayload TablePayload) override;
  // cts-coverage-fidl-name:test.protocollayoutssamelibrary/MainProtocol.TwoWayLocal
  zx_status_t TwoWayLocal(::test::protocollayoutssamelibrary::UnionPayload UnionPayload, ::test::protocollayoutssamelibrary::TablePayload* out_TablePayload) override;
  // cts-coverage-fidl-name:test.protocollayoutssamelibrary/MainProtocol.TwoWayLocalWithError
  zx_status_t TwoWayLocalWithError(::test::protocollayoutssamelibrary::TablePayload TablePayload, ::test::protocollayoutssamelibrary::MainProtocol_TwoWayLocalWithError_Result* out_MainProtocol_TwoWayLocalWithError_Result) override;
  // cts-coverage-fidl-name:test.protocollayoutssamelibrary/MainProtocol.OneWayAnon
  zx_status_t OneWayAnon(::test::protocollayoutssamelibrary::MainProtocolOneWayAnonRequest MainProtocolOneWayAnonRequest) override;
  // cts-coverage-fidl-name:test.protocollayoutssamelibrary/MainProtocol.TwoWayAnon
  zx_status_t TwoWayAnon(::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonRequest MainProtocolTwoWayAnonRequest, ::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonResponse* out_MainProtocolTwoWayAnonResponse) override;
  // cts-coverage-fidl-name:test.protocollayoutssamelibrary/MainProtocol.TwoWayAnonWithError
  zx_status_t TwoWayAnonWithError(::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonWithErrorRequest MainProtocolTwoWayAnonWithErrorRequest, ::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Result* out_MainProtocol_TwoWayAnonWithError_Result) override;

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

#endif  // __Fuchsia__

}  // namespace protocollayoutssamelibrary
}  // namespace test