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

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

// fidl_experiment = output_index_json

#pragma once

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

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

//
// Domain objects declarations
//

class LocalStructPayload;

class MainProtocol_TwoWayLocalWithError_Result;

class MainProtocolOneWayAnonRequest;

class MainProtocolTwoWayAnonRequest;

class MainProtocolTwoWayAnonResponse;

class MainProtocolTwoWayAnonWithErrorRequest;

class MainProtocol_TwoWayAnonWithError_Response;

class MainProtocol_TwoWayAnonWithError_Result;

class MainProtocolOnAnonRequest;

class MainProtocol_TwoWayImportWithError_Result;

#ifdef __Fuchsia__

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

#endif  // __Fuchsia__

class LocalStructPayload final {
 public:
  static const fidl_type_t* FidlType;
  LocalStructPayload() = default;
  explicit LocalStructPayload(::std::tuple<uint32_t, uint32_t> _value_tuple) {
    std::tie(a, b) = std::move(_value_tuple);
  }
  operator ::std::tuple<uint32_t, uint32_t>() && {
    return std::make_tuple(std::move(a), std::move(b));
  }

  uint32_t a{};

  uint32_t b{};

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

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

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

using LocalStructPayloadPtr = ::std::unique_ptr<LocalStructPayload>;

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

  ::test::protocolpayloads::LocalStructPayload& response() {
    EnsureStorageInitialized(::test::protocolpayloads::MainProtocol_TwoWayLocalWithError_Result::Tag::kResponse);
    return response_;
  }

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

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

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

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

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

inline zx_status_t Clone(const ::test::protocolpayloads::MainProtocol_TwoWayLocalWithError_Result& value,
                         ::test::protocolpayloads::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;

  uint32_t a{};

  uint32_t b{};

  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;
};

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

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

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

  uint32_t a{};

  uint32_t b{};

  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;
};

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

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

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

  uint32_t a{};

  uint32_t b{};

  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;
};

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

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

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

  uint32_t a{};

  uint32_t b{};

  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;
};

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

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

class MainProtocol_TwoWayAnonWithError_Response final {
 public:
  static const fidl_type_t* FidlType;
  MainProtocol_TwoWayAnonWithError_Response() = default;
  explicit MainProtocol_TwoWayAnonWithError_Response(::std::tuple<uint32_t, uint32_t> _value_tuple) {
    std::tie(a, b) = std::move(_value_tuple);
  }
  operator ::std::tuple<uint32_t, uint32_t>() && {
    return std::make_tuple(std::move(a), std::move(b));
  }

  uint32_t a{};

  uint32_t b{};

  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;
};

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

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

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

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

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

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

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

inline zx_status_t Clone(const ::test::protocolpayloads::MainProtocol_TwoWayAnonWithError_Result& value,
                         ::test::protocolpayloads::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;

  uint32_t a{};

  uint32_t b{};

  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;
};

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

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

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::protocolpayloads::imported::ImportStructPayload&&);
  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::protocolpayloads::MainProtocol_TwoWayImportWithError_Result::Tag::kResponse; }

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

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

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

  uint32_t& err() {
    EnsureStorageInitialized(::test::protocolpayloads::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::protocolpayloads::MainProtocol_TwoWayImportWithError_Result::Tag Which() const {
    return ::test::protocolpayloads::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::protocolpayloads::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::protocolpayloads::MainProtocol_TwoWayImportWithError_Result::Tag::Invalid);
  union {
    ::test::protocolpayloads::imported::ImportStructPayload response_;
    uint32_t err_;
  };
};

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

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

#ifdef __Fuchsia__

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

__LOCAL extern "C" const fidl_type_t test_protocolpayloads_LocalStructPayloadTable;

__LOCAL extern "C" const fidl_type_t test_protocolpayloads_MainProtocolOneWayAnonRequestTable;

__LOCAL extern "C" const fidl_type_t test_protocolpayloads_MainProtocolTwoWayAnonRequestTable;

__LOCAL extern "C" const fidl_type_t test_protocolpayloads_MainProtocolTwoWayAnonWithErrorRequestTable;

}  // namespace _internal

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

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

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

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage OneWayLocal(::fidl::MessageEncoder* _encoder, uint32_t* a, uint32_t* b) {
    _encoder->Alloc(8);
    ::fidl::Encode(_encoder, a, 0 + sizeof(fidl_message_header_t));

    ::fidl::Encode(_encoder, b, 4 + sizeof(fidl_message_header_t));

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage TwoWayLocal(::fidl::MessageEncoder* _encoder, uint32_t* a, uint32_t* b) {
    _encoder->Alloc(8);
    ::fidl::Encode(_encoder, a, 0 + sizeof(fidl_message_header_t));

    ::fidl::Encode(_encoder, b, 4 + sizeof(fidl_message_header_t));

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage TwoWayLocalWithError(::fidl::MessageEncoder* _encoder, uint32_t* a, uint32_t* b) {
    _encoder->Alloc(8);
    ::fidl::Encode(_encoder, a, 0 + sizeof(fidl_message_header_t));

    ::fidl::Encode(_encoder, b, 4 + sizeof(fidl_message_header_t));

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

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

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

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage OneWayAnon(::fidl::MessageEncoder* _encoder, uint32_t* a, uint32_t* b) {
    _encoder->Alloc(8);
    ::fidl::Encode(_encoder, a, 0 + sizeof(fidl_message_header_t));

    ::fidl::Encode(_encoder, b, 4 + sizeof(fidl_message_header_t));

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage TwoWayAnon(::fidl::MessageEncoder* _encoder, uint32_t* a, uint32_t* b) {
    _encoder->Alloc(8);
    ::fidl::Encode(_encoder, a, 0 + sizeof(fidl_message_header_t));

    ::fidl::Encode(_encoder, b, 4 + sizeof(fidl_message_header_t));

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage TwoWayAnonWithError(::fidl::MessageEncoder* _encoder, uint32_t* a, uint32_t* b) {
    _encoder->Alloc(8);
    ::fidl::Encode(_encoder, a, 0 + sizeof(fidl_message_header_t));

    ::fidl::Encode(_encoder, b, 4 + sizeof(fidl_message_header_t));

    return _encoder->GetMessage();
  }
};

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

__LOCAL extern "C" const fidl_type_t test_protocolpayloads_MainProtocol_TwoWayLocalWithError_ResultTable;

__LOCAL extern "C" const fidl_type_t test_protocolpayloads_MainProtocol_TwoWayImportWithError_ResultTable;

__LOCAL extern "C" const fidl_type_t test_protocolpayloads_MainProtocolTwoWayAnonResponseTable;

__LOCAL extern "C" const fidl_type_t test_protocolpayloads_MainProtocol_TwoWayAnonWithError_ResultTable;

__LOCAL extern "C" const fidl_type_t test_protocolpayloads_MainProtocolOnAnonRequestTable;

}  // namespace _internal

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

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

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

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage TwoWayLocal(::fidl::MessageEncoder* _encoder, uint32_t* a, uint32_t* b) {
    _encoder->Alloc(8);
    ::fidl::Encode(_encoder, a, 0 + sizeof(fidl_message_header_t));

    ::fidl::Encode(_encoder, b, 4 + sizeof(fidl_message_header_t));

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage TwoWayLocalWithError(::fidl::MessageEncoder* _encoder, ::test::protocolpayloads::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, uint32_t* a, uint32_t* b) {
    _encoder->Alloc(8);
    ::fidl::Encode(_encoder, a, 0 + sizeof(fidl_message_header_t));

    ::fidl::Encode(_encoder, b, 4 + sizeof(fidl_message_header_t));

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

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage TwoWayImportWithError(::fidl::MessageEncoder* _encoder, ::test::protocolpayloads::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, int32_t* a) {
    _encoder->Alloc(4);
    ::fidl::Encode(_encoder, a, 0 + sizeof(fidl_message_header_t));

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage TwoWayAnon(::fidl::MessageEncoder* _encoder, uint32_t* a, uint32_t* b) {
    _encoder->Alloc(8);
    ::fidl::Encode(_encoder, a, 0 + sizeof(fidl_message_header_t));

    ::fidl::Encode(_encoder, b, 4 + sizeof(fidl_message_header_t));

    return _encoder->GetMessage();
  }
  static ::fidl::HLCPPOutgoingMessage TwoWayAnonWithError(::fidl::MessageEncoder* _encoder, ::test::protocolpayloads::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, uint32_t* a, uint32_t* b) {
    _encoder->Alloc(8);
    ::fidl::Encode(_encoder, a, 0 + sizeof(fidl_message_header_t));

    ::fidl::Encode(_encoder, b, 4 + sizeof(fidl_message_header_t));

    return _encoder->GetMessage();
  }
};

#endif  // __Fuchsia__

}  // namespace protocolpayloads
}  // namespace test
namespace fidl {

template <>
struct CodingTraits<::test::protocolpayloads::LocalStructPayload>
    : public EncodableCodingTraits<::test::protocolpayloads::LocalStructPayload, 8> {};

template <>
struct IsMemcpyCompatible<::test::protocolpayloads::LocalStructPayload> : public internal::BoolConstant<
                                                                              !HasPadding<::test::protocolpayloads::LocalStructPayload>::value && IsMemcpyCompatible<uint32_t>::value> {};

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

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

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

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

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

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

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

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

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

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

template <>
struct IsMemcpyCompatible<::test::protocolpayloads::MainProtocolOneWayAnonRequest> : public internal::BoolConstant<
                                                                                         !HasPadding<::test::protocolpayloads::MainProtocolOneWayAnonRequest>::value && IsMemcpyCompatible<uint32_t>::value> {};

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

template <>
struct Equality<::test::protocolpayloads::MainProtocolOneWayAnonRequest> {
  bool operator()(const ::test::protocolpayloads::MainProtocolOneWayAnonRequest& _lhs, const ::test::protocolpayloads::MainProtocolOneWayAnonRequest& _rhs) const {
    if (!::fidl::Equals(_lhs.a, _rhs.a)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.b, _rhs.b)) {
      return false;
    }
    return true;
  }
};
template <>
struct CodingTraits<::test::protocolpayloads::MainProtocolTwoWayAnonRequest>
    : public EncodableCodingTraits<::test::protocolpayloads::MainProtocolTwoWayAnonRequest, 8> {};

template <>
struct IsMemcpyCompatible<::test::protocolpayloads::MainProtocolTwoWayAnonRequest> : public internal::BoolConstant<
                                                                                         !HasPadding<::test::protocolpayloads::MainProtocolTwoWayAnonRequest>::value && IsMemcpyCompatible<uint32_t>::value> {};

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

template <>
struct Equality<::test::protocolpayloads::MainProtocolTwoWayAnonRequest> {
  bool operator()(const ::test::protocolpayloads::MainProtocolTwoWayAnonRequest& _lhs, const ::test::protocolpayloads::MainProtocolTwoWayAnonRequest& _rhs) const {
    if (!::fidl::Equals(_lhs.a, _rhs.a)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.b, _rhs.b)) {
      return false;
    }
    return true;
  }
};
template <>
struct CodingTraits<::test::protocolpayloads::MainProtocolTwoWayAnonResponse>
    : public EncodableCodingTraits<::test::protocolpayloads::MainProtocolTwoWayAnonResponse, 8> {};

template <>
struct IsMemcpyCompatible<::test::protocolpayloads::MainProtocolTwoWayAnonResponse> : public internal::BoolConstant<
                                                                                          !HasPadding<::test::protocolpayloads::MainProtocolTwoWayAnonResponse>::value && IsMemcpyCompatible<uint32_t>::value> {};

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

template <>
struct Equality<::test::protocolpayloads::MainProtocolTwoWayAnonResponse> {
  bool operator()(const ::test::protocolpayloads::MainProtocolTwoWayAnonResponse& _lhs, const ::test::protocolpayloads::MainProtocolTwoWayAnonResponse& _rhs) const {
    if (!::fidl::Equals(_lhs.a, _rhs.a)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.b, _rhs.b)) {
      return false;
    }
    return true;
  }
};
template <>
struct CodingTraits<::test::protocolpayloads::MainProtocolTwoWayAnonWithErrorRequest>
    : public EncodableCodingTraits<::test::protocolpayloads::MainProtocolTwoWayAnonWithErrorRequest, 8> {};

template <>
struct IsMemcpyCompatible<::test::protocolpayloads::MainProtocolTwoWayAnonWithErrorRequest> : public internal::BoolConstant<
                                                                                                  !HasPadding<::test::protocolpayloads::MainProtocolTwoWayAnonWithErrorRequest>::value && IsMemcpyCompatible<uint32_t>::value> {};

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

template <>
struct Equality<::test::protocolpayloads::MainProtocolTwoWayAnonWithErrorRequest> {
  bool operator()(const ::test::protocolpayloads::MainProtocolTwoWayAnonWithErrorRequest& _lhs, const ::test::protocolpayloads::MainProtocolTwoWayAnonWithErrorRequest& _rhs) const {
    if (!::fidl::Equals(_lhs.a, _rhs.a)) {
      return false;
    }
    if (!::fidl::Equals(_lhs.b, _rhs.b)) {
      return false;
    }
    return true;
  }
};
template <>
struct CodingTraits<::test::protocolpayloads::MainProtocol_TwoWayAnonWithError_Response>
    : public EncodableCodingTraits<::test::protocolpayloads::MainProtocol_TwoWayAnonWithError_Response, 8> {};

template <>
struct IsMemcpyCompatible<::test::protocolpayloads::MainProtocol_TwoWayAnonWithError_Response> : public internal::BoolConstant<
                                                                                                     !HasPadding<::test::protocolpayloads::MainProtocol_TwoWayAnonWithError_Response>::value && IsMemcpyCompatible<uint32_t>::value> {};

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

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

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

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

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

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

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

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

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

      default:
        return false;
    }
  }
};
template <>
struct CodingTraits<::test::protocolpayloads::MainProtocolOnAnonRequest>
    : public EncodableCodingTraits<::test::protocolpayloads::MainProtocolOnAnonRequest, 8> {};

template <>
struct IsMemcpyCompatible<::test::protocolpayloads::MainProtocolOnAnonRequest> : public internal::BoolConstant<
                                                                                     !HasPadding<::test::protocolpayloads::MainProtocolOnAnonRequest>::value && IsMemcpyCompatible<uint32_t>::value> {};

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

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

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

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

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

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

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

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

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

      default:
        return false;
    }
  }
};

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

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

constexpr ::fidl::MessageDynamicFlags kMainProtocol_OneWayComposed_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kMainProtocol_TwoWayComposed_Ordinal = 0x2348a1331ca4cfb0lu;

constexpr ::fidl::MessageDynamicFlags kMainProtocol_TwoWayComposed_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kMainProtocol_TwoWayComposedWithError_Ordinal = 0x6a9be48b574d1557lu;

constexpr ::fidl::MessageDynamicFlags kMainProtocol_TwoWayComposedWithError_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kMainProtocol_OnComposed_Ordinal = 0x19fbe2b2f6f9273alu;

constexpr ::fidl::MessageDynamicFlags kMainProtocol_OnComposed_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

constexpr uint64_t kMainProtocol_OneWayLocal_Ordinal = 0x6b9feaf9305b0715lu;

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

constexpr uint64_t kMainProtocol_TwoWayLocal_Ordinal = 0x743776548de3af0flu;

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

constexpr uint64_t kMainProtocol_TwoWayLocalWithError_Ordinal = 0x2839c029915cb8fclu;

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

constexpr uint64_t kMainProtocol_OnLocal_Ordinal = 0x4745f7438cd80819lu;

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

constexpr uint64_t kMainProtocol_OneWayImport_Ordinal = 0x2e6b091ae4cee40clu;

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

constexpr uint64_t kMainProtocol_TwoWayImport_Ordinal = 0x20f4a8f65ff69473lu;

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

constexpr uint64_t kMainProtocol_TwoWayImportWithError_Ordinal = 0x3b7b706d42eb9bbdlu;

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

constexpr uint64_t kMainProtocol_OnImport_Ordinal = 0x1bb4f4c30b6f8909lu;

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

constexpr uint64_t kMainProtocol_OneWayAnon_Ordinal = 0xb43565c01ab54aclu;

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

constexpr uint64_t kMainProtocol_TwoWayAnon_Ordinal = 0x8bdc969ff7dd759lu;

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

constexpr uint64_t kMainProtocol_TwoWayAnonWithError_Ordinal = 0x5862bf8170c87a36lu;

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

constexpr uint64_t kMainProtocol_OnAnon_Ordinal = 0x42d321dacc4df000lu;

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

#endif  // __Fuchsia__

#ifdef __Fuchsia__

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

  virtual void OneWayComposed(int32_t a) = 0;
  using TwoWayComposedCallback =
      fit::function<void(int32_t)>;

  virtual void TwoWayComposed(int32_t a, TwoWayComposedCallback callback) = 0;
  using TwoWayComposedWithErrorCallback =
      fit::function<void(::test::protocolpayloads::imported::ComposedProtocol_TwoWayComposedWithError_Result)>;

  virtual void TwoWayComposedWithError(int32_t a, TwoWayComposedWithErrorCallback callback) = 0;
  using OnComposedCallback =
      fit::function<void(int32_t)>;

  virtual void OneWayLocal(uint32_t a, uint32_t b) = 0;
  using TwoWayLocalCallback =
      fit::function<void(uint32_t, uint32_t)>;

  virtual void TwoWayLocal(uint32_t a, uint32_t b, TwoWayLocalCallback callback) = 0;
  using TwoWayLocalWithErrorCallback =
      fit::function<void(::test::protocolpayloads::MainProtocol_TwoWayLocalWithError_Result)>;

  virtual void TwoWayLocalWithError(uint32_t a, uint32_t b, TwoWayLocalWithErrorCallback callback) = 0;
  using OnLocalCallback =
      fit::function<void(uint32_t, uint32_t)>;

  virtual void OneWayImport(int32_t a) = 0;
  using TwoWayImportCallback =
      fit::function<void(int32_t)>;

  virtual void TwoWayImport(int32_t a, TwoWayImportCallback callback) = 0;
  using TwoWayImportWithErrorCallback =
      fit::function<void(::test::protocolpayloads::MainProtocol_TwoWayImportWithError_Result)>;

  virtual void TwoWayImportWithError(int32_t a, TwoWayImportWithErrorCallback callback) = 0;
  using OnImportCallback =
      fit::function<void(int32_t)>;

  virtual void OneWayAnon(uint32_t a, uint32_t b) = 0;
  using TwoWayAnonCallback =
      fit::function<void(uint32_t, uint32_t)>;

  virtual void TwoWayAnon(uint32_t a, uint32_t b, TwoWayAnonCallback callback) = 0;
  using TwoWayAnonWithErrorCallback =
      fit::function<void(::test::protocolpayloads::MainProtocol_TwoWayAnonWithError_Result)>;

  virtual void TwoWayAnonWithError(uint32_t a, uint32_t b, TwoWayAnonWithErrorCallback callback) = 0;
  using OnAnonCallback =
      fit::function<void(uint32_t, uint32_t)>;
};

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 OneWayComposed(int32_t a) = 0;
  virtual void TwoWayComposed(int32_t a) = 0;
  virtual void TwoWayComposedWithError(int32_t a) = 0;
  virtual void OneWayLocal(uint32_t a, uint32_t b) = 0;
  virtual void TwoWayLocal(uint32_t a, uint32_t b) = 0;
  virtual void TwoWayLocalWithError(uint32_t a, uint32_t b) = 0;
  virtual void OneWayImport(int32_t a) = 0;
  virtual void TwoWayImport(int32_t a) = 0;
  virtual void TwoWayImportWithError(int32_t a) = 0;
  virtual void OneWayAnon(uint32_t a, uint32_t b) = 0;
  virtual void TwoWayAnon(uint32_t a, uint32_t b) = 0;
  virtual void TwoWayAnonWithError(uint32_t a, uint32_t b) = 0;
};

class MainProtocol_ResponseDecoder {
 public:
  MainProtocol_ResponseDecoder() = default;
  virtual ~MainProtocol_ResponseDecoder() = default;
  static const fidl_type_t* GetType(uint64_t ordinal);
  virtual void TwoWayComposed(int32_t a) = 0;
  virtual void TwoWayComposedWithError(::test::protocolpayloads::imported::ComposedProtocol_TwoWayComposedWithError_Result ComposedProtocol_TwoWayComposedWithError_Result) = 0;
  virtual void OnComposed(int32_t a) = 0;
  virtual void TwoWayLocal(uint32_t a, uint32_t b) = 0;
  virtual void TwoWayLocalWithError(::test::protocolpayloads::MainProtocol_TwoWayLocalWithError_Result MainProtocol_TwoWayLocalWithError_Result) = 0;
  virtual void OnLocal(uint32_t a, uint32_t b) = 0;
  virtual void TwoWayImport(int32_t a) = 0;
  virtual void TwoWayImportWithError(::test::protocolpayloads::MainProtocol_TwoWayImportWithError_Result MainProtocol_TwoWayImportWithError_Result) = 0;
  virtual void OnImport(int32_t a) = 0;
  virtual void TwoWayAnon(uint32_t a, uint32_t b) = 0;
  virtual void TwoWayAnonWithError(::test::protocolpayloads::MainProtocol_TwoWayAnonWithError_Result MainProtocol_TwoWayAnonWithError_Result) = 0;
  virtual void OnAnon(uint32_t a, uint32_t b) = 0;
};

class MainProtocol_EventSender {
 public:
  virtual ~MainProtocol_EventSender();
  virtual void OnComposed(int32_t a) = 0;
  virtual void OnLocal(uint32_t a, uint32_t b) = 0;
  virtual void OnImport(int32_t a) = 0;
  virtual void OnAnon(uint32_t a, uint32_t b) = 0;
};

class MainProtocol_Sync {
 public:
  using Proxy_ = ::test::protocolpayloads::MainProtocol_SyncProxy;
  virtual ~MainProtocol_Sync();
  virtual zx_status_t OneWayComposed(int32_t a) = 0;
  virtual zx_status_t TwoWayComposed(int32_t a, int32_t* out_a) = 0;
  virtual zx_status_t TwoWayComposedWithError(int32_t a, ::test::protocolpayloads::imported::ComposedProtocol_TwoWayComposedWithError_Result* out_ComposedProtocol_TwoWayComposedWithError_Result) = 0;
  virtual zx_status_t OneWayLocal(uint32_t a, uint32_t b) = 0;
  virtual zx_status_t TwoWayLocal(uint32_t a, uint32_t b, uint32_t* out_a, uint32_t* out_b) = 0;
  virtual zx_status_t TwoWayLocalWithError(uint32_t a, uint32_t b, ::test::protocolpayloads::MainProtocol_TwoWayLocalWithError_Result* out_MainProtocol_TwoWayLocalWithError_Result) = 0;
  virtual zx_status_t OneWayImport(int32_t a) = 0;
  virtual zx_status_t TwoWayImport(int32_t a, int32_t* out_a) = 0;
  virtual zx_status_t TwoWayImportWithError(int32_t a, ::test::protocolpayloads::MainProtocol_TwoWayImportWithError_Result* out_MainProtocol_TwoWayImportWithError_Result) = 0;
  virtual zx_status_t OneWayAnon(uint32_t a, uint32_t b) = 0;
  virtual zx_status_t TwoWayAnon(uint32_t a, uint32_t b, uint32_t* out_a, uint32_t* out_b) = 0;
  virtual zx_status_t TwoWayAnonWithError(uint32_t a, uint32_t b, ::test::protocolpayloads::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.protocolpayloads/MainProtocol.OneWayComposed
  void OneWayComposed(int32_t a) override;
  // cts-coverage-fidl-name:test.protocolpayloads/MainProtocol.TwoWayComposed
  void TwoWayComposed(int32_t a, TwoWayComposedCallback callback) override;
  // cts-coverage-fidl-name:test.protocolpayloads/MainProtocol.TwoWayComposedWithError
  void TwoWayComposedWithError(int32_t a, TwoWayComposedWithErrorCallback callback) override;
  OnComposedCallback OnComposed;
  // cts-coverage-fidl-name:test.protocolpayloads/MainProtocol.OneWayLocal
  void OneWayLocal(uint32_t a, uint32_t b) override;
  // cts-coverage-fidl-name:test.protocolpayloads/MainProtocol.TwoWayLocal
  void TwoWayLocal(uint32_t a, uint32_t b, TwoWayLocalCallback callback) override;
  // cts-coverage-fidl-name:test.protocolpayloads/MainProtocol.TwoWayLocalWithError
  void TwoWayLocalWithError(uint32_t a, uint32_t b, TwoWayLocalWithErrorCallback callback) override;
  OnLocalCallback OnLocal;
  // cts-coverage-fidl-name:test.protocolpayloads/MainProtocol.OneWayImport
  void OneWayImport(int32_t a) override;
  // cts-coverage-fidl-name:test.protocolpayloads/MainProtocol.TwoWayImport
  void TwoWayImport(int32_t a, TwoWayImportCallback callback) override;
  // cts-coverage-fidl-name:test.protocolpayloads/MainProtocol.TwoWayImportWithError
  void TwoWayImportWithError(int32_t a, TwoWayImportWithErrorCallback callback) override;
  OnImportCallback OnImport;
  // cts-coverage-fidl-name:test.protocolpayloads/MainProtocol.OneWayAnon
  void OneWayAnon(uint32_t a, uint32_t b) override;
  // cts-coverage-fidl-name:test.protocolpayloads/MainProtocol.TwoWayAnon
  void TwoWayAnon(uint32_t a, uint32_t b, TwoWayAnonCallback callback) override;
  // cts-coverage-fidl-name:test.protocolpayloads/MainProtocol.TwoWayAnonWithError
  void TwoWayAnonWithError(uint32_t a, uint32_t b, TwoWayAnonWithErrorCallback callback) override;
  OnAnonCallback OnAnon;

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

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

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

  zx_status_t Dispatch_(::fidl::HLCPPIncomingMessage message,
                        ::fidl::internal::PendingResponse response) override;
  void OnComposed(int32_t a) override;
  void OnLocal(uint32_t a, uint32_t b) override;
  void OnImport(int32_t a) override;
  void OnAnon(uint32_t a, uint32_t b) override;

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

class MainProtocol_SyncProxy : public ::test::protocolpayloads::MainProtocol_Sync {
 public:
  explicit MainProtocol_SyncProxy(::zx::channel channel);
  ~MainProtocol_SyncProxy() override;
  // cts-coverage-fidl-name:test.protocolpayloads/MainProtocol.OneWayComposed
  zx_status_t OneWayComposed(int32_t a) override;
  // cts-coverage-fidl-name:test.protocolpayloads/MainProtocol.TwoWayComposed
  zx_status_t TwoWayComposed(int32_t a, int32_t* out_a) override;
  // cts-coverage-fidl-name:test.protocolpayloads/MainProtocol.TwoWayComposedWithError
  zx_status_t TwoWayComposedWithError(int32_t a, ::test::protocolpayloads::imported::ComposedProtocol_TwoWayComposedWithError_Result* out_ComposedProtocol_TwoWayComposedWithError_Result) override;
  // cts-coverage-fidl-name:test.protocolpayloads/MainProtocol.OneWayLocal
  zx_status_t OneWayLocal(uint32_t a, uint32_t b) override;
  // cts-coverage-fidl-name:test.protocolpayloads/MainProtocol.TwoWayLocal
  zx_status_t TwoWayLocal(uint32_t a, uint32_t b, uint32_t* out_a, uint32_t* out_b) override;
  // cts-coverage-fidl-name:test.protocolpayloads/MainProtocol.TwoWayLocalWithError
  zx_status_t TwoWayLocalWithError(uint32_t a, uint32_t b, ::test::protocolpayloads::MainProtocol_TwoWayLocalWithError_Result* out_MainProtocol_TwoWayLocalWithError_Result) override;
  // cts-coverage-fidl-name:test.protocolpayloads/MainProtocol.OneWayImport
  zx_status_t OneWayImport(int32_t a) override;
  // cts-coverage-fidl-name:test.protocolpayloads/MainProtocol.TwoWayImport
  zx_status_t TwoWayImport(int32_t a, int32_t* out_a) override;
  // cts-coverage-fidl-name:test.protocolpayloads/MainProtocol.TwoWayImportWithError
  zx_status_t TwoWayImportWithError(int32_t a, ::test::protocolpayloads::MainProtocol_TwoWayImportWithError_Result* out_MainProtocol_TwoWayImportWithError_Result) override;
  // cts-coverage-fidl-name:test.protocolpayloads/MainProtocol.OneWayAnon
  zx_status_t OneWayAnon(uint32_t a, uint32_t b) override;
  // cts-coverage-fidl-name:test.protocolpayloads/MainProtocol.TwoWayAnon
  zx_status_t TwoWayAnon(uint32_t a, uint32_t b, uint32_t* out_a, uint32_t* out_b) override;
  // cts-coverage-fidl-name:test.protocolpayloads/MainProtocol.TwoWayAnonWithError
  zx_status_t TwoWayAnonWithError(uint32_t a, uint32_t b, ::test::protocolpayloads::MainProtocol_TwoWayAnonWithError_Result* out_MainProtocol_TwoWayAnonWithError_Result) override;

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

#endif  // __Fuchsia__

}  // namespace protocolpayloads
}  // namespace test