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

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

// fidl_experiment = output_index_json

#pragma once

#include <test/protocollayouts/imported/cpp/fidl.h>

#include "lib/fidl/cpp/internal/header.h"
namespace test {
namespace protocollayouts {

//
// Domain objects declarations
//

class LocalTablePayload;

class LocalUnionPayload;

class MainProtocol_TwoWayImportWithError_Result;

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__

#ifdef __Fuchsia__

class OpenProtocol;
using OpenProtocolHandle = ::fidl::InterfaceHandle<OpenProtocol>;

#endif  // __Fuchsia__

class LocalTablePayload 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;
  }
  LocalTablePayload& set_a(uint16_t _value);
  void clear_a() {
    if (!field_presence_.IsSet<0>()) {
      return;
    }
    field_presence_.Clear<0>();
    Destruct(&a_value_.value);
  }

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

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

  void Encode(::fidl::Encoder* _encoder, size_t _offset,
              cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt);
  static void Decode(::fidl::Decoder* _decoder, LocalTablePayload* _value, size_t _offset);
  zx_status_t Clone(LocalTablePayload* _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 LocalTablePayloadPtr = ::std::unique_ptr<LocalTablePayload>;

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

  LocalUnionPayload();
  ~LocalUnionPayload();

  LocalUnionPayload(LocalUnionPayload&&);
  LocalUnionPayload& operator=(LocalUnionPayload&&);

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

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

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

  bool is_b() const { return tag_ == ::test::protocollayouts::LocalUnionPayload::Tag::kB; }

  bool& b() {
    EnsureStorageInitialized(::test::protocollayouts::LocalUnionPayload::Tag::kB);
    return b_;
  }

  const bool& b() const {
    ZX_ASSERT(is_b());
    return b_;
  }
  LocalUnionPayload& set_b(bool value);
  LocalUnionPayload& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes);

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

  friend ::fidl::Equality<::test::protocollayouts::LocalUnionPayload>;

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

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

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

using LocalUnionPayloadPtr = ::std::unique_ptr<LocalUnionPayload>;

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

  MainProtocol_TwoWayImportWithError_Result();
  ~MainProtocol_TwoWayImportWithError_Result();

  MainProtocol_TwoWayImportWithError_Result(MainProtocol_TwoWayImportWithError_Result&&);
  MainProtocol_TwoWayImportWithError_Result& operator=(MainProtocol_TwoWayImportWithError_Result&&);

  static MainProtocol_TwoWayImportWithError_Result WithResponse(::test::protocollayouts::imported::ImportUnionPayload&&);
  static MainProtocol_TwoWayImportWithError_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_TwoWayImportWithError_Result> New() { return ::std::make_unique<MainProtocol_TwoWayImportWithError_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_TwoWayImportWithError_Result* value, size_t offset);
  zx_status_t Clone(MainProtocol_TwoWayImportWithError_Result* result) const;

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

  bool is_response() const { return tag_ == ::test::protocollayouts::MainProtocol_TwoWayImportWithError_Result::Tag::kResponse; }

  ::test::protocollayouts::imported::ImportUnionPayload& response() {
    EnsureStorageInitialized(::test::protocollayouts::MainProtocol_TwoWayImportWithError_Result::Tag::kResponse);
    return response_;
  }

  const ::test::protocollayouts::imported::ImportUnionPayload& response() const {
    ZX_ASSERT(is_response());
    return response_;
  }
  MainProtocol_TwoWayImportWithError_Result& set_response(::test::protocollayouts::imported::ImportUnionPayload value);

  bool is_err() const { return tag_ == ::test::protocollayouts::MainProtocol_TwoWayImportWithError_Result::Tag::kErr; }

  uint32_t& err() {
    EnsureStorageInitialized(::test::protocollayouts::MainProtocol_TwoWayImportWithError_Result::Tag::kErr);
    return err_;
  }

  const uint32_t& err() const {
    ZX_ASSERT(is_err());
    return err_;
  }
  MainProtocol_TwoWayImportWithError_Result& set_err(uint32_t value);

  ::test::protocollayouts::MainProtocol_TwoWayImportWithError_Result::Tag Which() const {
    return ::test::protocollayouts::MainProtocol_TwoWayImportWithError_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::protocollayouts::MainProtocol_TwoWayImportWithError_Result>;

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

  ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::protocollayouts::MainProtocol_TwoWayImportWithError_Result::Tag::Invalid);
  union {
    ::test::protocollayouts::imported::ImportUnionPayload response_;
    uint32_t err_;
  };
};

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

using MainProtocol_TwoWayImportWithError_ResultPtr = ::std::unique_ptr<MainProtocol_TwoWayImportWithError_Result>;

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::protocollayouts::LocalUnionPayload&&);
  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::protocollayouts::MainProtocol_TwoWayLocalWithError_Result::Tag::kResponse; }

  ::test::protocollayouts::LocalUnionPayload& response() {
    EnsureStorageInitialized(::test::protocollayouts::MainProtocol_TwoWayLocalWithError_Result::Tag::kResponse);
    return response_;
  }

  const ::test::protocollayouts::LocalUnionPayload& response() const {
    ZX_ASSERT(is_response());
    return response_;
  }
  MainProtocol_TwoWayLocalWithError_Result& set_response(::test::protocollayouts::LocalUnionPayload value);

  bool is_err() const { return tag_ == ::test::protocollayouts::MainProtocol_TwoWayLocalWithError_Result::Tag::kErr; }

  uint32_t& err() {
    EnsureStorageInitialized(::test::protocollayouts::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::protocollayouts::MainProtocol_TwoWayLocalWithError_Result::Tag Which() const {
    return ::test::protocollayouts::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::protocollayouts::MainProtocol_TwoWayLocalWithError_Result>;
  MainProtocol_TwoWayLocalWithError_Result(fpromise::ok_result<::test::protocollayouts::LocalUnionPayload>&& result) {
    set_response(::test::protocollayouts::LocalUnionPayload{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::protocollayouts::LocalUnionPayload, uint32_t>&& result) {
    ZX_ASSERT(!result.is_pending());
    if (result.is_ok()) {
      set_response(::test::protocollayouts::LocalUnionPayload{result.take_value()});
    } else {
      set_err(result.take_error());
    }
  }
  operator fpromise::result<::test::protocollayouts::LocalUnionPayload, uint32_t>() && {
    if (is_err()) {
      return fpromise::error(err());
    }
    ::std::tuple<::test::protocollayouts::LocalUnionPayload> 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::protocollayouts::MainProtocol_TwoWayLocalWithError_Result::Tag::Invalid);
  union {
    ::test::protocollayouts::LocalUnionPayload response_;
    uint32_t err_;
  };
};

inline zx_status_t Clone(const ::test::protocollayouts::MainProtocol_TwoWayLocalWithError_Result& value,
                         ::test::protocollayouts::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::protocollayouts::MainProtocolTwoWayAnonRequest::Tag::kB; }

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

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

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

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

inline zx_status_t Clone(const ::test::protocollayouts::MainProtocolTwoWayAnonRequest& value,
                         ::test::protocollayouts::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::protocollayouts::MainProtocol_TwoWayAnonWithError_Response::Tag::kB; }

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

  friend ::fidl::Equality<::test::protocollayouts::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::protocollayouts::MainProtocol_TwoWayAnonWithError_Response::Tag::Invalid);
  union {
    bool b_;
    std::vector<uint8_t> unknown_data_;
  };
};

inline zx_status_t Clone(const ::test::protocollayouts::MainProtocol_TwoWayAnonWithError_Response& value,
                         ::test::protocollayouts::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::protocollayouts::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::protocollayouts::MainProtocol_TwoWayAnonWithError_Result::Tag::kResponse; }

  ::test::protocollayouts::MainProtocol_TwoWayAnonWithError_Response& response() {
    EnsureStorageInitialized(::test::protocollayouts::MainProtocol_TwoWayAnonWithError_Result::Tag::kResponse);
    return response_;
  }

  const ::test::protocollayouts::MainProtocol_TwoWayAnonWithError_Response& response() const {
    ZX_ASSERT(is_response());
    return response_;
  }
  MainProtocol_TwoWayAnonWithError_Result& set_response(::test::protocollayouts::MainProtocol_TwoWayAnonWithError_Response value);

  bool is_err() const { return tag_ == ::test::protocollayouts::MainProtocol_TwoWayAnonWithError_Result::Tag::kErr; }

  uint32_t& err() {
    EnsureStorageInitialized(::test::protocollayouts::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::protocollayouts::MainProtocol_TwoWayAnonWithError_Result::Tag Which() const {
    return ::test::protocollayouts::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::protocollayouts::MainProtocol_TwoWayAnonWithError_Result>;
  MainProtocol_TwoWayAnonWithError_Result(fpromise::ok_result<::test::protocollayouts::MainProtocol_TwoWayAnonWithError_Response>&& result) {
    set_response(::test::protocollayouts::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::protocollayouts::MainProtocol_TwoWayAnonWithError_Response, uint32_t>&& result) {
    ZX_ASSERT(!result.is_pending());
    if (result.is_ok()) {
      set_response(::test::protocollayouts::MainProtocol_TwoWayAnonWithError_Response{result.take_value()});
    } else {
      set_err(result.take_error());
    }
  }
  operator fpromise::result<::test::protocollayouts::MainProtocol_TwoWayAnonWithError_Response, uint32_t>() && {
    if (is_err()) {
      return fpromise::error(err());
    }
    ::std::tuple<::test::protocollayouts::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::protocollayouts::MainProtocol_TwoWayAnonWithError_Result::Tag::Invalid);
  union {
    ::test::protocollayouts::MainProtocol_TwoWayAnonWithError_Response response_;
    uint32_t err_;
  };
};

inline zx_status_t Clone(const ::test::protocollayouts::MainProtocol_TwoWayAnonWithError_Result& value,
                         ::test::protocollayouts::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::protocollayouts::MainProtocolOnAnonRequest::Tag::kB; }

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

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

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

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

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

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

#ifdef __Fuchsia__

namespace _internal {
__LOCAL extern "C" const fidl_type_t test_protocollayouts_imported_ComposedProtocolOneWayAnonComposedRequestTable;

__LOCAL extern "C" const fidl_type_t test_protocollayouts_imported_ComposedProtocolTwoWayAnonComposedRequestTable;

__LOCAL extern "C" const fidl_type_t test_protocollayouts_imported_ComposedProtocolTwoWayAnonComposedWithErrorRequestTable;

__LOCAL extern "C" const fidl_type_t test_protocollayouts_imported_ImportTablePayloadTable;

__LOCAL extern "C" const fidl_type_t test_protocollayouts_imported_ImportUnionPayloadTable;

__LOCAL extern "C" const fidl_type_t test_protocollayouts_LocalTablePayloadTable;

__LOCAL extern "C" const fidl_type_t test_protocollayouts_LocalUnionPayloadTable;

__LOCAL extern "C" const fidl_type_t test_protocollayouts_MainProtocolOneWayAnonRequestTable;

__LOCAL extern "C" const fidl_type_t test_protocollayouts_MainProtocolTwoWayAnonRequestTable;

__LOCAL extern "C" const fidl_type_t test_protocollayouts_MainProtocolTwoWayAnonWithErrorRequestTable;

}  // namespace _internal

class MainProtocol_RequestEncoder {
 public:
  static ::fidl::HLCPPOutgoingMessage OneWayAnonComposed(::fidl::MessageEncoder* _encoder, ::test::protocollayouts::imported::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::protocollayouts::imported::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::protocollayouts::imported::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::protocollayouts::imported::ImportTablePayload* ImportTablePayload) {
    _encoder->Alloc(16);
    ::fidl::Encode(_encoder, ImportTablePayload, 0 + sizeof(fidl_message_header_t));

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

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

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage OneWayImport(::fidl::MessageEncoder* _encoder, ::test::protocollayouts::imported::ImportTablePayload* ImportTablePayload) {
    _encoder->Alloc(16);
    ::fidl::Encode(_encoder, ImportTablePayload, 0 + sizeof(fidl_message_header_t));

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage TwoWayImport(::fidl::MessageEncoder* _encoder, ::test::protocollayouts::imported::ImportUnionPayload* ImportUnionPayload) {
    _encoder->Alloc(16);
    ::fidl::Encode(_encoder, ImportUnionPayload, 0 + sizeof(fidl_message_header_t));

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage TwoWayImportWithError(::fidl::MessageEncoder* _encoder, ::test::protocollayouts::imported::ImportTablePayload* ImportTablePayload) {
    _encoder->Alloc(16);
    ::fidl::Encode(_encoder, ImportTablePayload, 0 + sizeof(fidl_message_header_t));

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

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

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

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage OneWayAnon(::fidl::MessageEncoder* _encoder, ::test::protocollayouts::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::protocollayouts::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::protocollayouts::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_protocollayouts_imported_ComposedProtocolTwoWayAnonComposedResponseTable;

__LOCAL extern "C" const fidl_type_t test_protocollayouts_imported_ComposedProtocol_TwoWayAnonComposedWithError_ResultTable;

__LOCAL extern "C" const fidl_type_t test_protocollayouts_imported_ComposedProtocolOnAnonComposedRequestTable;

__LOCAL extern "C" const fidl_type_t test_protocollayouts_imported_ComposedProtocol_TwoWayNamedComposedWithError_ResultTable;

__LOCAL extern "C" const fidl_type_t test_protocollayouts_MainProtocol_TwoWayImportWithError_ResultTable;

__LOCAL extern "C" const fidl_type_t test_protocollayouts_MainProtocol_TwoWayLocalWithError_ResultTable;

__LOCAL extern "C" const fidl_type_t test_protocollayouts_MainProtocolTwoWayAnonResponseTable;

__LOCAL extern "C" const fidl_type_t test_protocollayouts_MainProtocol_TwoWayAnonWithError_ResultTable;

__LOCAL extern "C" const fidl_type_t test_protocollayouts_MainProtocolOnAnonRequestTable;

}  // namespace _internal

class MainProtocol_ResponseEncoder {
 public:
  static ::fidl::HLCPPOutgoingMessage TwoWayAnonComposed(::fidl::MessageEncoder* _encoder, ::test::protocollayouts::imported::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::protocollayouts::imported::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::protocollayouts::imported::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::protocollayouts::imported::ImportTablePayload* ImportTablePayload) {
    _encoder->Alloc(16);
    ::fidl::Encode(_encoder, ImportTablePayload, 0 + sizeof(fidl_message_header_t));

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage TwoWayNamedComposedWithError(::fidl::MessageEncoder* _encoder, ::test::protocollayouts::imported::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::protocollayouts::imported::ImportUnionPayload* ImportUnionPayload) {
    _encoder->Alloc(16);
    ::fidl::Encode(_encoder, ImportUnionPayload, 0 + sizeof(fidl_message_header_t));

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage TwoWayImport(::fidl::MessageEncoder* _encoder, ::test::protocollayouts::imported::ImportTablePayload* ImportTablePayload) {
    _encoder->Alloc(16);
    ::fidl::Encode(_encoder, ImportTablePayload, 0 + sizeof(fidl_message_header_t));

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

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage OnImport(::fidl::MessageEncoder* _encoder, ::test::protocollayouts::imported::ImportUnionPayload* ImportUnionPayload) {
    _encoder->Alloc(16);
    ::fidl::Encode(_encoder, ImportUnionPayload, 0 + sizeof(fidl_message_header_t));

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

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage TwoWayLocalWithError(::fidl::MessageEncoder* _encoder, ::test::protocollayouts::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::protocollayouts::LocalUnionPayload* LocalUnionPayload) {
    _encoder->Alloc(16);
    ::fidl::Encode(_encoder, LocalUnionPayload, 0 + sizeof(fidl_message_header_t));

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage TwoWayAnon(::fidl::MessageEncoder* _encoder, ::test::protocollayouts::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::protocollayouts::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::protocollayouts::MainProtocolOnAnonRequest* MainProtocolOnAnonRequest) {
    _encoder->Alloc(16);
    ::fidl::Encode(_encoder, MainProtocolOnAnonRequest, 0 + sizeof(fidl_message_header_t));

    return _encoder->GetMessage();
  }
};

#endif  // __Fuchsia__

#ifdef __Fuchsia__

namespace _internal {
__LOCAL extern "C" const fidl_type_t test_protocollayouts_imported_ComposedOpenProtocolFlexibleOneWayRequestTable;

__LOCAL extern "C" const fidl_type_t test_protocollayouts_imported_ComposedOpenProtocolFlexibleTwoWayNoErrorRequestTable;

__LOCAL extern "C" const fidl_type_t test_protocollayouts_imported_ComposedOpenProtocolFlexibleTwoWayWithErrorRequestTable;

__LOCAL extern "C" const fidl_type_t test_protocollayouts_imported_ComposedOpenProtocolStrictOneWayRequestTable;

__LOCAL extern "C" const fidl_type_t test_protocollayouts_imported_ComposedOpenProtocolStrictTwoWayNoErrorRequestTable;

__LOCAL extern "C" const fidl_type_t test_protocollayouts_imported_ComposedOpenProtocolStrictTwoWayWithErrorRequestTable;

__LOCAL extern "C" const fidl_type_t test_protocollayouts_imported_ImportStructPayloadTable;

}  // namespace _internal

class OpenProtocol_RequestEncoder {
 public:
  static ::fidl::HLCPPOutgoingMessage FlexibleOneWay(::fidl::MessageEncoder* _encoder, int32_t* value) {
    _encoder->Alloc(4);
    ::fidl::Encode(_encoder, value, 0 + sizeof(fidl_message_header_t));

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage FlexibleTwoWayNoError(::fidl::MessageEncoder* _encoder, int32_t* value) {
    _encoder->Alloc(4);
    ::fidl::Encode(_encoder, value, 0 + sizeof(fidl_message_header_t));

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage FlexibleTwoWayWithError(::fidl::MessageEncoder* _encoder, int32_t* value) {
    _encoder->Alloc(4);
    ::fidl::Encode(_encoder, value, 0 + sizeof(fidl_message_header_t));

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage StrictOneWay(::fidl::MessageEncoder* _encoder, int32_t* value) {
    _encoder->Alloc(4);
    ::fidl::Encode(_encoder, value, 0 + sizeof(fidl_message_header_t));

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage StrictTwoWayNoError(::fidl::MessageEncoder* _encoder, int32_t* value) {
    _encoder->Alloc(4);
    ::fidl::Encode(_encoder, value, 0 + sizeof(fidl_message_header_t));

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage StrictTwoWayWithError(::fidl::MessageEncoder* _encoder, int32_t* value) {
    _encoder->Alloc(4);
    ::fidl::Encode(_encoder, value, 0 + sizeof(fidl_message_header_t));

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage FlexibleOneWayNamedPayload(::fidl::MessageEncoder* _encoder, int32_t* value) {
    _encoder->Alloc(4);
    ::fidl::Encode(_encoder, value, 0 + sizeof(fidl_message_header_t));

    return _encoder->GetMessage();
  }
};

namespace _internal {
__LOCAL extern "C" const fidl_type_t test_protocollayouts_imported_ComposedOpenProtocol_FlexibleTwoWayNoError_ResultTable;

__LOCAL extern "C" const fidl_type_t test_protocollayouts_imported_ComposedOpenProtocol_FlexibleTwoWayWithError_ResultTable;

__LOCAL extern "C" const fidl_type_t test_protocollayouts_imported_ComposedOpenProtocolFlexibleEventRequestTable;

__LOCAL extern "C" const fidl_type_t test_protocollayouts_imported_ComposedOpenProtocolStrictTwoWayNoErrorResponseTable;

__LOCAL extern "C" const fidl_type_t test_protocollayouts_imported_ComposedOpenProtocol_StrictTwoWayWithError_ResultTable;

__LOCAL extern "C" const fidl_type_t test_protocollayouts_imported_ComposedOpenProtocolStrictEventRequestTable;

}  // namespace _internal

class OpenProtocol_ResponseEncoder {
 public:
  static ::fidl::HLCPPOutgoingMessage FlexibleTwoWayNoError(::fidl::MessageEncoder* _encoder, ::test::protocollayouts::imported::ComposedOpenProtocol_FlexibleTwoWayNoError_Result* ComposedOpenProtocol_FlexibleTwoWayNoError_Result) {
    _encoder->Alloc(16);
    ::fidl::Encode(_encoder, ComposedOpenProtocol_FlexibleTwoWayNoError_Result, 0 + sizeof(fidl_message_header_t));

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage FlexibleTwoWayWithError(::fidl::MessageEncoder* _encoder, ::test::protocollayouts::imported::ComposedOpenProtocol_FlexibleTwoWayWithError_Result* ComposedOpenProtocol_FlexibleTwoWayWithError_Result) {
    _encoder->Alloc(16);
    ::fidl::Encode(_encoder, ComposedOpenProtocol_FlexibleTwoWayWithError_Result, 0 + sizeof(fidl_message_header_t));

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage FlexibleEvent(::fidl::MessageEncoder* _encoder, int32_t* value) {
    _encoder->Alloc(4);
    ::fidl::Encode(_encoder, value, 0 + sizeof(fidl_message_header_t));

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage StrictTwoWayNoError(::fidl::MessageEncoder* _encoder, int32_t* value) {
    _encoder->Alloc(4);
    ::fidl::Encode(_encoder, value, 0 + sizeof(fidl_message_header_t));

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage StrictTwoWayWithError(::fidl::MessageEncoder* _encoder, ::test::protocollayouts::imported::ComposedOpenProtocol_StrictTwoWayWithError_Result* ComposedOpenProtocol_StrictTwoWayWithError_Result) {
    _encoder->Alloc(16);
    ::fidl::Encode(_encoder, ComposedOpenProtocol_StrictTwoWayWithError_Result, 0 + sizeof(fidl_message_header_t));

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage StrictEvent(::fidl::MessageEncoder* _encoder, int32_t* value) {
    _encoder->Alloc(4);
    ::fidl::Encode(_encoder, value, 0 + sizeof(fidl_message_header_t));

    return _encoder->GetMessage();
  }
};

#endif  // __Fuchsia__

}  // namespace protocollayouts
}  // namespace test
namespace fidl {

template <>
struct CodingTraits<::test::protocollayouts::LocalTablePayload>
    : public EncodableCodingTraits<::test::protocollayouts::LocalTablePayload, 16> {};

inline zx_status_t Clone(const ::test::protocollayouts::LocalTablePayload& _value,
                         ::test::protocollayouts::LocalTablePayload* result) {
  return _value.Clone(result);
}
template <>
struct Equality<::test::protocollayouts::LocalTablePayload> {
  bool operator()(const ::test::protocollayouts::LocalTablePayload& _lhs, const ::test::protocollayouts::LocalTablePayload& _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::protocollayouts::LocalUnionPayload> : public std::true_type {};

template <>
struct CodingTraits<::test::protocollayouts::LocalUnionPayload>
    : public EncodableCodingTraits<::test::protocollayouts::LocalUnionPayload, 16> {};

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

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

    ::test::protocollayouts::LocalUnionPayload::Decode(_decoder, value->get(), offset);
  }
};

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

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

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

template <>
struct CodingTraits<::test::protocollayouts::MainProtocol_TwoWayImportWithError_Result>
    : public EncodableCodingTraits<::test::protocollayouts::MainProtocol_TwoWayImportWithError_Result, 16> {};

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

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

    ::test::protocollayouts::MainProtocol_TwoWayImportWithError_Result::Decode(_decoder, value->get(), offset);
  }
};

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::protocollayouts::MainProtocol_TwoWayImportWithError_Result::Tag::Invalid):
        return true;
      case ::test::protocollayouts::MainProtocol_TwoWayImportWithError_Result::Tag::kResponse:
        return ::fidl::Equals(_lhs.response_, _rhs.response_);
      case ::test::protocollayouts::MainProtocol_TwoWayImportWithError_Result::Tag::kErr:
        return ::fidl::Equals(_lhs.err_, _rhs.err_);

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

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

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

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

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

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::protocollayouts::MainProtocol_TwoWayLocalWithError_Result::Tag::Invalid):
        return true;
      case ::test::protocollayouts::MainProtocol_TwoWayLocalWithError_Result::Tag::kResponse:
        return ::fidl::Equals(_lhs.response_, _rhs.response_);
      case ::test::protocollayouts::MainProtocol_TwoWayLocalWithError_Result::Tag::kErr:
        return ::fidl::Equals(_lhs.err_, _rhs.err_);

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

inline zx_status_t Clone(const ::test::protocollayouts::MainProtocolOneWayAnonRequest& _value,
                         ::test::protocollayouts::MainProtocolOneWayAnonRequest* result) {
  return _value.Clone(result);
}
template <>
struct Equality<::test::protocollayouts::MainProtocolOneWayAnonRequest> {
  bool operator()(const ::test::protocollayouts::MainProtocolOneWayAnonRequest& _lhs, const ::test::protocollayouts::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::protocollayouts::MainProtocolTwoWayAnonRequest> : public std::true_type {};

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

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

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

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

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

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

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

inline zx_status_t Clone(const ::test::protocollayouts::MainProtocolTwoWayAnonResponse& _value,
                         ::test::protocollayouts::MainProtocolTwoWayAnonResponse* result) {
  return _value.Clone(result);
}
template <>
struct Equality<::test::protocollayouts::MainProtocolTwoWayAnonResponse> {
  bool operator()(const ::test::protocollayouts::MainProtocolTwoWayAnonResponse& _lhs, const ::test::protocollayouts::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::protocollayouts::MainProtocolTwoWayAnonWithErrorRequest>
    : public EncodableCodingTraits<::test::protocollayouts::MainProtocolTwoWayAnonWithErrorRequest, 16> {};

inline zx_status_t Clone(const ::test::protocollayouts::MainProtocolTwoWayAnonWithErrorRequest& _value,
                         ::test::protocollayouts::MainProtocolTwoWayAnonWithErrorRequest* result) {
  return _value.Clone(result);
}
template <>
struct Equality<::test::protocollayouts::MainProtocolTwoWayAnonWithErrorRequest> {
  bool operator()(const ::test::protocollayouts::MainProtocolTwoWayAnonWithErrorRequest& _lhs, const ::test::protocollayouts::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::protocollayouts::MainProtocol_TwoWayAnonWithError_Response> : public std::true_type {};

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

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

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

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

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::protocollayouts::MainProtocol_TwoWayAnonWithError_Response::Tag::Invalid):
        return true;
      case ::test::protocollayouts::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::protocollayouts::MainProtocol_TwoWayAnonWithError_Result> : public std::true_type {};

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

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

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

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

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::protocollayouts::MainProtocol_TwoWayAnonWithError_Result::Tag::Invalid):
        return true;
      case ::test::protocollayouts::MainProtocol_TwoWayAnonWithError_Result::Tag::kResponse:
        return ::fidl::Equals(_lhs.response_, _rhs.response_);
      case ::test::protocollayouts::MainProtocol_TwoWayAnonWithError_Result::Tag::kErr:
        return ::fidl::Equals(_lhs.err_, _rhs.err_);

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

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

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

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

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

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

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

    switch (_lhs.Ordinal()) {
      case static_cast<fidl_xunion_tag_t>(::test::protocollayouts::MainProtocolOnAnonRequest::Tag::Invalid):
        return true;
      case ::test::protocollayouts::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 protocollayouts {

#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 = 0x67da05e1ae3f5e1lu;

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

constexpr uint64_t kMainProtocol_TwoWayAnonComposed_Ordinal = 0x16afa17ea70d3370lu;

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

constexpr uint64_t kMainProtocol_TwoWayAnonComposedWithError_Ordinal = 0x2ed33746b7bb119dlu;

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

constexpr uint64_t kMainProtocol_OnAnonComposed_Ordinal = 0x7fa8a0bf08128a0blu;

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

constexpr uint64_t kMainProtocol_OneWayNamedComposed_Ordinal = 0x5d78ce13958eee58lu;

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

constexpr uint64_t kMainProtocol_TwoWayNamedComposed_Ordinal = 0xf67f27cae663810lu;

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

constexpr uint64_t kMainProtocol_TwoWayNamedComposedWithError_Ordinal = 0x30dac4182813ef7flu;

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

constexpr uint64_t kMainProtocol_OnNamedComposed_Ordinal = 0x5e68f92a5b28cdealu;

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

constexpr uint64_t kMainProtocol_OneWayImport_Ordinal = 0x530db65f2691d3blu;

constexpr ::fidl::MessageDynamicFlags kMainProtocol_OneWayImport_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kMainProtocol_TwoWayImport_Ordinal = 0x2bf680c8f0d40604lu;

constexpr ::fidl::MessageDynamicFlags kMainProtocol_TwoWayImport_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kMainProtocol_TwoWayImportWithError_Ordinal = 0x432093586084ff0alu;

constexpr ::fidl::MessageDynamicFlags kMainProtocol_TwoWayImportWithError_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kMainProtocol_OnImport_Ordinal = 0x5b61e3156b09acd0lu;

constexpr ::fidl::MessageDynamicFlags kMainProtocol_OnImport_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kMainProtocol_OneWayLocal_Ordinal = 0x54759b55efd60f43lu;

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

constexpr uint64_t kMainProtocol_TwoWayLocal_Ordinal = 0x6bbeeb18f39c539blu;

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

constexpr uint64_t kMainProtocol_TwoWayLocalWithError_Ordinal = 0x4dd8e7287c4c9b57lu;

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

constexpr uint64_t kMainProtocol_OnLocal_Ordinal = 0x3a46c48153f0437clu;

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

constexpr uint64_t kMainProtocol_OneWayAnon_Ordinal = 0x3a552f30c77c76eclu;

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

constexpr uint64_t kMainProtocol_TwoWayAnon_Ordinal = 0x672eb5e71efdabcflu;

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

constexpr uint64_t kMainProtocol_TwoWayAnonWithError_Ordinal = 0x6bd5fcf6f7b46df1lu;

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

constexpr uint64_t kMainProtocol_OnAnon_Ordinal = 0x64f7b1ec1ba0810blu;

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

#endif  // __Fuchsia__

#ifdef __Fuchsia__

using OpenProtocolPtr = ::fidl::InterfacePtr<OpenProtocol>;
class OpenProtocol_Proxy;
class OpenProtocol_Stub;
class OpenProtocol_EventSender;
class OpenProtocol_Sync;
using OpenProtocolSyncPtr = ::fidl::SynchronousInterfacePtr<OpenProtocol>;
class OpenProtocol_SyncProxy;

namespace internal {

constexpr uint64_t kOpenProtocol_FlexibleOneWay_Ordinal = 0x30ce1cc0e7e88521lu;

constexpr ::fidl::MessageDynamicFlags kOpenProtocol_FlexibleOneWay_DynamicFlags = ::fidl::MessageDynamicFlags::kFlexibleMethod;

constexpr uint64_t kOpenProtocol_FlexibleTwoWayNoError_Ordinal = 0x4d5655754da320d8lu;

constexpr ::fidl::MessageDynamicFlags kOpenProtocol_FlexibleTwoWayNoError_DynamicFlags = ::fidl::MessageDynamicFlags::kFlexibleMethod;

constexpr uint64_t kOpenProtocol_FlexibleTwoWayWithError_Ordinal = 0x30a12dd4f7823782lu;

constexpr ::fidl::MessageDynamicFlags kOpenProtocol_FlexibleTwoWayWithError_DynamicFlags = ::fidl::MessageDynamicFlags::kFlexibleMethod;

constexpr uint64_t kOpenProtocol_FlexibleEvent_Ordinal = 0x7f038af71aad17d4lu;

constexpr ::fidl::MessageDynamicFlags kOpenProtocol_FlexibleEvent_DynamicFlags = ::fidl::MessageDynamicFlags::kFlexibleMethod;

constexpr uint64_t kOpenProtocol_StrictOneWay_Ordinal = 0x79fce2c7f5b1bfa7lu;

constexpr ::fidl::MessageDynamicFlags kOpenProtocol_StrictOneWay_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kOpenProtocol_StrictTwoWayNoError_Ordinal = 0x3338d68165132184lu;

constexpr ::fidl::MessageDynamicFlags kOpenProtocol_StrictTwoWayNoError_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kOpenProtocol_StrictTwoWayWithError_Ordinal = 0x4a72f997c7db5037lu;

constexpr ::fidl::MessageDynamicFlags kOpenProtocol_StrictTwoWayWithError_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kOpenProtocol_StrictEvent_Ordinal = 0x366a73eb0b37159dlu;

constexpr ::fidl::MessageDynamicFlags kOpenProtocol_StrictEvent_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kOpenProtocol_FlexibleOneWayNamedPayload_Ordinal = 0x152c0b4acb5c0570lu;

constexpr ::fidl::MessageDynamicFlags kOpenProtocol_FlexibleOneWayNamedPayload_DynamicFlags = ::fidl::MessageDynamicFlags::kFlexibleMethod;
}  // namespace internal

#endif  // __Fuchsia__

#ifdef __Fuchsia__

class MainProtocol {
 public:
  using Proxy_ = ::test::protocollayouts::MainProtocol_Proxy;
  using Stub_ = ::test::protocollayouts::MainProtocol_Stub;
  using EventSender_ = ::test::protocollayouts::MainProtocol_EventSender;
  using Sync_ = ::test::protocollayouts::MainProtocol_Sync;
  virtual ~MainProtocol();

  virtual void OneWayAnonComposed(::test::protocollayouts::imported::ComposedProtocolOneWayAnonComposedRequest ComposedProtocolOneWayAnonComposedRequest) = 0;
  using TwoWayAnonComposedCallback =
      fit::function<void(::test::protocollayouts::imported::ComposedProtocolTwoWayAnonComposedResponse)>;

  virtual void TwoWayAnonComposed(::test::protocollayouts::imported::ComposedProtocolTwoWayAnonComposedRequest ComposedProtocolTwoWayAnonComposedRequest, TwoWayAnonComposedCallback callback) = 0;
  using TwoWayAnonComposedWithErrorCallback =
      fit::function<void(::test::protocollayouts::imported::ComposedProtocol_TwoWayAnonComposedWithError_Result)>;

  virtual void TwoWayAnonComposedWithError(::test::protocollayouts::imported::ComposedProtocolTwoWayAnonComposedWithErrorRequest ComposedProtocolTwoWayAnonComposedWithErrorRequest, TwoWayAnonComposedWithErrorCallback callback) = 0;
  using OnAnonComposedCallback =
      fit::function<void(::test::protocollayouts::imported::ComposedProtocolOnAnonComposedRequest)>;

  virtual void OneWayNamedComposed(::test::protocollayouts::imported::ImportTablePayload ImportTablePayload) = 0;
  using TwoWayNamedComposedCallback =
      fit::function<void(::test::protocollayouts::imported::ImportTablePayload)>;

  virtual void TwoWayNamedComposed(::test::protocollayouts::imported::ImportUnionPayload ImportUnionPayload, TwoWayNamedComposedCallback callback) = 0;
  using TwoWayNamedComposedWithErrorCallback =
      fit::function<void(::test::protocollayouts::imported::ComposedProtocol_TwoWayNamedComposedWithError_Result)>;

  virtual void TwoWayNamedComposedWithError(::test::protocollayouts::imported::ImportTablePayload ImportTablePayload, TwoWayNamedComposedWithErrorCallback callback) = 0;
  using OnNamedComposedCallback =
      fit::function<void(::test::protocollayouts::imported::ImportUnionPayload)>;

  virtual void OneWayImport(::test::protocollayouts::imported::ImportTablePayload ImportTablePayload) = 0;
  using TwoWayImportCallback =
      fit::function<void(::test::protocollayouts::imported::ImportTablePayload)>;

  virtual void TwoWayImport(::test::protocollayouts::imported::ImportUnionPayload ImportUnionPayload, TwoWayImportCallback callback) = 0;
  using TwoWayImportWithErrorCallback =
      fit::function<void(::test::protocollayouts::MainProtocol_TwoWayImportWithError_Result)>;

  virtual void TwoWayImportWithError(::test::protocollayouts::imported::ImportTablePayload ImportTablePayload, TwoWayImportWithErrorCallback callback) = 0;
  using OnImportCallback =
      fit::function<void(::test::protocollayouts::imported::ImportUnionPayload)>;

  virtual void OneWayLocal(::test::protocollayouts::LocalTablePayload LocalTablePayload) = 0;
  using TwoWayLocalCallback =
      fit::function<void(::test::protocollayouts::LocalTablePayload)>;

  virtual void TwoWayLocal(::test::protocollayouts::LocalUnionPayload LocalUnionPayload, TwoWayLocalCallback callback) = 0;
  using TwoWayLocalWithErrorCallback =
      fit::function<void(::test::protocollayouts::MainProtocol_TwoWayLocalWithError_Result)>;

  virtual void TwoWayLocalWithError(::test::protocollayouts::LocalTablePayload LocalTablePayload, TwoWayLocalWithErrorCallback callback) = 0;
  using OnLocalCallback =
      fit::function<void(::test::protocollayouts::LocalUnionPayload)>;

  virtual void OneWayAnon(::test::protocollayouts::MainProtocolOneWayAnonRequest MainProtocolOneWayAnonRequest) = 0;
  using TwoWayAnonCallback =
      fit::function<void(::test::protocollayouts::MainProtocolTwoWayAnonResponse)>;

  virtual void TwoWayAnon(::test::protocollayouts::MainProtocolTwoWayAnonRequest MainProtocolTwoWayAnonRequest, TwoWayAnonCallback callback) = 0;
  using TwoWayAnonWithErrorCallback =
      fit::function<void(::test::protocollayouts::MainProtocol_TwoWayAnonWithError_Result)>;

  virtual void TwoWayAnonWithError(::test::protocollayouts::MainProtocolTwoWayAnonWithErrorRequest MainProtocolTwoWayAnonWithErrorRequest, TwoWayAnonWithErrorCallback callback) = 0;
  using OnAnonCallback =
      fit::function<void(::test::protocollayouts::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::protocollayouts::imported::ComposedProtocolOneWayAnonComposedRequest ComposedProtocolOneWayAnonComposedRequest) = 0;
  virtual void TwoWayAnonComposed(::test::protocollayouts::imported::ComposedProtocolTwoWayAnonComposedRequest ComposedProtocolTwoWayAnonComposedRequest) = 0;
  virtual void TwoWayAnonComposedWithError(::test::protocollayouts::imported::ComposedProtocolTwoWayAnonComposedWithErrorRequest ComposedProtocolTwoWayAnonComposedWithErrorRequest) = 0;
  virtual void OneWayNamedComposed(::test::protocollayouts::imported::ImportTablePayload ImportTablePayload) = 0;
  virtual void TwoWayNamedComposed(::test::protocollayouts::imported::ImportUnionPayload ImportUnionPayload) = 0;
  virtual void TwoWayNamedComposedWithError(::test::protocollayouts::imported::ImportTablePayload ImportTablePayload) = 0;
  virtual void OneWayImport(::test::protocollayouts::imported::ImportTablePayload ImportTablePayload) = 0;
  virtual void TwoWayImport(::test::protocollayouts::imported::ImportUnionPayload ImportUnionPayload) = 0;
  virtual void TwoWayImportWithError(::test::protocollayouts::imported::ImportTablePayload ImportTablePayload) = 0;
  virtual void OneWayLocal(::test::protocollayouts::LocalTablePayload LocalTablePayload) = 0;
  virtual void TwoWayLocal(::test::protocollayouts::LocalUnionPayload LocalUnionPayload) = 0;
  virtual void TwoWayLocalWithError(::test::protocollayouts::LocalTablePayload LocalTablePayload) = 0;
  virtual void OneWayAnon(::test::protocollayouts::MainProtocolOneWayAnonRequest MainProtocolOneWayAnonRequest) = 0;
  virtual void TwoWayAnon(::test::protocollayouts::MainProtocolTwoWayAnonRequest MainProtocolTwoWayAnonRequest) = 0;
  virtual void TwoWayAnonWithError(::test::protocollayouts::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::protocollayouts::imported::ComposedProtocolTwoWayAnonComposedResponse ComposedProtocolTwoWayAnonComposedResponse) = 0;
  virtual void TwoWayAnonComposedWithError(::test::protocollayouts::imported::ComposedProtocol_TwoWayAnonComposedWithError_Result ComposedProtocol_TwoWayAnonComposedWithError_Result) = 0;
  virtual void OnAnonComposed(::test::protocollayouts::imported::ComposedProtocolOnAnonComposedRequest ComposedProtocolOnAnonComposedRequest) = 0;
  virtual void TwoWayNamedComposed(::test::protocollayouts::imported::ImportTablePayload ImportTablePayload) = 0;
  virtual void TwoWayNamedComposedWithError(::test::protocollayouts::imported::ComposedProtocol_TwoWayNamedComposedWithError_Result ComposedProtocol_TwoWayNamedComposedWithError_Result) = 0;
  virtual void OnNamedComposed(::test::protocollayouts::imported::ImportUnionPayload ImportUnionPayload) = 0;
  virtual void TwoWayImport(::test::protocollayouts::imported::ImportTablePayload ImportTablePayload) = 0;
  virtual void TwoWayImportWithError(::test::protocollayouts::MainProtocol_TwoWayImportWithError_Result MainProtocol_TwoWayImportWithError_Result) = 0;
  virtual void OnImport(::test::protocollayouts::imported::ImportUnionPayload ImportUnionPayload) = 0;
  virtual void TwoWayLocal(::test::protocollayouts::LocalTablePayload LocalTablePayload) = 0;
  virtual void TwoWayLocalWithError(::test::protocollayouts::MainProtocol_TwoWayLocalWithError_Result MainProtocol_TwoWayLocalWithError_Result) = 0;
  virtual void OnLocal(::test::protocollayouts::LocalUnionPayload LocalUnionPayload) = 0;
  virtual void TwoWayAnon(::test::protocollayouts::MainProtocolTwoWayAnonResponse MainProtocolTwoWayAnonResponse) = 0;
  virtual void TwoWayAnonWithError(::test::protocollayouts::MainProtocol_TwoWayAnonWithError_Result MainProtocol_TwoWayAnonWithError_Result) = 0;
  virtual void OnAnon(::test::protocollayouts::MainProtocolOnAnonRequest MainProtocolOnAnonRequest) = 0;
};

class MainProtocol_EventSender {
 public:
  virtual ~MainProtocol_EventSender();
  virtual void OnAnonComposed(::test::protocollayouts::imported::ComposedProtocolOnAnonComposedRequest ComposedProtocolOnAnonComposedRequest) = 0;
  virtual void OnNamedComposed(::test::protocollayouts::imported::ImportUnionPayload ImportUnionPayload) = 0;
  virtual void OnImport(::test::protocollayouts::imported::ImportUnionPayload ImportUnionPayload) = 0;
  virtual void OnLocal(::test::protocollayouts::LocalUnionPayload LocalUnionPayload) = 0;
  virtual void OnAnon(::test::protocollayouts::MainProtocolOnAnonRequest MainProtocolOnAnonRequest) = 0;
};

class MainProtocol_Sync {
 public:
  using Proxy_ = ::test::protocollayouts::MainProtocol_SyncProxy;
  virtual ~MainProtocol_Sync();
  virtual zx_status_t OneWayAnonComposed(::test::protocollayouts::imported::ComposedProtocolOneWayAnonComposedRequest ComposedProtocolOneWayAnonComposedRequest) = 0;
  virtual zx_status_t TwoWayAnonComposed(::test::protocollayouts::imported::ComposedProtocolTwoWayAnonComposedRequest ComposedProtocolTwoWayAnonComposedRequest, ::test::protocollayouts::imported::ComposedProtocolTwoWayAnonComposedResponse* out_ComposedProtocolTwoWayAnonComposedResponse) = 0;
  virtual zx_status_t TwoWayAnonComposedWithError(::test::protocollayouts::imported::ComposedProtocolTwoWayAnonComposedWithErrorRequest ComposedProtocolTwoWayAnonComposedWithErrorRequest, ::test::protocollayouts::imported::ComposedProtocol_TwoWayAnonComposedWithError_Result* out_ComposedProtocol_TwoWayAnonComposedWithError_Result) = 0;
  virtual zx_status_t OneWayNamedComposed(::test::protocollayouts::imported::ImportTablePayload ImportTablePayload) = 0;
  virtual zx_status_t TwoWayNamedComposed(::test::protocollayouts::imported::ImportUnionPayload ImportUnionPayload, ::test::protocollayouts::imported::ImportTablePayload* out_ImportTablePayload) = 0;
  virtual zx_status_t TwoWayNamedComposedWithError(::test::protocollayouts::imported::ImportTablePayload ImportTablePayload, ::test::protocollayouts::imported::ComposedProtocol_TwoWayNamedComposedWithError_Result* out_ComposedProtocol_TwoWayNamedComposedWithError_Result) = 0;
  virtual zx_status_t OneWayImport(::test::protocollayouts::imported::ImportTablePayload ImportTablePayload) = 0;
  virtual zx_status_t TwoWayImport(::test::protocollayouts::imported::ImportUnionPayload ImportUnionPayload, ::test::protocollayouts::imported::ImportTablePayload* out_ImportTablePayload) = 0;
  virtual zx_status_t TwoWayImportWithError(::test::protocollayouts::imported::ImportTablePayload ImportTablePayload, ::test::protocollayouts::MainProtocol_TwoWayImportWithError_Result* out_MainProtocol_TwoWayImportWithError_Result) = 0;
  virtual zx_status_t OneWayLocal(::test::protocollayouts::LocalTablePayload LocalTablePayload) = 0;
  virtual zx_status_t TwoWayLocal(::test::protocollayouts::LocalUnionPayload LocalUnionPayload, ::test::protocollayouts::LocalTablePayload* out_LocalTablePayload) = 0;
  virtual zx_status_t TwoWayLocalWithError(::test::protocollayouts::LocalTablePayload LocalTablePayload, ::test::protocollayouts::MainProtocol_TwoWayLocalWithError_Result* out_MainProtocol_TwoWayLocalWithError_Result) = 0;
  virtual zx_status_t OneWayAnon(::test::protocollayouts::MainProtocolOneWayAnonRequest MainProtocolOneWayAnonRequest) = 0;
  virtual zx_status_t TwoWayAnon(::test::protocollayouts::MainProtocolTwoWayAnonRequest MainProtocolTwoWayAnonRequest, ::test::protocollayouts::MainProtocolTwoWayAnonResponse* out_MainProtocolTwoWayAnonResponse) = 0;
  virtual zx_status_t TwoWayAnonWithError(::test::protocollayouts::MainProtocolTwoWayAnonWithErrorRequest MainProtocolTwoWayAnonWithErrorRequest, ::test::protocollayouts::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.protocollayouts/MainProtocol.OneWayAnonComposed
  void OneWayAnonComposed(::test::protocollayouts::imported::ComposedProtocolOneWayAnonComposedRequest ComposedProtocolOneWayAnonComposedRequest) override;
  // cts-coverage-fidl-name:test.protocollayouts/MainProtocol.TwoWayAnonComposed
  void TwoWayAnonComposed(::test::protocollayouts::imported::ComposedProtocolTwoWayAnonComposedRequest ComposedProtocolTwoWayAnonComposedRequest, TwoWayAnonComposedCallback callback) override;
  // cts-coverage-fidl-name:test.protocollayouts/MainProtocol.TwoWayAnonComposedWithError
  void TwoWayAnonComposedWithError(::test::protocollayouts::imported::ComposedProtocolTwoWayAnonComposedWithErrorRequest ComposedProtocolTwoWayAnonComposedWithErrorRequest, TwoWayAnonComposedWithErrorCallback callback) override;
  OnAnonComposedCallback OnAnonComposed;
  // cts-coverage-fidl-name:test.protocollayouts/MainProtocol.OneWayNamedComposed
  void OneWayNamedComposed(::test::protocollayouts::imported::ImportTablePayload ImportTablePayload) override;
  // cts-coverage-fidl-name:test.protocollayouts/MainProtocol.TwoWayNamedComposed
  void TwoWayNamedComposed(::test::protocollayouts::imported::ImportUnionPayload ImportUnionPayload, TwoWayNamedComposedCallback callback) override;
  // cts-coverage-fidl-name:test.protocollayouts/MainProtocol.TwoWayNamedComposedWithError
  void TwoWayNamedComposedWithError(::test::protocollayouts::imported::ImportTablePayload ImportTablePayload, TwoWayNamedComposedWithErrorCallback callback) override;
  OnNamedComposedCallback OnNamedComposed;
  // cts-coverage-fidl-name:test.protocollayouts/MainProtocol.OneWayImport
  void OneWayImport(::test::protocollayouts::imported::ImportTablePayload ImportTablePayload) override;
  // cts-coverage-fidl-name:test.protocollayouts/MainProtocol.TwoWayImport
  void TwoWayImport(::test::protocollayouts::imported::ImportUnionPayload ImportUnionPayload, TwoWayImportCallback callback) override;
  // cts-coverage-fidl-name:test.protocollayouts/MainProtocol.TwoWayImportWithError
  void TwoWayImportWithError(::test::protocollayouts::imported::ImportTablePayload ImportTablePayload, TwoWayImportWithErrorCallback callback) override;
  OnImportCallback OnImport;
  // cts-coverage-fidl-name:test.protocollayouts/MainProtocol.OneWayLocal
  void OneWayLocal(::test::protocollayouts::LocalTablePayload LocalTablePayload) override;
  // cts-coverage-fidl-name:test.protocollayouts/MainProtocol.TwoWayLocal
  void TwoWayLocal(::test::protocollayouts::LocalUnionPayload LocalUnionPayload, TwoWayLocalCallback callback) override;
  // cts-coverage-fidl-name:test.protocollayouts/MainProtocol.TwoWayLocalWithError
  void TwoWayLocalWithError(::test::protocollayouts::LocalTablePayload LocalTablePayload, TwoWayLocalWithErrorCallback callback) override;
  OnLocalCallback OnLocal;
  // cts-coverage-fidl-name:test.protocollayouts/MainProtocol.OneWayAnon
  void OneWayAnon(::test::protocollayouts::MainProtocolOneWayAnonRequest MainProtocolOneWayAnonRequest) override;
  // cts-coverage-fidl-name:test.protocollayouts/MainProtocol.TwoWayAnon
  void TwoWayAnon(::test::protocollayouts::MainProtocolTwoWayAnonRequest MainProtocolTwoWayAnonRequest, TwoWayAnonCallback callback) override;
  // cts-coverage-fidl-name:test.protocollayouts/MainProtocol.TwoWayAnonWithError
  void TwoWayAnonWithError(::test::protocollayouts::MainProtocolTwoWayAnonWithErrorRequest MainProtocolTwoWayAnonWithErrorRequest, TwoWayAnonWithErrorCallback callback) override;
  OnAnonCallback OnAnon;

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

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

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

  zx_status_t Dispatch_(::fidl::HLCPPIncomingMessage message,
                        ::fidl::internal::PendingResponse response) override;
  void OnAnonComposed(::test::protocollayouts::imported::ComposedProtocolOnAnonComposedRequest ComposedProtocolOnAnonComposedRequest) override;
  void OnNamedComposed(::test::protocollayouts::imported::ImportUnionPayload ImportUnionPayload) override;
  void OnImport(::test::protocollayouts::imported::ImportUnionPayload ImportUnionPayload) override;
  void OnLocal(::test::protocollayouts::LocalUnionPayload LocalUnionPayload) override;
  void OnAnon(::test::protocollayouts::MainProtocolOnAnonRequest MainProtocolOnAnonRequest) override;

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

class MainProtocol_SyncProxy : public ::test::protocollayouts::MainProtocol_Sync {
 public:
  explicit MainProtocol_SyncProxy(::zx::channel channel);
  ~MainProtocol_SyncProxy() override;
  // cts-coverage-fidl-name:test.protocollayouts/MainProtocol.OneWayAnonComposed
  zx_status_t OneWayAnonComposed(::test::protocollayouts::imported::ComposedProtocolOneWayAnonComposedRequest ComposedProtocolOneWayAnonComposedRequest) override;
  // cts-coverage-fidl-name:test.protocollayouts/MainProtocol.TwoWayAnonComposed
  zx_status_t TwoWayAnonComposed(::test::protocollayouts::imported::ComposedProtocolTwoWayAnonComposedRequest ComposedProtocolTwoWayAnonComposedRequest, ::test::protocollayouts::imported::ComposedProtocolTwoWayAnonComposedResponse* out_ComposedProtocolTwoWayAnonComposedResponse) override;
  // cts-coverage-fidl-name:test.protocollayouts/MainProtocol.TwoWayAnonComposedWithError
  zx_status_t TwoWayAnonComposedWithError(::test::protocollayouts::imported::ComposedProtocolTwoWayAnonComposedWithErrorRequest ComposedProtocolTwoWayAnonComposedWithErrorRequest, ::test::protocollayouts::imported::ComposedProtocol_TwoWayAnonComposedWithError_Result* out_ComposedProtocol_TwoWayAnonComposedWithError_Result) override;
  // cts-coverage-fidl-name:test.protocollayouts/MainProtocol.OneWayNamedComposed
  zx_status_t OneWayNamedComposed(::test::protocollayouts::imported::ImportTablePayload ImportTablePayload) override;
  // cts-coverage-fidl-name:test.protocollayouts/MainProtocol.TwoWayNamedComposed
  zx_status_t TwoWayNamedComposed(::test::protocollayouts::imported::ImportUnionPayload ImportUnionPayload, ::test::protocollayouts::imported::ImportTablePayload* out_ImportTablePayload) override;
  // cts-coverage-fidl-name:test.protocollayouts/MainProtocol.TwoWayNamedComposedWithError
  zx_status_t TwoWayNamedComposedWithError(::test::protocollayouts::imported::ImportTablePayload ImportTablePayload, ::test::protocollayouts::imported::ComposedProtocol_TwoWayNamedComposedWithError_Result* out_ComposedProtocol_TwoWayNamedComposedWithError_Result) override;
  // cts-coverage-fidl-name:test.protocollayouts/MainProtocol.OneWayImport
  zx_status_t OneWayImport(::test::protocollayouts::imported::ImportTablePayload ImportTablePayload) override;
  // cts-coverage-fidl-name:test.protocollayouts/MainProtocol.TwoWayImport
  zx_status_t TwoWayImport(::test::protocollayouts::imported::ImportUnionPayload ImportUnionPayload, ::test::protocollayouts::imported::ImportTablePayload* out_ImportTablePayload) override;
  // cts-coverage-fidl-name:test.protocollayouts/MainProtocol.TwoWayImportWithError
  zx_status_t TwoWayImportWithError(::test::protocollayouts::imported::ImportTablePayload ImportTablePayload, ::test::protocollayouts::MainProtocol_TwoWayImportWithError_Result* out_MainProtocol_TwoWayImportWithError_Result) override;
  // cts-coverage-fidl-name:test.protocollayouts/MainProtocol.OneWayLocal
  zx_status_t OneWayLocal(::test::protocollayouts::LocalTablePayload LocalTablePayload) override;
  // cts-coverage-fidl-name:test.protocollayouts/MainProtocol.TwoWayLocal
  zx_status_t TwoWayLocal(::test::protocollayouts::LocalUnionPayload LocalUnionPayload, ::test::protocollayouts::LocalTablePayload* out_LocalTablePayload) override;
  // cts-coverage-fidl-name:test.protocollayouts/MainProtocol.TwoWayLocalWithError
  zx_status_t TwoWayLocalWithError(::test::protocollayouts::LocalTablePayload LocalTablePayload, ::test::protocollayouts::MainProtocol_TwoWayLocalWithError_Result* out_MainProtocol_TwoWayLocalWithError_Result) override;
  // cts-coverage-fidl-name:test.protocollayouts/MainProtocol.OneWayAnon
  zx_status_t OneWayAnon(::test::protocollayouts::MainProtocolOneWayAnonRequest MainProtocolOneWayAnonRequest) override;
  // cts-coverage-fidl-name:test.protocollayouts/MainProtocol.TwoWayAnon
  zx_status_t TwoWayAnon(::test::protocollayouts::MainProtocolTwoWayAnonRequest MainProtocolTwoWayAnonRequest, ::test::protocollayouts::MainProtocolTwoWayAnonResponse* out_MainProtocolTwoWayAnonResponse) override;
  // cts-coverage-fidl-name:test.protocollayouts/MainProtocol.TwoWayAnonWithError
  zx_status_t TwoWayAnonWithError(::test::protocollayouts::MainProtocolTwoWayAnonWithErrorRequest MainProtocolTwoWayAnonWithErrorRequest, ::test::protocollayouts::MainProtocol_TwoWayAnonWithError_Result* out_MainProtocol_TwoWayAnonWithError_Result) override;

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

#endif  // __Fuchsia__

#ifdef __Fuchsia__

class OpenProtocol {
 public:
  using Proxy_ = ::test::protocollayouts::OpenProtocol_Proxy;
  using Stub_ = ::test::protocollayouts::OpenProtocol_Stub;
  using EventSender_ = ::test::protocollayouts::OpenProtocol_EventSender;
  using Sync_ = ::test::protocollayouts::OpenProtocol_Sync;
  virtual ~OpenProtocol();

  virtual void FlexibleOneWay(int32_t value) = 0;
  using FlexibleTwoWayNoErrorCallback =
      fit::function<void(::test::protocollayouts::imported::ComposedOpenProtocol_FlexibleTwoWayNoError_Result)>;

  virtual void FlexibleTwoWayNoError(int32_t value, FlexibleTwoWayNoErrorCallback callback) = 0;
  using FlexibleTwoWayWithErrorCallback =
      fit::function<void(::test::protocollayouts::imported::ComposedOpenProtocol_FlexibleTwoWayWithError_Result)>;

  virtual void FlexibleTwoWayWithError(int32_t value, FlexibleTwoWayWithErrorCallback callback) = 0;
  using FlexibleEventCallback =
      fit::function<void(int32_t)>;

  virtual void StrictOneWay(int32_t value) = 0;
  using StrictTwoWayNoErrorCallback =
      fit::function<void(int32_t)>;

  virtual void StrictTwoWayNoError(int32_t value, StrictTwoWayNoErrorCallback callback) = 0;
  using StrictTwoWayWithErrorCallback =
      fit::function<void(::test::protocollayouts::imported::ComposedOpenProtocol_StrictTwoWayWithError_Result)>;

  virtual void StrictTwoWayWithError(int32_t value, StrictTwoWayWithErrorCallback callback) = 0;
  using StrictEventCallback =
      fit::function<void(int32_t)>;

  virtual void FlexibleOneWayNamedPayload(int32_t value) = 0;

 protected:
  // Allow the stub to access the handle_unknown_method method.
  friend class OpenProtocol_Stub;

  virtual void handle_unknown_method(uint64_t ordinal, bool method_has_response) = 0;
};

class OpenProtocol_RequestDecoder {
 public:
  OpenProtocol_RequestDecoder() = default;
  virtual ~OpenProtocol_RequestDecoder() = default;
  static const fidl_type_t* GetType(uint64_t ordinal, bool* out_needs_response, bool* is_known);
  virtual void FlexibleOneWay(int32_t value) = 0;
  virtual void FlexibleTwoWayNoError(int32_t value) = 0;
  virtual void FlexibleTwoWayWithError(int32_t value) = 0;
  virtual void StrictOneWay(int32_t value) = 0;
  virtual void StrictTwoWayNoError(int32_t value) = 0;
  virtual void StrictTwoWayWithError(int32_t value) = 0;
  virtual void FlexibleOneWayNamedPayload(int32_t value) = 0;
};

class OpenProtocol_ResponseDecoder {
 public:
  OpenProtocol_ResponseDecoder() = default;
  virtual ~OpenProtocol_ResponseDecoder() = default;
  static const fidl_type_t* GetType(uint64_t ordinal);
  virtual void FlexibleTwoWayNoError(::test::protocollayouts::imported::ComposedOpenProtocol_FlexibleTwoWayNoError_Result ComposedOpenProtocol_FlexibleTwoWayNoError_Result) = 0;
  virtual void FlexibleTwoWayWithError(::test::protocollayouts::imported::ComposedOpenProtocol_FlexibleTwoWayWithError_Result ComposedOpenProtocol_FlexibleTwoWayWithError_Result) = 0;
  virtual void FlexibleEvent(int32_t value) = 0;
  virtual void StrictTwoWayNoError(int32_t value) = 0;
  virtual void StrictTwoWayWithError(::test::protocollayouts::imported::ComposedOpenProtocol_StrictTwoWayWithError_Result ComposedOpenProtocol_StrictTwoWayWithError_Result) = 0;
  virtual void StrictEvent(int32_t value) = 0;
};

class OpenProtocol_EventSender {
 public:
  virtual ~OpenProtocol_EventSender();
  virtual void FlexibleEvent(int32_t value) = 0;
  virtual void StrictEvent(int32_t value) = 0;
};

class OpenProtocol_Sync {
 public:
  using Proxy_ = ::test::protocollayouts::OpenProtocol_SyncProxy;
  virtual ~OpenProtocol_Sync();
  virtual zx_status_t FlexibleOneWay(int32_t value) = 0;
  virtual zx_status_t FlexibleTwoWayNoError(int32_t value, ::test::protocollayouts::imported::ComposedOpenProtocol_FlexibleTwoWayNoError_Result* out_ComposedOpenProtocol_FlexibleTwoWayNoError_Result) = 0;
  virtual zx_status_t FlexibleTwoWayWithError(int32_t value, ::test::protocollayouts::imported::ComposedOpenProtocol_FlexibleTwoWayWithError_Result* out_ComposedOpenProtocol_FlexibleTwoWayWithError_Result) = 0;
  virtual zx_status_t StrictOneWay(int32_t value) = 0;
  virtual zx_status_t StrictTwoWayNoError(int32_t value, int32_t* out_value) = 0;
  virtual zx_status_t StrictTwoWayWithError(int32_t value, ::test::protocollayouts::imported::ComposedOpenProtocol_StrictTwoWayWithError_Result* out_ComposedOpenProtocol_StrictTwoWayWithError_Result) = 0;
  virtual zx_status_t FlexibleOneWayNamedPayload(int32_t value) = 0;
};

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

  zx_status_t Dispatch_(::fidl::HLCPPIncomingMessage message) override;
  // cts-coverage-fidl-name:test.protocollayouts/OpenProtocol.FlexibleOneWay
  void FlexibleOneWay(int32_t value) override;
  // cts-coverage-fidl-name:test.protocollayouts/OpenProtocol.FlexibleTwoWayNoError
  void FlexibleTwoWayNoError(int32_t value, FlexibleTwoWayNoErrorCallback callback) override;
  // cts-coverage-fidl-name:test.protocollayouts/OpenProtocol.FlexibleTwoWayWithError
  void FlexibleTwoWayWithError(int32_t value, FlexibleTwoWayWithErrorCallback callback) override;
  FlexibleEventCallback FlexibleEvent;
  // cts-coverage-fidl-name:test.protocollayouts/OpenProtocol.StrictOneWay
  void StrictOneWay(int32_t value) override;
  // cts-coverage-fidl-name:test.protocollayouts/OpenProtocol.StrictTwoWayNoError
  void StrictTwoWayNoError(int32_t value, StrictTwoWayNoErrorCallback callback) override;
  // cts-coverage-fidl-name:test.protocollayouts/OpenProtocol.StrictTwoWayWithError
  void StrictTwoWayWithError(int32_t value, StrictTwoWayWithErrorCallback callback) override;
  StrictEventCallback StrictEvent;
  // cts-coverage-fidl-name:test.protocollayouts/OpenProtocol.FlexibleOneWayNamedPayload
  void FlexibleOneWayNamedPayload(int32_t value) override;

  fit::function<void(uint64_t)> handle_unknown_event;

 protected:
  void handle_unknown_method(uint64_t ordinal, bool method_has_response) override {
    // This method is only provided to satisfy the base interface. It's
    // protected and should never be called by generated code on the client
    // side, so it should never be called.
    ZX_PANIC("Unreachable: OpenProtocol_Proxy::handle_unknown_method should not be callable");
  }

 private:
  OpenProtocol_Proxy(const ::test::protocollayouts::OpenProtocol_Proxy&) = delete;
  OpenProtocol_Proxy& operator=(const ::test::protocollayouts::OpenProtocol_Proxy&) = delete;

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

class OpenProtocol_Stub final : public ::fidl::internal::Stub, public ::test::protocollayouts::OpenProtocol_EventSender {
 public:
  typedef class ::test::protocollayouts::OpenProtocol OpenProtocol_clazz;
  explicit OpenProtocol_Stub(::test::protocollayouts::OpenProtocol_Stub::OpenProtocol_clazz* impl);
  ~OpenProtocol_Stub() override;

  zx_status_t Dispatch_(::fidl::HLCPPIncomingMessage message,
                        ::fidl::internal::PendingResponse response) override;
  void FlexibleEvent(int32_t value) override;
  void StrictEvent(int32_t value) override;

 private:
  ::test::protocollayouts::OpenProtocol_Stub::OpenProtocol_clazz* impl_;
};

class OpenProtocol_SyncProxy : public ::test::protocollayouts::OpenProtocol_Sync {
 public:
  explicit OpenProtocol_SyncProxy(::zx::channel channel);
  ~OpenProtocol_SyncProxy() override;
  // cts-coverage-fidl-name:test.protocollayouts/OpenProtocol.FlexibleOneWay
  zx_status_t FlexibleOneWay(int32_t value) override;
  // cts-coverage-fidl-name:test.protocollayouts/OpenProtocol.FlexibleTwoWayNoError
  zx_status_t FlexibleTwoWayNoError(int32_t value, ::test::protocollayouts::imported::ComposedOpenProtocol_FlexibleTwoWayNoError_Result* out_ComposedOpenProtocol_FlexibleTwoWayNoError_Result) override;
  // cts-coverage-fidl-name:test.protocollayouts/OpenProtocol.FlexibleTwoWayWithError
  zx_status_t FlexibleTwoWayWithError(int32_t value, ::test::protocollayouts::imported::ComposedOpenProtocol_FlexibleTwoWayWithError_Result* out_ComposedOpenProtocol_FlexibleTwoWayWithError_Result) override;
  // cts-coverage-fidl-name:test.protocollayouts/OpenProtocol.StrictOneWay
  zx_status_t StrictOneWay(int32_t value) override;
  // cts-coverage-fidl-name:test.protocollayouts/OpenProtocol.StrictTwoWayNoError
  zx_status_t StrictTwoWayNoError(int32_t value, int32_t* out_value) override;
  // cts-coverage-fidl-name:test.protocollayouts/OpenProtocol.StrictTwoWayWithError
  zx_status_t StrictTwoWayWithError(int32_t value, ::test::protocollayouts::imported::ComposedOpenProtocol_StrictTwoWayWithError_Result* out_ComposedOpenProtocol_StrictTwoWayWithError_Result) override;
  // cts-coverage-fidl-name:test.protocollayouts/OpenProtocol.FlexibleOneWayNamedPayload
  zx_status_t FlexibleOneWayNamedPayload(int32_t value) override;

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

#endif  // __Fuchsia__

}  // namespace protocollayouts
}  // namespace test