tools/fidl/fidlgen_llcpp/goldens/protocol_payloads_natural_messaging.h.golden

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

#pragma once

#include <fidl/test.protocolpayloads.imported/cpp/natural_messaging.h>
#include <fidl/test.protocolpayloads/cpp/markers.h>
#include <fidl/test.protocolpayloads/cpp/natural_types.h>
#include <fidl/test.protocolpayloads/cpp/wire_messaging.h>
#include <lib/fidl/cpp/channel.h>
#include <lib/fidl/cpp/client.h>
#include <lib/fidl/cpp/internal/thenable.h>
#include <lib/fidl/cpp/natural_types.h>
#include <lib/fidl/cpp/unified_messaging.h>

namespace fidl {

}  // namespace fidl
template <>
struct ::fidl::internal::NaturalMethodTypes<::test_protocolpayloads::MainProtocol::TwoWayComposed> {
  using Completer = fidl::Completer<::fidl::internal::NaturalCompleterBase<::test_protocolpayloads::MainProtocol::TwoWayComposed>>;

  using ResultCallback =
      ::fit::callback<void(::fidl::Result<::test_protocolpayloads::MainProtocol::TwoWayComposed>&)>;

  static constexpr bool HasApplicationError = false;
  static constexpr bool HasTransportError = false;

  static constexpr bool IsAbsentBody = false;
};

template <>
struct ::fidl::internal::NaturalMethodTypes<::test_protocolpayloads::MainProtocol::TwoWayComposedWithError> {
  using Completer = fidl::Completer<::fidl::internal::NaturalCompleterBase<::test_protocolpayloads::MainProtocol::TwoWayComposedWithError>>;

  using ResultCallback =
      ::fit::callback<void(::fidl::Result<::test_protocolpayloads::MainProtocol::TwoWayComposedWithError>&)>;

  static constexpr bool HasApplicationError = true;
  static constexpr bool HasTransportError = false;

  static constexpr bool IsEmptyStructPayload = false;

  static constexpr bool IsAbsentBody = false;
};

template <>
struct ::fidl::internal::NaturalMethodTypes<::test_protocolpayloads::MainProtocol::TwoWayLocal> {
  using Completer = fidl::Completer<::fidl::internal::NaturalCompleterBase<::test_protocolpayloads::MainProtocol::TwoWayLocal>>;

  using ResultCallback =
      ::fit::callback<void(::fidl::Result<::test_protocolpayloads::MainProtocol::TwoWayLocal>&)>;

  static constexpr bool HasApplicationError = false;
  static constexpr bool HasTransportError = false;

  static constexpr bool IsAbsentBody = false;
};

template <>
struct ::fidl::internal::NaturalMethodTypes<::test_protocolpayloads::MainProtocol::TwoWayLocalWithError> {
  using Completer = fidl::Completer<::fidl::internal::NaturalCompleterBase<::test_protocolpayloads::MainProtocol::TwoWayLocalWithError>>;

  using ResultCallback =
      ::fit::callback<void(::fidl::Result<::test_protocolpayloads::MainProtocol::TwoWayLocalWithError>&)>;

  static constexpr bool HasApplicationError = true;
  static constexpr bool HasTransportError = false;

  static constexpr bool IsEmptyStructPayload = false;

  static constexpr bool IsAbsentBody = false;
};

template <>
struct ::fidl::internal::NaturalMethodTypes<::test_protocolpayloads::MainProtocol::TwoWayImport> {
  using Completer = fidl::Completer<::fidl::internal::NaturalCompleterBase<::test_protocolpayloads::MainProtocol::TwoWayImport>>;

  using ResultCallback =
      ::fit::callback<void(::fidl::Result<::test_protocolpayloads::MainProtocol::TwoWayImport>&)>;

  static constexpr bool HasApplicationError = false;
  static constexpr bool HasTransportError = false;

  static constexpr bool IsAbsentBody = false;
};

template <>
struct ::fidl::internal::NaturalMethodTypes<::test_protocolpayloads::MainProtocol::TwoWayImportWithError> {
  using Completer = fidl::Completer<::fidl::internal::NaturalCompleterBase<::test_protocolpayloads::MainProtocol::TwoWayImportWithError>>;

  using ResultCallback =
      ::fit::callback<void(::fidl::Result<::test_protocolpayloads::MainProtocol::TwoWayImportWithError>&)>;

  static constexpr bool HasApplicationError = true;
  static constexpr bool HasTransportError = false;

  static constexpr bool IsEmptyStructPayload = false;

  static constexpr bool IsAbsentBody = false;
};

template <>
struct ::fidl::internal::NaturalMethodTypes<::test_protocolpayloads::MainProtocol::TwoWayAnon> {
  using Completer = fidl::Completer<::fidl::internal::NaturalCompleterBase<::test_protocolpayloads::MainProtocol::TwoWayAnon>>;

  using ResultCallback =
      ::fit::callback<void(::fidl::Result<::test_protocolpayloads::MainProtocol::TwoWayAnon>&)>;

  static constexpr bool HasApplicationError = false;
  static constexpr bool HasTransportError = false;

  static constexpr bool IsAbsentBody = false;
};

template <>
struct ::fidl::internal::NaturalMethodTypes<::test_protocolpayloads::MainProtocol::TwoWayAnonWithError> {
  using Completer = fidl::Completer<::fidl::internal::NaturalCompleterBase<::test_protocolpayloads::MainProtocol::TwoWayAnonWithError>>;

  using ResultCallback =
      ::fit::callback<void(::fidl::Result<::test_protocolpayloads::MainProtocol::TwoWayAnonWithError>&)>;

  static constexpr bool HasApplicationError = true;
  static constexpr bool HasTransportError = false;

  static constexpr bool IsEmptyStructPayload = false;

  static constexpr bool IsAbsentBody = false;
};
namespace test_protocolpayloads {
__LOCAL extern "C" const fidl_type_t test_protocolpayloads_imported_ImportStructPayloadTable;

__LOCAL extern "C" const fidl_type_t test_protocolpayloads_imported_ComposedProtocolTwoWayComposedWithErrorTopResponseTable;

__LOCAL extern "C" const fidl_type_t test_protocolpayloads_imported_ComposedProtocolOnComposedWithErrorRequestTable;
__LOCAL extern "C" const fidl_type_t test_protocolpayloads_LocalStructPayloadTable;

__LOCAL extern "C" const fidl_type_t test_protocolpayloads_MainProtocolTwoWayLocalWithErrorTopResponseTable;

__LOCAL extern "C" const fidl_type_t test_protocolpayloads_MainProtocolOnLocalWithErrorRequestTable;

__LOCAL extern "C" const fidl_type_t test_protocolpayloads_MainProtocolTwoWayImportWithErrorTopResponseTable;

__LOCAL extern "C" const fidl_type_t test_protocolpayloads_MainProtocolOnImportWithErrorRequestTable;
__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_MainProtocolTwoWayAnonTopResponseTable;
__LOCAL extern "C" const fidl_type_t test_protocolpayloads_MainProtocolTwoWayAnonWithErrorRequestTable;
__LOCAL extern "C" const fidl_type_t test_protocolpayloads_MainProtocolTwoWayAnonWithErrorTopResponseTable;

__LOCAL extern "C" const fidl_type_t test_protocolpayloads_MainProtocolOnAnonRequestTable;

__LOCAL extern "C" const fidl_type_t test_protocolpayloads_MainProtocolOnAnonWithErrorRequestTable;

#ifdef __Fuchsia__
}  // namespace test_protocolpayloads

template <>
class ::fidl::Event<::test_protocolpayloads::MainProtocol::OnComposed> final : public ::test_protocolpayloads_imported::ImportStructPayload {
 public:
  using ::test_protocolpayloads_imported::ImportStructPayload::ImportStructPayload;
  Event(::test_protocolpayloads_imported::ImportStructPayload v) : ImportStructPayload(std::move(v)) {}
};

template <>
struct ::fidl::internal::MessageTraits<::fidl::Event<::test_protocolpayloads::MainProtocol::OnComposed>> final {
 public:
  static constexpr bool kHasPayload = true;
  using Payload = ::test_protocolpayloads_imported::ImportStructPayload;
};
namespace test_protocolpayloads {}  // namespace test_protocolpayloads

template <>
class ::fidl::Event<::test_protocolpayloads::MainProtocol::OnComposedWithError> final : public ::fitx::result<uint32_t, ::test_protocolpayloads_imported::ImportStructPayload> {
 public:
  using ::fitx::result<uint32_t, ::test_protocolpayloads_imported::ImportStructPayload>::result;
  Event(::fitx::result<uint32_t, ::test_protocolpayloads_imported::ImportStructPayload> v) : result(std::move(v)) {}
  Event() = delete;
};

template <>
struct ::fidl::internal::MessageTraits<::fidl::Event<::test_protocolpayloads::MainProtocol::OnComposedWithError>> final {
 public:
  static constexpr bool kHasPayload = true;
  using Payload = ::test_protocolpayloads_imported::ComposedProtocolOnComposedWithErrorRequest;
};
template <>
class ::fidl::internal::NaturalMessageConverter<::fidl::Event<::test_protocolpayloads::MainProtocol::OnComposedWithError>> {
  using DomainObject = ::test_protocolpayloads_imported::ComposedProtocolOnComposedWithErrorRequest;

 public:
  static ::fidl::Event<::test_protocolpayloads::MainProtocol::OnComposedWithError> FromDomainObject(DomainObject o) {
    if (o.result().err().has_value()) {
      return ::fitx::error(std::move(o.result().err().value()));
    } else {
      ZX_DEBUG_ASSERT(o.result().response().has_value());
      return ::fitx::ok(std::move(o.result().response().value()));
    }
  }

  static DomainObject IntoDomainObject(::fidl::Event<::test_protocolpayloads::MainProtocol::OnComposedWithError>&& m) {
    if (m.is_error()) {
      return DomainObject{{.result = ::test_protocolpayloads_imported::ComposedProtocolOnComposedWithErrorResult::WithErr(m.error_value())}};
    } else {
      return DomainObject{{.result = ::test_protocolpayloads_imported::ComposedProtocolOnComposedWithErrorResult::WithResponse(std::move(m.value()))}};
    }
  }
};
namespace test_protocolpayloads {}  // namespace test_protocolpayloads

template <>
class ::fidl::Event<::test_protocolpayloads::MainProtocol::OnLocal> final : public ::test_protocolpayloads::LocalStructPayload {
 public:
  using ::test_protocolpayloads::LocalStructPayload::LocalStructPayload;
  Event(::test_protocolpayloads::LocalStructPayload v) : LocalStructPayload(std::move(v)) {}
};

template <>
struct ::fidl::internal::MessageTraits<::fidl::Event<::test_protocolpayloads::MainProtocol::OnLocal>> final {
 public:
  static constexpr bool kHasPayload = true;
  using Payload = ::test_protocolpayloads::LocalStructPayload;
};
namespace test_protocolpayloads {}  // namespace test_protocolpayloads

template <>
class ::fidl::Event<::test_protocolpayloads::MainProtocol::OnLocalWithError> final : public ::fitx::result<uint32_t, ::test_protocolpayloads::LocalStructPayload> {
 public:
  using ::fitx::result<uint32_t, ::test_protocolpayloads::LocalStructPayload>::result;
  Event(::fitx::result<uint32_t, ::test_protocolpayloads::LocalStructPayload> v) : result(std::move(v)) {}
  Event() = delete;
};

template <>
struct ::fidl::internal::MessageTraits<::fidl::Event<::test_protocolpayloads::MainProtocol::OnLocalWithError>> final {
 public:
  static constexpr bool kHasPayload = true;
  using Payload = ::test_protocolpayloads::MainProtocolOnLocalWithErrorRequest;
};
template <>
class ::fidl::internal::NaturalMessageConverter<::fidl::Event<::test_protocolpayloads::MainProtocol::OnLocalWithError>> {
  using DomainObject = ::test_protocolpayloads::MainProtocolOnLocalWithErrorRequest;

 public:
  static ::fidl::Event<::test_protocolpayloads::MainProtocol::OnLocalWithError> FromDomainObject(DomainObject o) {
    if (o.result().err().has_value()) {
      return ::fitx::error(std::move(o.result().err().value()));
    } else {
      ZX_DEBUG_ASSERT(o.result().response().has_value());
      return ::fitx::ok(std::move(o.result().response().value()));
    }
  }

  static DomainObject IntoDomainObject(::fidl::Event<::test_protocolpayloads::MainProtocol::OnLocalWithError>&& m) {
    if (m.is_error()) {
      return DomainObject{{.result = ::test_protocolpayloads::MainProtocolOnLocalWithErrorResult::WithErr(m.error_value())}};
    } else {
      return DomainObject{{.result = ::test_protocolpayloads::MainProtocolOnLocalWithErrorResult::WithResponse(std::move(m.value()))}};
    }
  }
};
namespace test_protocolpayloads {}  // namespace test_protocolpayloads

template <>
class ::fidl::Event<::test_protocolpayloads::MainProtocol::OnImport> final : public ::test_protocolpayloads_imported::ImportStructPayload {
 public:
  using ::test_protocolpayloads_imported::ImportStructPayload::ImportStructPayload;
  Event(::test_protocolpayloads_imported::ImportStructPayload v) : ImportStructPayload(std::move(v)) {}
};

template <>
struct ::fidl::internal::MessageTraits<::fidl::Event<::test_protocolpayloads::MainProtocol::OnImport>> final {
 public:
  static constexpr bool kHasPayload = true;
  using Payload = ::test_protocolpayloads_imported::ImportStructPayload;
};
namespace test_protocolpayloads {}  // namespace test_protocolpayloads

template <>
class ::fidl::Event<::test_protocolpayloads::MainProtocol::OnImportWithError> final : public ::fitx::result<uint32_t, ::test_protocolpayloads_imported::ImportStructPayload> {
 public:
  using ::fitx::result<uint32_t, ::test_protocolpayloads_imported::ImportStructPayload>::result;
  Event(::fitx::result<uint32_t, ::test_protocolpayloads_imported::ImportStructPayload> v) : result(std::move(v)) {}
  Event() = delete;
};

template <>
struct ::fidl::internal::MessageTraits<::fidl::Event<::test_protocolpayloads::MainProtocol::OnImportWithError>> final {
 public:
  static constexpr bool kHasPayload = true;
  using Payload = ::test_protocolpayloads::MainProtocolOnImportWithErrorRequest;
};
template <>
class ::fidl::internal::NaturalMessageConverter<::fidl::Event<::test_protocolpayloads::MainProtocol::OnImportWithError>> {
  using DomainObject = ::test_protocolpayloads::MainProtocolOnImportWithErrorRequest;

 public:
  static ::fidl::Event<::test_protocolpayloads::MainProtocol::OnImportWithError> FromDomainObject(DomainObject o) {
    if (o.result().err().has_value()) {
      return ::fitx::error(std::move(o.result().err().value()));
    } else {
      ZX_DEBUG_ASSERT(o.result().response().has_value());
      return ::fitx::ok(std::move(o.result().response().value()));
    }
  }

  static DomainObject IntoDomainObject(::fidl::Event<::test_protocolpayloads::MainProtocol::OnImportWithError>&& m) {
    if (m.is_error()) {
      return DomainObject{{.result = ::test_protocolpayloads::MainProtocolOnImportWithErrorResult::WithErr(m.error_value())}};
    } else {
      return DomainObject{{.result = ::test_protocolpayloads::MainProtocolOnImportWithErrorResult::WithResponse(std::move(m.value()))}};
    }
  }
};
namespace test_protocolpayloads {}  // namespace test_protocolpayloads

template <>
class ::fidl::Event<::test_protocolpayloads::MainProtocol::OnAnon> final : public ::test_protocolpayloads::MainProtocolOnAnonRequest {
 public:
  using ::test_protocolpayloads::MainProtocolOnAnonRequest::MainProtocolOnAnonRequest;
  Event(::test_protocolpayloads::MainProtocolOnAnonRequest v) : MainProtocolOnAnonRequest(std::move(v)) {}
};

template <>
struct ::fidl::internal::MessageTraits<::fidl::Event<::test_protocolpayloads::MainProtocol::OnAnon>> final {
 public:
  static constexpr bool kHasPayload = true;
  using Payload = ::test_protocolpayloads::MainProtocolOnAnonRequest;
};
namespace test_protocolpayloads {}  // namespace test_protocolpayloads

template <>
class ::fidl::Event<::test_protocolpayloads::MainProtocol::OnAnonWithError> final : public ::fitx::result<uint32_t, ::test_protocolpayloads::MainProtocolOnAnonWithErrorResponse> {
 public:
  using ::fitx::result<uint32_t, ::test_protocolpayloads::MainProtocolOnAnonWithErrorResponse>::result;
  Event(::fitx::result<uint32_t, ::test_protocolpayloads::MainProtocolOnAnonWithErrorResponse> v) : result(std::move(v)) {}
  Event() = delete;
};

template <>
struct ::fidl::internal::MessageTraits<::fidl::Event<::test_protocolpayloads::MainProtocol::OnAnonWithError>> final {
 public:
  static constexpr bool kHasPayload = true;
  using Payload = ::test_protocolpayloads::MainProtocolOnAnonWithErrorRequest;
};
template <>
class ::fidl::internal::NaturalMessageConverter<::fidl::Event<::test_protocolpayloads::MainProtocol::OnAnonWithError>> {
  using DomainObject = ::test_protocolpayloads::MainProtocolOnAnonWithErrorRequest;

 public:
  static ::fidl::Event<::test_protocolpayloads::MainProtocol::OnAnonWithError> FromDomainObject(DomainObject o) {
    if (o.result().err().has_value()) {
      return ::fitx::error(std::move(o.result().err().value()));
    } else {
      ZX_DEBUG_ASSERT(o.result().response().has_value());
      return ::fitx::ok(std::move(o.result().response().value()));
    }
  }

  static DomainObject IntoDomainObject(::fidl::Event<::test_protocolpayloads::MainProtocol::OnAnonWithError>&& m) {
    if (m.is_error()) {
      return DomainObject{{.result = ::test_protocolpayloads::MainProtocolOnAnonWithErrorResult::WithErr(m.error_value())}};
    } else {
      return DomainObject{{.result = ::test_protocolpayloads::MainProtocolOnAnonWithErrorResult::WithResponse(std::move(m.value()))}};
    }
  }
};
namespace test_protocolpayloads {}  // namespace test_protocolpayloads

template <>
class ::fidl::Response<::test_protocolpayloads::MainProtocol::TwoWayComposed> final : public ::test_protocolpayloads_imported::ImportStructPayload {
 public:
  using ::test_protocolpayloads_imported::ImportStructPayload::ImportStructPayload;
  Response(::test_protocolpayloads_imported::ImportStructPayload v) : ImportStructPayload(std::move(v)) {}
};

template <>
struct ::fidl::internal::MessageTraits<::fidl::Response<::test_protocolpayloads::MainProtocol::TwoWayComposed>> final {
 public:
  static constexpr bool kHasPayload = true;
  using Payload = ::test_protocolpayloads_imported::ImportStructPayload;
};
namespace test_protocolpayloads {}  // namespace test_protocolpayloads
template <>
class ::fidl::Result<::test_protocolpayloads::MainProtocol::TwoWayComposed> final : public ::fitx::result<::fidl::Error, ::test_protocolpayloads_imported::ImportStructPayload> {
 public:
  using ::fitx::result<::fidl::Error, ::test_protocolpayloads_imported::ImportStructPayload>::result;

 protected:
  Result() = default;
};

template <>
class ::fidl::Response<::test_protocolpayloads::MainProtocol::TwoWayComposedWithError> final : public ::fitx::result<uint32_t, ::test_protocolpayloads_imported::ImportStructPayload> {
 public:
  using ::fitx::result<uint32_t, ::test_protocolpayloads_imported::ImportStructPayload>::result;
  Response(::fitx::result<uint32_t, ::test_protocolpayloads_imported::ImportStructPayload> v) : result(std::move(v)) {}
  Response() = delete;
};

template <>
struct ::fidl::internal::MessageTraits<::fidl::Response<::test_protocolpayloads::MainProtocol::TwoWayComposedWithError>> final {
 public:
  static constexpr bool kHasPayload = true;
  using Payload = ::test_protocolpayloads_imported::ComposedProtocolTwoWayComposedWithErrorTopResponse;
};
template <>
class ::fidl::internal::NaturalMessageConverter<::fidl::Response<::test_protocolpayloads::MainProtocol::TwoWayComposedWithError>> {
  using DomainObject = ::test_protocolpayloads_imported::ComposedProtocolTwoWayComposedWithErrorTopResponse;

 public:
  static ::fidl::Response<::test_protocolpayloads::MainProtocol::TwoWayComposedWithError> FromDomainObject(DomainObject o) {
    if (o.result().err().has_value()) {
      return ::fitx::error(std::move(o.result().err().value()));
    } else {
      ZX_DEBUG_ASSERT(o.result().response().has_value());
      return ::fitx::ok(std::move(o.result().response().value()));
    }
  }

  static DomainObject IntoDomainObject(::fidl::Response<::test_protocolpayloads::MainProtocol::TwoWayComposedWithError>&& m) {
    if (m.is_error()) {
      return DomainObject{{.result = ::test_protocolpayloads_imported::ComposedProtocolTwoWayComposedWithErrorResult::WithErr(m.error_value())}};
    } else {
      return DomainObject{{.result = ::test_protocolpayloads_imported::ComposedProtocolTwoWayComposedWithErrorResult::WithResponse(std::move(m.value()))}};
    }
  }
};
template <>
class ::fidl::Result<::test_protocolpayloads::MainProtocol::TwoWayComposedWithError> final : public ::fitx::result<::fidl::AnyErrorIn<::test_protocolpayloads::MainProtocol::TwoWayComposedWithError>, ::test_protocolpayloads_imported::ImportStructPayload> {
 public:
  using ::fitx::result<::fidl::AnyErrorIn<::test_protocolpayloads::MainProtocol::TwoWayComposedWithError>, ::test_protocolpayloads_imported::ImportStructPayload>::result;

 protected:
  Result() = default;
};

template <>
class ::fidl::Response<::test_protocolpayloads::MainProtocol::TwoWayLocal> final : public ::test_protocolpayloads::LocalStructPayload {
 public:
  using ::test_protocolpayloads::LocalStructPayload::LocalStructPayload;
  Response(::test_protocolpayloads::LocalStructPayload v) : LocalStructPayload(std::move(v)) {}
};

template <>
struct ::fidl::internal::MessageTraits<::fidl::Response<::test_protocolpayloads::MainProtocol::TwoWayLocal>> final {
 public:
  static constexpr bool kHasPayload = true;
  using Payload = ::test_protocolpayloads::LocalStructPayload;
};
template <>
class ::fidl::Result<::test_protocolpayloads::MainProtocol::TwoWayLocal> final : public ::fitx::result<::fidl::Error, ::test_protocolpayloads::LocalStructPayload> {
 public:
  using ::fitx::result<::fidl::Error, ::test_protocolpayloads::LocalStructPayload>::result;

 protected:
  Result() = default;
};

template <>
class ::fidl::Response<::test_protocolpayloads::MainProtocol::TwoWayLocalWithError> final : public ::fitx::result<uint32_t, ::test_protocolpayloads::LocalStructPayload> {
 public:
  using ::fitx::result<uint32_t, ::test_protocolpayloads::LocalStructPayload>::result;
  Response(::fitx::result<uint32_t, ::test_protocolpayloads::LocalStructPayload> v) : result(std::move(v)) {}
  Response() = delete;
};

template <>
struct ::fidl::internal::MessageTraits<::fidl::Response<::test_protocolpayloads::MainProtocol::TwoWayLocalWithError>> final {
 public:
  static constexpr bool kHasPayload = true;
  using Payload = ::test_protocolpayloads::MainProtocolTwoWayLocalWithErrorTopResponse;
};
template <>
class ::fidl::internal::NaturalMessageConverter<::fidl::Response<::test_protocolpayloads::MainProtocol::TwoWayLocalWithError>> {
  using DomainObject = ::test_protocolpayloads::MainProtocolTwoWayLocalWithErrorTopResponse;

 public:
  static ::fidl::Response<::test_protocolpayloads::MainProtocol::TwoWayLocalWithError> FromDomainObject(DomainObject o) {
    if (o.result().err().has_value()) {
      return ::fitx::error(std::move(o.result().err().value()));
    } else {
      ZX_DEBUG_ASSERT(o.result().response().has_value());
      return ::fitx::ok(std::move(o.result().response().value()));
    }
  }

  static DomainObject IntoDomainObject(::fidl::Response<::test_protocolpayloads::MainProtocol::TwoWayLocalWithError>&& m) {
    if (m.is_error()) {
      return DomainObject{{.result = ::test_protocolpayloads::MainProtocolTwoWayLocalWithErrorResult::WithErr(m.error_value())}};
    } else {
      return DomainObject{{.result = ::test_protocolpayloads::MainProtocolTwoWayLocalWithErrorResult::WithResponse(std::move(m.value()))}};
    }
  }
};
template <>
class ::fidl::Result<::test_protocolpayloads::MainProtocol::TwoWayLocalWithError> final : public ::fitx::result<::fidl::AnyErrorIn<::test_protocolpayloads::MainProtocol::TwoWayLocalWithError>, ::test_protocolpayloads::LocalStructPayload> {
 public:
  using ::fitx::result<::fidl::AnyErrorIn<::test_protocolpayloads::MainProtocol::TwoWayLocalWithError>, ::test_protocolpayloads::LocalStructPayload>::result;

 protected:
  Result() = default;
};

template <>
class ::fidl::Response<::test_protocolpayloads::MainProtocol::TwoWayImport> final : public ::test_protocolpayloads_imported::ImportStructPayload {
 public:
  using ::test_protocolpayloads_imported::ImportStructPayload::ImportStructPayload;
  Response(::test_protocolpayloads_imported::ImportStructPayload v) : ImportStructPayload(std::move(v)) {}
};

template <>
struct ::fidl::internal::MessageTraits<::fidl::Response<::test_protocolpayloads::MainProtocol::TwoWayImport>> final {
 public:
  static constexpr bool kHasPayload = true;
  using Payload = ::test_protocolpayloads_imported::ImportStructPayload;
};
template <>
class ::fidl::Result<::test_protocolpayloads::MainProtocol::TwoWayImport> final : public ::fitx::result<::fidl::Error, ::test_protocolpayloads_imported::ImportStructPayload> {
 public:
  using ::fitx::result<::fidl::Error, ::test_protocolpayloads_imported::ImportStructPayload>::result;

 protected:
  Result() = default;
};

template <>
class ::fidl::Response<::test_protocolpayloads::MainProtocol::TwoWayImportWithError> final : public ::fitx::result<uint32_t, ::test_protocolpayloads_imported::ImportStructPayload> {
 public:
  using ::fitx::result<uint32_t, ::test_protocolpayloads_imported::ImportStructPayload>::result;
  Response(::fitx::result<uint32_t, ::test_protocolpayloads_imported::ImportStructPayload> v) : result(std::move(v)) {}
  Response() = delete;
};

template <>
struct ::fidl::internal::MessageTraits<::fidl::Response<::test_protocolpayloads::MainProtocol::TwoWayImportWithError>> final {
 public:
  static constexpr bool kHasPayload = true;
  using Payload = ::test_protocolpayloads::MainProtocolTwoWayImportWithErrorTopResponse;
};
template <>
class ::fidl::internal::NaturalMessageConverter<::fidl::Response<::test_protocolpayloads::MainProtocol::TwoWayImportWithError>> {
  using DomainObject = ::test_protocolpayloads::MainProtocolTwoWayImportWithErrorTopResponse;

 public:
  static ::fidl::Response<::test_protocolpayloads::MainProtocol::TwoWayImportWithError> FromDomainObject(DomainObject o) {
    if (o.result().err().has_value()) {
      return ::fitx::error(std::move(o.result().err().value()));
    } else {
      ZX_DEBUG_ASSERT(o.result().response().has_value());
      return ::fitx::ok(std::move(o.result().response().value()));
    }
  }

  static DomainObject IntoDomainObject(::fidl::Response<::test_protocolpayloads::MainProtocol::TwoWayImportWithError>&& m) {
    if (m.is_error()) {
      return DomainObject{{.result = ::test_protocolpayloads::MainProtocolTwoWayImportWithErrorResult::WithErr(m.error_value())}};
    } else {
      return DomainObject{{.result = ::test_protocolpayloads::MainProtocolTwoWayImportWithErrorResult::WithResponse(std::move(m.value()))}};
    }
  }
};
template <>
class ::fidl::Result<::test_protocolpayloads::MainProtocol::TwoWayImportWithError> final : public ::fitx::result<::fidl::AnyErrorIn<::test_protocolpayloads::MainProtocol::TwoWayImportWithError>, ::test_protocolpayloads_imported::ImportStructPayload> {
 public:
  using ::fitx::result<::fidl::AnyErrorIn<::test_protocolpayloads::MainProtocol::TwoWayImportWithError>, ::test_protocolpayloads_imported::ImportStructPayload>::result;

 protected:
  Result() = default;
};

template <>
class ::fidl::Response<::test_protocolpayloads::MainProtocol::TwoWayAnon> final : public ::test_protocolpayloads::MainProtocolTwoWayAnonTopResponse {
 public:
  using ::test_protocolpayloads::MainProtocolTwoWayAnonTopResponse::MainProtocolTwoWayAnonTopResponse;
  Response(::test_protocolpayloads::MainProtocolTwoWayAnonTopResponse v) : MainProtocolTwoWayAnonTopResponse(std::move(v)) {}
};

template <>
struct ::fidl::internal::MessageTraits<::fidl::Response<::test_protocolpayloads::MainProtocol::TwoWayAnon>> final {
 public:
  static constexpr bool kHasPayload = true;
  using Payload = ::test_protocolpayloads::MainProtocolTwoWayAnonTopResponse;
};
template <>
class ::fidl::Result<::test_protocolpayloads::MainProtocol::TwoWayAnon> final : public ::fitx::result<::fidl::Error, ::test_protocolpayloads::MainProtocolTwoWayAnonTopResponse> {
 public:
  using ::fitx::result<::fidl::Error, ::test_protocolpayloads::MainProtocolTwoWayAnonTopResponse>::result;

 protected:
  Result() = default;
};

template <>
class ::fidl::Response<::test_protocolpayloads::MainProtocol::TwoWayAnonWithError> final : public ::fitx::result<uint32_t, ::test_protocolpayloads::MainProtocolTwoWayAnonWithErrorResponse> {
 public:
  using ::fitx::result<uint32_t, ::test_protocolpayloads::MainProtocolTwoWayAnonWithErrorResponse>::result;
  Response(::fitx::result<uint32_t, ::test_protocolpayloads::MainProtocolTwoWayAnonWithErrorResponse> v) : result(std::move(v)) {}
  Response() = delete;
};

template <>
struct ::fidl::internal::MessageTraits<::fidl::Response<::test_protocolpayloads::MainProtocol::TwoWayAnonWithError>> final {
 public:
  static constexpr bool kHasPayload = true;
  using Payload = ::test_protocolpayloads::MainProtocolTwoWayAnonWithErrorTopResponse;
};
template <>
class ::fidl::internal::NaturalMessageConverter<::fidl::Response<::test_protocolpayloads::MainProtocol::TwoWayAnonWithError>> {
  using DomainObject = ::test_protocolpayloads::MainProtocolTwoWayAnonWithErrorTopResponse;

 public:
  static ::fidl::Response<::test_protocolpayloads::MainProtocol::TwoWayAnonWithError> FromDomainObject(DomainObject o) {
    if (o.result().err().has_value()) {
      return ::fitx::error(std::move(o.result().err().value()));
    } else {
      ZX_DEBUG_ASSERT(o.result().response().has_value());
      return ::fitx::ok(std::move(o.result().response().value()));
    }
  }

  static DomainObject IntoDomainObject(::fidl::Response<::test_protocolpayloads::MainProtocol::TwoWayAnonWithError>&& m) {
    if (m.is_error()) {
      return DomainObject{{.result = ::test_protocolpayloads::MainProtocolTwoWayAnonWithErrorResult::WithErr(m.error_value())}};
    } else {
      return DomainObject{{.result = ::test_protocolpayloads::MainProtocolTwoWayAnonWithErrorResult::WithResponse(std::move(m.value()))}};
    }
  }
};
template <>
class ::fidl::Result<::test_protocolpayloads::MainProtocol::TwoWayAnonWithError> final : public ::fitx::result<::fidl::AnyErrorIn<::test_protocolpayloads::MainProtocol::TwoWayAnonWithError>, ::test_protocolpayloads::MainProtocolTwoWayAnonWithErrorResponse> {
 public:
  using ::fitx::result<::fidl::AnyErrorIn<::test_protocolpayloads::MainProtocol::TwoWayAnonWithError>, ::test_protocolpayloads::MainProtocolTwoWayAnonWithErrorResponse>::result;

 protected:
  Result() = default;
};

template <>
class ::fidl::internal::NaturalClientImpl<::test_protocolpayloads::MainProtocol> final : public ::fidl::internal::NaturalClientBase {
 public:
  using NaturalClientBase::NaturalClientBase;
  ::fidl::internal::NaturalThenable<::test_protocolpayloads::MainProtocol::TwoWayComposed> TwoWayComposed(::fidl::Request<::test_protocolpayloads::MainProtocol::TwoWayComposed> request) const;

  ::fidl::internal::NaturalThenable<::test_protocolpayloads::MainProtocol::TwoWayComposedWithError> TwoWayComposedWithError(::fidl::Request<::test_protocolpayloads::MainProtocol::TwoWayComposedWithError> request) const;

  ::fidl::internal::NaturalThenable<::test_protocolpayloads::MainProtocol::TwoWayLocal> TwoWayLocal(::fidl::Request<::test_protocolpayloads::MainProtocol::TwoWayLocal> request) const;

  ::fidl::internal::NaturalThenable<::test_protocolpayloads::MainProtocol::TwoWayLocalWithError> TwoWayLocalWithError(::fidl::Request<::test_protocolpayloads::MainProtocol::TwoWayLocalWithError> request) const;

  ::fidl::internal::NaturalThenable<::test_protocolpayloads::MainProtocol::TwoWayImport> TwoWayImport(::fidl::Request<::test_protocolpayloads::MainProtocol::TwoWayImport> request) const;

  ::fidl::internal::NaturalThenable<::test_protocolpayloads::MainProtocol::TwoWayImportWithError> TwoWayImportWithError(::fidl::Request<::test_protocolpayloads::MainProtocol::TwoWayImportWithError> request) const;

  ::fidl::internal::NaturalThenable<::test_protocolpayloads::MainProtocol::TwoWayAnon> TwoWayAnon(::fidl::Request<::test_protocolpayloads::MainProtocol::TwoWayAnon> request) const;

  ::fidl::internal::NaturalThenable<::test_protocolpayloads::MainProtocol::TwoWayAnonWithError> TwoWayAnonWithError(::fidl::Request<::test_protocolpayloads::MainProtocol::TwoWayAnonWithError> request) const;

  ::fitx::result<::fidl::Error> OneWayComposed(::fidl::Request<::test_protocolpayloads::MainProtocol::OneWayComposed> request) const;

  ::fitx::result<::fidl::Error> OneWayLocal(::fidl::Request<::test_protocolpayloads::MainProtocol::OneWayLocal> request) const;

  ::fitx::result<::fidl::Error> OneWayImport(::fidl::Request<::test_protocolpayloads::MainProtocol::OneWayImport> request) const;

  ::fitx::result<::fidl::Error> OneWayAnon(::fidl::Request<::test_protocolpayloads::MainProtocol::OneWayAnon> request) const;
};
namespace test_protocolpayloads {
#endif  // __Fuchsia__

}  // namespace test_protocolpayloads
#ifdef __Fuchsia__

template <>
class ::fidl::internal::NaturalSyncClientImpl<::test_protocolpayloads::MainProtocol> final
    : public ::fidl::internal::SyncEndpointManagedVeneer<::fidl::internal::NaturalSyncClientImpl<::test_protocolpayloads::MainProtocol>> {
 public:
  ::fidl::Result<::test_protocolpayloads::MainProtocol::TwoWayComposed> TwoWayComposed(::fidl::Request<::test_protocolpayloads::MainProtocol::TwoWayComposed> request);

  ::fidl::Result<::test_protocolpayloads::MainProtocol::TwoWayComposedWithError> TwoWayComposedWithError(::fidl::Request<::test_protocolpayloads::MainProtocol::TwoWayComposedWithError> request);

  ::fidl::Result<::test_protocolpayloads::MainProtocol::TwoWayLocal> TwoWayLocal(::fidl::Request<::test_protocolpayloads::MainProtocol::TwoWayLocal> request);

  ::fidl::Result<::test_protocolpayloads::MainProtocol::TwoWayLocalWithError> TwoWayLocalWithError(::fidl::Request<::test_protocolpayloads::MainProtocol::TwoWayLocalWithError> request);

  ::fidl::Result<::test_protocolpayloads::MainProtocol::TwoWayImport> TwoWayImport(::fidl::Request<::test_protocolpayloads::MainProtocol::TwoWayImport> request);

  ::fidl::Result<::test_protocolpayloads::MainProtocol::TwoWayImportWithError> TwoWayImportWithError(::fidl::Request<::test_protocolpayloads::MainProtocol::TwoWayImportWithError> request);

  ::fidl::Result<::test_protocolpayloads::MainProtocol::TwoWayAnon> TwoWayAnon(::fidl::Request<::test_protocolpayloads::MainProtocol::TwoWayAnon> request);

  ::fidl::Result<::test_protocolpayloads::MainProtocol::TwoWayAnonWithError> TwoWayAnonWithError(::fidl::Request<::test_protocolpayloads::MainProtocol::TwoWayAnonWithError> request);

  ::fitx::result<::fidl::Error> OneWayComposed(::fidl::Request<::test_protocolpayloads::MainProtocol::OneWayComposed> request);

  ::fitx::result<::fidl::Error> OneWayLocal(::fidl::Request<::test_protocolpayloads::MainProtocol::OneWayLocal> request);

  ::fitx::result<::fidl::Error> OneWayImport(::fidl::Request<::test_protocolpayloads::MainProtocol::OneWayImport> request);

  ::fitx::result<::fidl::Error> OneWayAnon(::fidl::Request<::test_protocolpayloads::MainProtocol::OneWayAnon> request);

 private:
  ::fidl::UnownedClientEnd<::test_protocolpayloads::MainProtocol> _client_end() const {
    return ::fidl::UnownedClientEnd<::test_protocolpayloads::MainProtocol>(
        _transport().get<::fidl::internal::ChannelTransport>());
  }
};
#endif  // __Fuchsia__

#ifdef __Fuchsia__

template <>
class ::fidl::internal::NaturalEventHandlerInterface<::test_protocolpayloads::MainProtocol> : public ::fidl::internal::BaseEventHandlerInterface {
 public:
  NaturalEventHandlerInterface() = default;
  virtual ~NaturalEventHandlerInterface() = default;
  virtual void OnComposed(::fidl::Event<::test_protocolpayloads::MainProtocol::OnComposed>&) = 0;
  virtual void OnComposedWithError(::fidl::Event<::test_protocolpayloads::MainProtocol::OnComposedWithError>&) = 0;
  virtual void OnLocal(::fidl::Event<::test_protocolpayloads::MainProtocol::OnLocal>&) = 0;
  virtual void OnLocalWithError(::fidl::Event<::test_protocolpayloads::MainProtocol::OnLocalWithError>&) = 0;
  virtual void OnImport(::fidl::Event<::test_protocolpayloads::MainProtocol::OnImport>&) = 0;
  virtual void OnImportWithError(::fidl::Event<::test_protocolpayloads::MainProtocol::OnImportWithError>&) = 0;
  virtual void OnAnon(::fidl::Event<::test_protocolpayloads::MainProtocol::OnAnon>&) = 0;
  virtual void OnAnonWithError(::fidl::Event<::test_protocolpayloads::MainProtocol::OnAnonWithError>&) = 0;
};

template <>
class ::fidl::AsyncEventHandler<::test_protocolpayloads::MainProtocol>
    : public ::fidl::internal::NaturalEventHandlerInterface<::test_protocolpayloads::MainProtocol>, public ::fidl::internal::AsyncEventHandler {
 public:
  AsyncEventHandler() = default;
  void OnComposed(::fidl::Event<::test_protocolpayloads::MainProtocol::OnComposed>&) override {}
  void OnComposedWithError(::fidl::Event<::test_protocolpayloads::MainProtocol::OnComposedWithError>&) override {}
  void OnLocal(::fidl::Event<::test_protocolpayloads::MainProtocol::OnLocal>&) override {}
  void OnLocalWithError(::fidl::Event<::test_protocolpayloads::MainProtocol::OnLocalWithError>&) override {}
  void OnImport(::fidl::Event<::test_protocolpayloads::MainProtocol::OnImport>&) override {}
  void OnImportWithError(::fidl::Event<::test_protocolpayloads::MainProtocol::OnImportWithError>&) override {}
  void OnAnon(::fidl::Event<::test_protocolpayloads::MainProtocol::OnAnon>&) override {}
  void OnAnonWithError(::fidl::Event<::test_protocolpayloads::MainProtocol::OnAnonWithError>&) override {}
};

template <>
class ::fidl::SyncEventHandler<::test_protocolpayloads::MainProtocol>
    : public ::fidl::internal::NaturalEventHandlerInterface<::test_protocolpayloads::MainProtocol>, public ::fidl::internal::SyncEventHandler {
 public:
  SyncEventHandler() = default;

  // Handle all possible events defined in this protocol.
  // Blocks to consume exactly one message from the channel, then call the corresponding virtual
  // method.
  ::fidl::Status HandleOneEvent(
      ::fidl::UnownedClientEnd<::test_protocolpayloads::MainProtocol> client_end);
};

template <>
class ::fidl::internal::NaturalEventDispatcher<::test_protocolpayloads::MainProtocol> final : public ::fidl::internal::IncomingEventDispatcher<::fidl::internal::NaturalEventHandlerInterface<::test_protocolpayloads::MainProtocol>> {
 public:
  explicit NaturalEventDispatcher(::fidl::internal::NaturalEventHandlerInterface<::test_protocolpayloads::MainProtocol>* event_handler)
      : IncomingEventDispatcher(event_handler) {}
  ::fidl::Status DispatchEvent(
      ::fidl::IncomingMessage& msg,
      internal::MessageStorageViewBase* storage_view) override;
};
#endif  // __Fuchsia__

#ifdef __Fuchsia__
template <>
class ::fidl::internal::NaturalWeakEventSender<::test_protocolpayloads::MainProtocol> : public ::fidl::internal::WeakEventSenderBase {
 public:
  using WeakEventSenderBase::WeakEventSenderBase;

  ::fitx::result<::fidl::Error> OnComposed(::test_protocolpayloads_imported::ImportStructPayload payload);

  ::fitx::result<::fidl::Error> OnComposedWithError(::test_protocolpayloads_imported::ComposedProtocolOnComposedWithErrorRequest payload);

  ::fitx::result<::fidl::Error> OnLocal(::test_protocolpayloads::LocalStructPayload payload);

  ::fitx::result<::fidl::Error> OnLocalWithError(::test_protocolpayloads::MainProtocolOnLocalWithErrorRequest payload);

  ::fitx::result<::fidl::Error> OnImport(::test_protocolpayloads_imported::ImportStructPayload payload);

  ::fitx::result<::fidl::Error> OnImportWithError(::test_protocolpayloads::MainProtocolOnImportWithErrorRequest payload);

  ::fitx::result<::fidl::Error> OnAnon(::test_protocolpayloads::MainProtocolOnAnonRequest payload);

  ::fitx::result<::fidl::Error> OnAnonWithError(::test_protocolpayloads::MainProtocolOnAnonWithErrorRequest payload);
};

template <>
class ::fidl::internal::NaturalEventSender<::test_protocolpayloads::MainProtocol>
    : public ::fidl::internal::SyncEndpointManagedVeneer<::fidl::internal::NaturalEventSender<::test_protocolpayloads::MainProtocol>> {
 public:
  using SyncEndpointManagedVeneer::SyncEndpointManagedVeneer;

  ::fitx::result<::fidl::Error> OnComposed(::test_protocolpayloads_imported::ImportStructPayload payload);

  ::fitx::result<::fidl::Error> OnComposedWithError(::test_protocolpayloads_imported::ComposedProtocolOnComposedWithErrorRequest payload);

  ::fitx::result<::fidl::Error> OnLocal(::test_protocolpayloads::LocalStructPayload payload);

  ::fitx::result<::fidl::Error> OnLocalWithError(::test_protocolpayloads::MainProtocolOnLocalWithErrorRequest payload);

  ::fitx::result<::fidl::Error> OnImport(::test_protocolpayloads_imported::ImportStructPayload payload);

  ::fitx::result<::fidl::Error> OnImportWithError(::test_protocolpayloads::MainProtocolOnImportWithErrorRequest payload);

  ::fitx::result<::fidl::Error> OnAnon(::test_protocolpayloads::MainProtocolOnAnonRequest payload);

  ::fitx::result<::fidl::Error> OnAnonWithError(::test_protocolpayloads::MainProtocolOnAnonWithErrorRequest payload);
};
#endif  // __Fuchsia__

#ifdef __Fuchsia__

template <>
class ::fidl::Request<::test_protocolpayloads::MainProtocol::OneWayComposed> final : public ::test_protocolpayloads_imported::ImportStructPayload {
 public:
  using ::test_protocolpayloads_imported::ImportStructPayload::ImportStructPayload;
  Request(::test_protocolpayloads_imported::ImportStructPayload v) : ::test_protocolpayloads_imported::ImportStructPayload(std::move(v)) {}
};

template <>
struct ::fidl::internal::MessageTraits<::fidl::Request<::test_protocolpayloads::MainProtocol::OneWayComposed>> final {
 public:
  static constexpr bool kHasPayload = true;
  using Payload = ::test_protocolpayloads_imported::ImportStructPayload;
};
#endif  // __Fuchsia__

#ifdef __Fuchsia__

template <>
class ::fidl::Request<::test_protocolpayloads::MainProtocol::TwoWayComposed> final : public ::test_protocolpayloads_imported::ImportStructPayload {
 public:
  using ::test_protocolpayloads_imported::ImportStructPayload::ImportStructPayload;
  Request(::test_protocolpayloads_imported::ImportStructPayload v) : ::test_protocolpayloads_imported::ImportStructPayload(std::move(v)) {}
};

template <>
struct ::fidl::internal::MessageTraits<::fidl::Request<::test_protocolpayloads::MainProtocol::TwoWayComposed>> final {
 public:
  static constexpr bool kHasPayload = true;
  using Payload = ::test_protocolpayloads_imported::ImportStructPayload;
};
#endif  // __Fuchsia__

#ifdef __Fuchsia__

template <>
class ::fidl::Request<::test_protocolpayloads::MainProtocol::TwoWayComposedWithError> final : public ::test_protocolpayloads_imported::ImportStructPayload {
 public:
  using ::test_protocolpayloads_imported::ImportStructPayload::ImportStructPayload;
  Request(::test_protocolpayloads_imported::ImportStructPayload v) : ::test_protocolpayloads_imported::ImportStructPayload(std::move(v)) {}
};

template <>
struct ::fidl::internal::MessageTraits<::fidl::Request<::test_protocolpayloads::MainProtocol::TwoWayComposedWithError>> final {
 public:
  static constexpr bool kHasPayload = true;
  using Payload = ::test_protocolpayloads_imported::ImportStructPayload;
};
#endif  // __Fuchsia__

#ifdef __Fuchsia__

template <>
class ::fidl::Request<::test_protocolpayloads::MainProtocol::OneWayLocal> final : public ::test_protocolpayloads::LocalStructPayload {
 public:
  using ::test_protocolpayloads::LocalStructPayload::LocalStructPayload;
  Request(::test_protocolpayloads::LocalStructPayload v) : ::test_protocolpayloads::LocalStructPayload(std::move(v)) {}
};

template <>
struct ::fidl::internal::MessageTraits<::fidl::Request<::test_protocolpayloads::MainProtocol::OneWayLocal>> final {
 public:
  static constexpr bool kHasPayload = true;
  using Payload = ::test_protocolpayloads::LocalStructPayload;
};
#endif  // __Fuchsia__

#ifdef __Fuchsia__

template <>
class ::fidl::Request<::test_protocolpayloads::MainProtocol::TwoWayLocal> final : public ::test_protocolpayloads::LocalStructPayload {
 public:
  using ::test_protocolpayloads::LocalStructPayload::LocalStructPayload;
  Request(::test_protocolpayloads::LocalStructPayload v) : ::test_protocolpayloads::LocalStructPayload(std::move(v)) {}
};

template <>
struct ::fidl::internal::MessageTraits<::fidl::Request<::test_protocolpayloads::MainProtocol::TwoWayLocal>> final {
 public:
  static constexpr bool kHasPayload = true;
  using Payload = ::test_protocolpayloads::LocalStructPayload;
};
#endif  // __Fuchsia__

#ifdef __Fuchsia__

template <>
class ::fidl::Request<::test_protocolpayloads::MainProtocol::TwoWayLocalWithError> final : public ::test_protocolpayloads::LocalStructPayload {
 public:
  using ::test_protocolpayloads::LocalStructPayload::LocalStructPayload;
  Request(::test_protocolpayloads::LocalStructPayload v) : ::test_protocolpayloads::LocalStructPayload(std::move(v)) {}
};

template <>
struct ::fidl::internal::MessageTraits<::fidl::Request<::test_protocolpayloads::MainProtocol::TwoWayLocalWithError>> final {
 public:
  static constexpr bool kHasPayload = true;
  using Payload = ::test_protocolpayloads::LocalStructPayload;
};
#endif  // __Fuchsia__

#ifdef __Fuchsia__

template <>
class ::fidl::Request<::test_protocolpayloads::MainProtocol::OneWayImport> final : public ::test_protocolpayloads_imported::ImportStructPayload {
 public:
  using ::test_protocolpayloads_imported::ImportStructPayload::ImportStructPayload;
  Request(::test_protocolpayloads_imported::ImportStructPayload v) : ::test_protocolpayloads_imported::ImportStructPayload(std::move(v)) {}
};

template <>
struct ::fidl::internal::MessageTraits<::fidl::Request<::test_protocolpayloads::MainProtocol::OneWayImport>> final {
 public:
  static constexpr bool kHasPayload = true;
  using Payload = ::test_protocolpayloads_imported::ImportStructPayload;
};
#endif  // __Fuchsia__

#ifdef __Fuchsia__

template <>
class ::fidl::Request<::test_protocolpayloads::MainProtocol::TwoWayImport> final : public ::test_protocolpayloads_imported::ImportStructPayload {
 public:
  using ::test_protocolpayloads_imported::ImportStructPayload::ImportStructPayload;
  Request(::test_protocolpayloads_imported::ImportStructPayload v) : ::test_protocolpayloads_imported::ImportStructPayload(std::move(v)) {}
};

template <>
struct ::fidl::internal::MessageTraits<::fidl::Request<::test_protocolpayloads::MainProtocol::TwoWayImport>> final {
 public:
  static constexpr bool kHasPayload = true;
  using Payload = ::test_protocolpayloads_imported::ImportStructPayload;
};
#endif  // __Fuchsia__

#ifdef __Fuchsia__

template <>
class ::fidl::Request<::test_protocolpayloads::MainProtocol::TwoWayImportWithError> final : public ::test_protocolpayloads_imported::ImportStructPayload {
 public:
  using ::test_protocolpayloads_imported::ImportStructPayload::ImportStructPayload;
  Request(::test_protocolpayloads_imported::ImportStructPayload v) : ::test_protocolpayloads_imported::ImportStructPayload(std::move(v)) {}
};

template <>
struct ::fidl::internal::MessageTraits<::fidl::Request<::test_protocolpayloads::MainProtocol::TwoWayImportWithError>> final {
 public:
  static constexpr bool kHasPayload = true;
  using Payload = ::test_protocolpayloads_imported::ImportStructPayload;
};
#endif  // __Fuchsia__

#ifdef __Fuchsia__

template <>
class ::fidl::Request<::test_protocolpayloads::MainProtocol::OneWayAnon> final : public ::test_protocolpayloads::MainProtocolOneWayAnonRequest {
 public:
  using ::test_protocolpayloads::MainProtocolOneWayAnonRequest::MainProtocolOneWayAnonRequest;
  Request(::test_protocolpayloads::MainProtocolOneWayAnonRequest v) : ::test_protocolpayloads::MainProtocolOneWayAnonRequest(std::move(v)) {}
};

template <>
struct ::fidl::internal::MessageTraits<::fidl::Request<::test_protocolpayloads::MainProtocol::OneWayAnon>> final {
 public:
  static constexpr bool kHasPayload = true;
  using Payload = ::test_protocolpayloads::MainProtocolOneWayAnonRequest;
};
#endif  // __Fuchsia__

#ifdef __Fuchsia__

template <>
class ::fidl::Request<::test_protocolpayloads::MainProtocol::TwoWayAnon> final : public ::test_protocolpayloads::MainProtocolTwoWayAnonRequest {
 public:
  using ::test_protocolpayloads::MainProtocolTwoWayAnonRequest::MainProtocolTwoWayAnonRequest;
  Request(::test_protocolpayloads::MainProtocolTwoWayAnonRequest v) : ::test_protocolpayloads::MainProtocolTwoWayAnonRequest(std::move(v)) {}
};

template <>
struct ::fidl::internal::MessageTraits<::fidl::Request<::test_protocolpayloads::MainProtocol::TwoWayAnon>> final {
 public:
  static constexpr bool kHasPayload = true;
  using Payload = ::test_protocolpayloads::MainProtocolTwoWayAnonRequest;
};
#endif  // __Fuchsia__

#ifdef __Fuchsia__

template <>
class ::fidl::Request<::test_protocolpayloads::MainProtocol::TwoWayAnonWithError> final : public ::test_protocolpayloads::MainProtocolTwoWayAnonWithErrorRequest {
 public:
  using ::test_protocolpayloads::MainProtocolTwoWayAnonWithErrorRequest::MainProtocolTwoWayAnonWithErrorRequest;
  Request(::test_protocolpayloads::MainProtocolTwoWayAnonWithErrorRequest v) : ::test_protocolpayloads::MainProtocolTwoWayAnonWithErrorRequest(std::move(v)) {}
};

template <>
struct ::fidl::internal::MessageTraits<::fidl::Request<::test_protocolpayloads::MainProtocol::TwoWayAnonWithError>> final {
 public:
  static constexpr bool kHasPayload = true;
  using Payload = ::test_protocolpayloads::MainProtocolTwoWayAnonWithErrorRequest;
};
#endif  // __Fuchsia__

template <>
class ::fidl::internal::NaturalCompleterBase<::test_protocolpayloads::MainProtocol::TwoWayComposed> : public ::fidl::CompleterBase {
 public:
  void Reply(::fidl::Response<::test_protocolpayloads::MainProtocol::TwoWayComposed>&& response);

 protected:
  using ::fidl::CompleterBase::CompleterBase;
};

template <>
class ::fidl::internal::NaturalCompleterBase<::test_protocolpayloads::MainProtocol::TwoWayComposedWithError> : public ::fidl::CompleterBase {
 public:
  void Reply(::fidl::Response<::test_protocolpayloads::MainProtocol::TwoWayComposedWithError>&& response);

 protected:
  using ::fidl::CompleterBase::CompleterBase;
};

template <>
class ::fidl::internal::NaturalCompleterBase<::test_protocolpayloads::MainProtocol::TwoWayLocal> : public ::fidl::CompleterBase {
 public:
  void Reply(::fidl::Response<::test_protocolpayloads::MainProtocol::TwoWayLocal>&& response);

 protected:
  using ::fidl::CompleterBase::CompleterBase;
};

template <>
class ::fidl::internal::NaturalCompleterBase<::test_protocolpayloads::MainProtocol::TwoWayLocalWithError> : public ::fidl::CompleterBase {
 public:
  void Reply(::fidl::Response<::test_protocolpayloads::MainProtocol::TwoWayLocalWithError>&& response);

 protected:
  using ::fidl::CompleterBase::CompleterBase;
};

template <>
class ::fidl::internal::NaturalCompleterBase<::test_protocolpayloads::MainProtocol::TwoWayImport> : public ::fidl::CompleterBase {
 public:
  void Reply(::fidl::Response<::test_protocolpayloads::MainProtocol::TwoWayImport>&& response);

 protected:
  using ::fidl::CompleterBase::CompleterBase;
};

template <>
class ::fidl::internal::NaturalCompleterBase<::test_protocolpayloads::MainProtocol::TwoWayImportWithError> : public ::fidl::CompleterBase {
 public:
  void Reply(::fidl::Response<::test_protocolpayloads::MainProtocol::TwoWayImportWithError>&& response);

 protected:
  using ::fidl::CompleterBase::CompleterBase;
};

template <>
class ::fidl::internal::NaturalCompleterBase<::test_protocolpayloads::MainProtocol::TwoWayAnon> : public ::fidl::CompleterBase {
 public:
  void Reply(::fidl::Response<::test_protocolpayloads::MainProtocol::TwoWayAnon>&& response);

 protected:
  using ::fidl::CompleterBase::CompleterBase;
};

template <>
class ::fidl::internal::NaturalCompleterBase<::test_protocolpayloads::MainProtocol::TwoWayAnonWithError> : public ::fidl::CompleterBase {
 public:
  void Reply(::fidl::Response<::test_protocolpayloads::MainProtocol::TwoWayAnonWithError>&& response);

 protected:
  using ::fidl::CompleterBase::CompleterBase;
};

template <>
class ::fidl::Server<::test_protocolpayloads::MainProtocol> : public ::fidl::internal::IncomingMessageDispatcher {
 public:
  Server() = default;
  virtual ~Server() = default;

  // The FIDL protocol type that is implemented by this server.
  using _EnclosingProtocol = ::test_protocolpayloads::MainProtocol;

  using OneWayComposedRequest = ::fidl::Request<::test_protocolpayloads::MainProtocol::OneWayComposed>;
  using OneWayComposedCompleter = ::fidl::internal::NaturalCompleter<::test_protocolpayloads::MainProtocol::OneWayComposed>;

  virtual void OneWayComposed(OneWayComposedRequest& request, OneWayComposedCompleter::Sync& completer) = 0;

  using TwoWayComposedRequest = ::fidl::Request<::test_protocolpayloads::MainProtocol::TwoWayComposed>;
  using TwoWayComposedCompleter = ::fidl::internal::NaturalCompleter<::test_protocolpayloads::MainProtocol::TwoWayComposed>;

  virtual void TwoWayComposed(TwoWayComposedRequest& request, TwoWayComposedCompleter::Sync& completer) = 0;

  using TwoWayComposedWithErrorRequest = ::fidl::Request<::test_protocolpayloads::MainProtocol::TwoWayComposedWithError>;
  using TwoWayComposedWithErrorCompleter = ::fidl::internal::NaturalCompleter<::test_protocolpayloads::MainProtocol::TwoWayComposedWithError>;

  virtual void TwoWayComposedWithError(TwoWayComposedWithErrorRequest& request, TwoWayComposedWithErrorCompleter::Sync& completer) = 0;

  using OneWayLocalRequest = ::fidl::Request<::test_protocolpayloads::MainProtocol::OneWayLocal>;
  using OneWayLocalCompleter = ::fidl::internal::NaturalCompleter<::test_protocolpayloads::MainProtocol::OneWayLocal>;

  virtual void OneWayLocal(OneWayLocalRequest& request, OneWayLocalCompleter::Sync& completer) = 0;

  using TwoWayLocalRequest = ::fidl::Request<::test_protocolpayloads::MainProtocol::TwoWayLocal>;
  using TwoWayLocalCompleter = ::fidl::internal::NaturalCompleter<::test_protocolpayloads::MainProtocol::TwoWayLocal>;

  virtual void TwoWayLocal(TwoWayLocalRequest& request, TwoWayLocalCompleter::Sync& completer) = 0;

  using TwoWayLocalWithErrorRequest = ::fidl::Request<::test_protocolpayloads::MainProtocol::TwoWayLocalWithError>;
  using TwoWayLocalWithErrorCompleter = ::fidl::internal::NaturalCompleter<::test_protocolpayloads::MainProtocol::TwoWayLocalWithError>;

  virtual void TwoWayLocalWithError(TwoWayLocalWithErrorRequest& request, TwoWayLocalWithErrorCompleter::Sync& completer) = 0;

  using OneWayImportRequest = ::fidl::Request<::test_protocolpayloads::MainProtocol::OneWayImport>;
  using OneWayImportCompleter = ::fidl::internal::NaturalCompleter<::test_protocolpayloads::MainProtocol::OneWayImport>;

  virtual void OneWayImport(OneWayImportRequest& request, OneWayImportCompleter::Sync& completer) = 0;

  using TwoWayImportRequest = ::fidl::Request<::test_protocolpayloads::MainProtocol::TwoWayImport>;
  using TwoWayImportCompleter = ::fidl::internal::NaturalCompleter<::test_protocolpayloads::MainProtocol::TwoWayImport>;

  virtual void TwoWayImport(TwoWayImportRequest& request, TwoWayImportCompleter::Sync& completer) = 0;

  using TwoWayImportWithErrorRequest = ::fidl::Request<::test_protocolpayloads::MainProtocol::TwoWayImportWithError>;
  using TwoWayImportWithErrorCompleter = ::fidl::internal::NaturalCompleter<::test_protocolpayloads::MainProtocol::TwoWayImportWithError>;

  virtual void TwoWayImportWithError(TwoWayImportWithErrorRequest& request, TwoWayImportWithErrorCompleter::Sync& completer) = 0;

  using OneWayAnonRequest = ::fidl::Request<::test_protocolpayloads::MainProtocol::OneWayAnon>;
  using OneWayAnonCompleter = ::fidl::internal::NaturalCompleter<::test_protocolpayloads::MainProtocol::OneWayAnon>;

  virtual void OneWayAnon(OneWayAnonRequest& request, OneWayAnonCompleter::Sync& completer) = 0;

  using TwoWayAnonRequest = ::fidl::Request<::test_protocolpayloads::MainProtocol::TwoWayAnon>;
  using TwoWayAnonCompleter = ::fidl::internal::NaturalCompleter<::test_protocolpayloads::MainProtocol::TwoWayAnon>;

  virtual void TwoWayAnon(TwoWayAnonRequest& request, TwoWayAnonCompleter::Sync& completer) = 0;

  using TwoWayAnonWithErrorRequest = ::fidl::Request<::test_protocolpayloads::MainProtocol::TwoWayAnonWithError>;
  using TwoWayAnonWithErrorCompleter = ::fidl::internal::NaturalCompleter<::test_protocolpayloads::MainProtocol::TwoWayAnonWithError>;

  virtual void TwoWayAnonWithError(TwoWayAnonWithErrorRequest& request, TwoWayAnonWithErrorCompleter::Sync& completer) = 0;

 private:
  void dispatch_message(
      ::fidl::IncomingMessage&& msg, ::fidl::Transaction* txn,
      ::fidl::internal::MessageStorageViewBase* storage_view) final;
};

#ifdef __Fuchsia__

template <>
struct ::fidl::internal::NaturalServerDispatcher<::test_protocolpayloads::MainProtocol> final {
  NaturalServerDispatcher() = delete;
  static void Dispatch(::fidl::Server<::test_protocolpayloads::MainProtocol>* impl, ::fidl::IncomingMessage&& msg,
                       internal::MessageStorageViewBase* storage_view,
                       ::fidl::Transaction* txn);

 private:
  static const ::fidl::internal::MethodEntry entries_[];
  static const ::fidl::internal::MethodEntry* entries_end_;
};
#endif  // __Fuchsia__