tools/fidl/fidlgen_cpp/goldens/types_in_protocols_natural_messaging.cc.golden

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

// fidl_experiment = output_index_json

#include <fidl/test.typesinprotocols/cpp/natural_messaging.h>
#include <lib/fidl/cpp/wire/unknown_interactions.h>

#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wshadow"

namespace test_typesinprotocols {

[[maybe_unused]]
constexpr inline uint64_t kProtocol_OneWayBasic_Ordinal = 8948968077914418681lu;

[[maybe_unused]]
constexpr inline ::fidl::MessageDynamicFlags kProtocol_OneWayBasic_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

[[maybe_unused]]
constexpr inline uint64_t kProtocol_TwoWayBasic_Ordinal = 2331618702752598159lu;

[[maybe_unused]]
constexpr inline ::fidl::MessageDynamicFlags kProtocol_TwoWayBasic_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

[[maybe_unused]]
constexpr inline uint64_t kProtocol_ErrorBasic_Ordinal = 5016634351643393939lu;

[[maybe_unused]]
constexpr inline ::fidl::MessageDynamicFlags kProtocol_ErrorBasic_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

[[maybe_unused]]
constexpr inline uint64_t kProtocol_EventBasic_Ordinal = 5892309624949902400lu;

[[maybe_unused]]
constexpr inline ::fidl::MessageDynamicFlags kProtocol_EventBasic_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

[[maybe_unused]]
constexpr inline uint64_t kProtocol_OneWayCompound_Ordinal = 3153289648860022476lu;

[[maybe_unused]]
constexpr inline ::fidl::MessageDynamicFlags kProtocol_OneWayCompound_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

[[maybe_unused]]
constexpr inline uint64_t kProtocol_TwoWayCompound_Ordinal = 8787219719097524529lu;

[[maybe_unused]]
constexpr inline ::fidl::MessageDynamicFlags kProtocol_TwoWayCompound_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

[[maybe_unused]]
constexpr inline uint64_t kProtocol_ErrorCompound_Ordinal = 2990809657626249085lu;

[[maybe_unused]]
constexpr inline ::fidl::MessageDynamicFlags kProtocol_ErrorCompound_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

[[maybe_unused]]
constexpr inline uint64_t kProtocol_EventCompound_Ordinal = 7024581948727571669lu;

[[maybe_unused]]
constexpr inline ::fidl::MessageDynamicFlags kProtocol_EventCompound_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

[[maybe_unused]]
constexpr inline uint64_t kProtocol_OneWayArrayBasic_Ordinal = 7125516817014311449lu;

[[maybe_unused]]
constexpr inline ::fidl::MessageDynamicFlags kProtocol_OneWayArrayBasic_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

[[maybe_unused]]
constexpr inline uint64_t kProtocol_TwoWayArrayBasic_Ordinal = 5309034178175279380lu;

[[maybe_unused]]
constexpr inline ::fidl::MessageDynamicFlags kProtocol_TwoWayArrayBasic_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

[[maybe_unused]]
constexpr inline uint64_t kProtocol_ErrorArrayBasic_Ordinal = 1084731895342694265lu;

[[maybe_unused]]
constexpr inline ::fidl::MessageDynamicFlags kProtocol_ErrorArrayBasic_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

[[maybe_unused]]
constexpr inline uint64_t kProtocol_EventArrayBasic_Ordinal = 5888282827283820590lu;

[[maybe_unused]]
constexpr inline ::fidl::MessageDynamicFlags kProtocol_EventArrayBasic_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

[[maybe_unused]]
constexpr inline uint64_t kProtocol_OneWayArrayCompound_Ordinal = 5064659223443251357lu;

[[maybe_unused]]
constexpr inline ::fidl::MessageDynamicFlags kProtocol_OneWayArrayCompound_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

[[maybe_unused]]
constexpr inline uint64_t kProtocol_TwoWayArrayCompound_Ordinal = 849744466051983995lu;

[[maybe_unused]]
constexpr inline ::fidl::MessageDynamicFlags kProtocol_TwoWayArrayCompound_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

[[maybe_unused]]
constexpr inline uint64_t kProtocol_ErrorArrayCompound_Ordinal = 5919277476782807556lu;

[[maybe_unused]]
constexpr inline ::fidl::MessageDynamicFlags kProtocol_ErrorArrayCompound_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

[[maybe_unused]]
constexpr inline uint64_t kProtocol_EventArrayCompound_Ordinal = 2189769767733851157lu;

[[maybe_unused]]
constexpr inline ::fidl::MessageDynamicFlags kProtocol_EventArrayCompound_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

[[maybe_unused]]
constexpr inline uint64_t kProtocol_OneWayVectorBasic_Ordinal = 5733220720079947351lu;

[[maybe_unused]]
constexpr inline ::fidl::MessageDynamicFlags kProtocol_OneWayVectorBasic_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

[[maybe_unused]]
constexpr inline uint64_t kProtocol_TwoWayVectorBasic_Ordinal = 8674156353091415668lu;

[[maybe_unused]]
constexpr inline ::fidl::MessageDynamicFlags kProtocol_TwoWayVectorBasic_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

[[maybe_unused]]
constexpr inline uint64_t kProtocol_ErrorVectorBasic_Ordinal = 875941614196965234lu;

[[maybe_unused]]
constexpr inline ::fidl::MessageDynamicFlags kProtocol_ErrorVectorBasic_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

[[maybe_unused]]
constexpr inline uint64_t kProtocol_EventVectorBasic_Ordinal = 4583890770109526006lu;

[[maybe_unused]]
constexpr inline ::fidl::MessageDynamicFlags kProtocol_EventVectorBasic_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

[[maybe_unused]]
constexpr inline uint64_t kProtocol_OneWayVectorCompound_Ordinal = 1853985797298830992lu;

[[maybe_unused]]
constexpr inline ::fidl::MessageDynamicFlags kProtocol_OneWayVectorCompound_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

[[maybe_unused]]
constexpr inline uint64_t kProtocol_TwoWayVectorCompound_Ordinal = 3968024057912959924lu;

[[maybe_unused]]
constexpr inline ::fidl::MessageDynamicFlags kProtocol_TwoWayVectorCompound_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

[[maybe_unused]]
constexpr inline uint64_t kProtocol_ErrorVectorCompound_Ordinal = 8506780203315865989lu;

[[maybe_unused]]
constexpr inline ::fidl::MessageDynamicFlags kProtocol_ErrorVectorCompound_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

[[maybe_unused]]
constexpr inline uint64_t kProtocol_EventVectorCompound_Ordinal = 6026375226599919603lu;

[[maybe_unused]]
constexpr inline ::fidl::MessageDynamicFlags kProtocol_EventVectorCompound_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

[[maybe_unused]]
constexpr inline uint64_t kProtocol_OneWayVectorOptional_Ordinal = 1530215841195476271lu;

[[maybe_unused]]
constexpr inline ::fidl::MessageDynamicFlags kProtocol_OneWayVectorOptional_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

[[maybe_unused]]
constexpr inline uint64_t kProtocol_TwoWayVectorOptional_Ordinal = 1030024737742222323lu;

[[maybe_unused]]
constexpr inline ::fidl::MessageDynamicFlags kProtocol_TwoWayVectorOptional_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

[[maybe_unused]]
constexpr inline uint64_t kProtocol_ErrorVectorOptional_Ordinal = 6406191217027936606lu;

[[maybe_unused]]
constexpr inline ::fidl::MessageDynamicFlags kProtocol_ErrorVectorOptional_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

[[maybe_unused]]
constexpr inline uint64_t kProtocol_EventVectorOptional_Ordinal = 1684763340073130077lu;

[[maybe_unused]]
constexpr inline ::fidl::MessageDynamicFlags kProtocol_EventVectorOptional_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

[[maybe_unused]]
constexpr inline uint64_t kProtocol_OneWayArrayVectorNested_Ordinal = 5912603762133524183lu;

[[maybe_unused]]
constexpr inline ::fidl::MessageDynamicFlags kProtocol_OneWayArrayVectorNested_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

[[maybe_unused]]
constexpr inline uint64_t kProtocol_TwoWayArrayVectorNested_Ordinal = 5351275678438791132lu;

[[maybe_unused]]
constexpr inline ::fidl::MessageDynamicFlags kProtocol_TwoWayArrayVectorNested_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

[[maybe_unused]]
constexpr inline uint64_t kProtocol_ErrorArrayVectorNested_Ordinal = 9085604921605802151lu;

[[maybe_unused]]
constexpr inline ::fidl::MessageDynamicFlags kProtocol_ErrorArrayVectorNested_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

[[maybe_unused]]
constexpr inline uint64_t kProtocol_EventArrayVectorNested_Ordinal = 1228201560727880574lu;

[[maybe_unused]]
constexpr inline ::fidl::MessageDynamicFlags kProtocol_EventArrayVectorNested_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

[[maybe_unused]]
constexpr inline uint64_t kProtocol_OneWayResource_Ordinal = 6553996787849601058lu;

[[maybe_unused]]
constexpr inline ::fidl::MessageDynamicFlags kProtocol_OneWayResource_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

[[maybe_unused]]
constexpr inline uint64_t kProtocol_TwoWayResource_Ordinal = 1802709005492464987lu;

[[maybe_unused]]
constexpr inline ::fidl::MessageDynamicFlags kProtocol_TwoWayResource_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

[[maybe_unused]]
constexpr inline uint64_t kProtocol_ErrorResource_Ordinal = 6568609240497354166lu;

[[maybe_unused]]
constexpr inline ::fidl::MessageDynamicFlags kProtocol_ErrorResource_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

[[maybe_unused]]
constexpr inline uint64_t kProtocol_EventResource_Ordinal = 5745997765922613643lu;

[[maybe_unused]]
constexpr inline ::fidl::MessageDynamicFlags kProtocol_EventResource_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;

#ifdef __Fuchsia__
}  // namespace test_typesinprotocols

::fidl::internal::NaturalThenable<::test_typesinprotocols::Protocol::TwoWayBasic>
fidl::internal::NaturalClientImpl<::test_typesinprotocols::Protocol>::TwoWayBasic(const ::fidl::Request<::test_typesinprotocols::Protocol::TwoWayBasic>& request) const {
  return ::fidl::internal::NaturalThenable<::test_typesinprotocols::Protocol::TwoWayBasic>(
      &client_base(), {}, &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_TwoWayBasic_Ordinal, ::test_typesinprotocols::kProtocol_TwoWayBasic_DynamicFlags,
      [request = request](NaturalMessageEncoder& encoder) mutable {
        encoder.EncodeBody(request);
        return ZX_OK;
      },
      [](
          ::fidl::internal::ThenableBase* base,
          ::fidl::internal::NaturalMessageEncoder& encoder,
          ::fidl::internal::ResponseContext* response_context) {
        ::fidl::OutgoingMessage msg = encoder.GetMessage();
        return base->SendTwoWay(msg, response_context);
      });
}

::fidl::internal::NaturalThenable<::test_typesinprotocols::Protocol::ErrorBasic>
fidl::internal::NaturalClientImpl<::test_typesinprotocols::Protocol>::ErrorBasic() const {
  return ::fidl::internal::NaturalThenable<::test_typesinprotocols::Protocol::ErrorBasic>(
      &client_base(), {}, &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_ErrorBasic_Ordinal, ::test_typesinprotocols::kProtocol_ErrorBasic_DynamicFlags,
      [](NaturalMessageEncoder& encoder) mutable {
        return ZX_OK;
      },
      [](
          ::fidl::internal::ThenableBase* base,
          ::fidl::internal::NaturalMessageEncoder& encoder,
          ::fidl::internal::ResponseContext* response_context) {
        ::fidl::OutgoingMessage msg = encoder.GetMessage();
        return base->SendTwoWay(msg, response_context);
      });
}

::fidl::internal::NaturalThenable<::test_typesinprotocols::Protocol::TwoWayCompound>
fidl::internal::NaturalClientImpl<::test_typesinprotocols::Protocol>::TwoWayCompound(const ::fidl::Request<::test_typesinprotocols::Protocol::TwoWayCompound>& request) const {
  return ::fidl::internal::NaturalThenable<::test_typesinprotocols::Protocol::TwoWayCompound>(
      &client_base(), {}, &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_TwoWayCompound_Ordinal, ::test_typesinprotocols::kProtocol_TwoWayCompound_DynamicFlags,
      [request = request](NaturalMessageEncoder& encoder) mutable {
        encoder.EncodeBody(request);
        return ZX_OK;
      },
      [](
          ::fidl::internal::ThenableBase* base,
          ::fidl::internal::NaturalMessageEncoder& encoder,
          ::fidl::internal::ResponseContext* response_context) {
        ::fidl::OutgoingMessage msg = encoder.GetMessage();
        return base->SendTwoWay(msg, response_context);
      });
}

::fidl::internal::NaturalThenable<::test_typesinprotocols::Protocol::ErrorCompound>
fidl::internal::NaturalClientImpl<::test_typesinprotocols::Protocol>::ErrorCompound() const {
  return ::fidl::internal::NaturalThenable<::test_typesinprotocols::Protocol::ErrorCompound>(
      &client_base(), {}, &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_ErrorCompound_Ordinal, ::test_typesinprotocols::kProtocol_ErrorCompound_DynamicFlags,
      [](NaturalMessageEncoder& encoder) mutable {
        return ZX_OK;
      },
      [](
          ::fidl::internal::ThenableBase* base,
          ::fidl::internal::NaturalMessageEncoder& encoder,
          ::fidl::internal::ResponseContext* response_context) {
        ::fidl::OutgoingMessage msg = encoder.GetMessage();
        return base->SendTwoWay(msg, response_context);
      });
}

::fidl::internal::NaturalThenable<::test_typesinprotocols::Protocol::TwoWayArrayBasic>
fidl::internal::NaturalClientImpl<::test_typesinprotocols::Protocol>::TwoWayArrayBasic(const ::fidl::Request<::test_typesinprotocols::Protocol::TwoWayArrayBasic>& request) const {
  return ::fidl::internal::NaturalThenable<::test_typesinprotocols::Protocol::TwoWayArrayBasic>(
      &client_base(), {}, &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_TwoWayArrayBasic_Ordinal, ::test_typesinprotocols::kProtocol_TwoWayArrayBasic_DynamicFlags,
      [request = request](NaturalMessageEncoder& encoder) mutable {
        encoder.EncodeBody(request);
        return ZX_OK;
      },
      [](
          ::fidl::internal::ThenableBase* base,
          ::fidl::internal::NaturalMessageEncoder& encoder,
          ::fidl::internal::ResponseContext* response_context) {
        ::fidl::OutgoingMessage msg = encoder.GetMessage();
        return base->SendTwoWay(msg, response_context);
      });
}

::fidl::internal::NaturalThenable<::test_typesinprotocols::Protocol::ErrorArrayBasic>
fidl::internal::NaturalClientImpl<::test_typesinprotocols::Protocol>::ErrorArrayBasic() const {
  return ::fidl::internal::NaturalThenable<::test_typesinprotocols::Protocol::ErrorArrayBasic>(
      &client_base(), {}, &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_ErrorArrayBasic_Ordinal, ::test_typesinprotocols::kProtocol_ErrorArrayBasic_DynamicFlags,
      [](NaturalMessageEncoder& encoder) mutable {
        return ZX_OK;
      },
      [](
          ::fidl::internal::ThenableBase* base,
          ::fidl::internal::NaturalMessageEncoder& encoder,
          ::fidl::internal::ResponseContext* response_context) {
        ::fidl::OutgoingMessage msg = encoder.GetMessage();
        return base->SendTwoWay(msg, response_context);
      });
}

::fidl::internal::NaturalThenable<::test_typesinprotocols::Protocol::TwoWayArrayCompound>
fidl::internal::NaturalClientImpl<::test_typesinprotocols::Protocol>::TwoWayArrayCompound(const ::fidl::Request<::test_typesinprotocols::Protocol::TwoWayArrayCompound>& request) const {
  return ::fidl::internal::NaturalThenable<::test_typesinprotocols::Protocol::TwoWayArrayCompound>(
      &client_base(), {}, &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_TwoWayArrayCompound_Ordinal, ::test_typesinprotocols::kProtocol_TwoWayArrayCompound_DynamicFlags,
      [request = request](NaturalMessageEncoder& encoder) mutable {
        encoder.EncodeBody(request);
        return ZX_OK;
      },
      [](
          ::fidl::internal::ThenableBase* base,
          ::fidl::internal::NaturalMessageEncoder& encoder,
          ::fidl::internal::ResponseContext* response_context) {
        ::fidl::OutgoingMessage msg = encoder.GetMessage();
        return base->SendTwoWay(msg, response_context);
      });
}

::fidl::internal::NaturalThenable<::test_typesinprotocols::Protocol::ErrorArrayCompound>
fidl::internal::NaturalClientImpl<::test_typesinprotocols::Protocol>::ErrorArrayCompound() const {
  return ::fidl::internal::NaturalThenable<::test_typesinprotocols::Protocol::ErrorArrayCompound>(
      &client_base(), {}, &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_ErrorArrayCompound_Ordinal, ::test_typesinprotocols::kProtocol_ErrorArrayCompound_DynamicFlags,
      [](NaturalMessageEncoder& encoder) mutable {
        return ZX_OK;
      },
      [](
          ::fidl::internal::ThenableBase* base,
          ::fidl::internal::NaturalMessageEncoder& encoder,
          ::fidl::internal::ResponseContext* response_context) {
        ::fidl::OutgoingMessage msg = encoder.GetMessage();
        return base->SendTwoWay(msg, response_context);
      });
}

::fidl::internal::NaturalThenable<::test_typesinprotocols::Protocol::TwoWayVectorBasic>
fidl::internal::NaturalClientImpl<::test_typesinprotocols::Protocol>::TwoWayVectorBasic(const ::fidl::Request<::test_typesinprotocols::Protocol::TwoWayVectorBasic>& request) const {
  return ::fidl::internal::NaturalThenable<::test_typesinprotocols::Protocol::TwoWayVectorBasic>(
      &client_base(), {}, &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_TwoWayVectorBasic_Ordinal, ::test_typesinprotocols::kProtocol_TwoWayVectorBasic_DynamicFlags,
      [request = request](NaturalMessageEncoder& encoder) mutable {
        encoder.EncodeBody(request);
        return ZX_OK;
      },
      [](
          ::fidl::internal::ThenableBase* base,
          ::fidl::internal::NaturalMessageEncoder& encoder,
          ::fidl::internal::ResponseContext* response_context) {
        ::fidl::OutgoingMessage msg = encoder.GetMessage();
        return base->SendTwoWay(msg, response_context);
      });
}

::fidl::internal::NaturalThenable<::test_typesinprotocols::Protocol::ErrorVectorBasic>
fidl::internal::NaturalClientImpl<::test_typesinprotocols::Protocol>::ErrorVectorBasic() const {
  return ::fidl::internal::NaturalThenable<::test_typesinprotocols::Protocol::ErrorVectorBasic>(
      &client_base(), {}, &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_ErrorVectorBasic_Ordinal, ::test_typesinprotocols::kProtocol_ErrorVectorBasic_DynamicFlags,
      [](NaturalMessageEncoder& encoder) mutable {
        return ZX_OK;
      },
      [](
          ::fidl::internal::ThenableBase* base,
          ::fidl::internal::NaturalMessageEncoder& encoder,
          ::fidl::internal::ResponseContext* response_context) {
        ::fidl::OutgoingMessage msg = encoder.GetMessage();
        return base->SendTwoWay(msg, response_context);
      });
}

::fidl::internal::NaturalThenable<::test_typesinprotocols::Protocol::TwoWayVectorCompound>
fidl::internal::NaturalClientImpl<::test_typesinprotocols::Protocol>::TwoWayVectorCompound(const ::fidl::Request<::test_typesinprotocols::Protocol::TwoWayVectorCompound>& request) const {
  return ::fidl::internal::NaturalThenable<::test_typesinprotocols::Protocol::TwoWayVectorCompound>(
      &client_base(), {}, &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_TwoWayVectorCompound_Ordinal, ::test_typesinprotocols::kProtocol_TwoWayVectorCompound_DynamicFlags,
      [request = request](NaturalMessageEncoder& encoder) mutable {
        encoder.EncodeBody(request);
        return ZX_OK;
      },
      [](
          ::fidl::internal::ThenableBase* base,
          ::fidl::internal::NaturalMessageEncoder& encoder,
          ::fidl::internal::ResponseContext* response_context) {
        ::fidl::OutgoingMessage msg = encoder.GetMessage();
        return base->SendTwoWay(msg, response_context);
      });
}

::fidl::internal::NaturalThenable<::test_typesinprotocols::Protocol::ErrorVectorCompound>
fidl::internal::NaturalClientImpl<::test_typesinprotocols::Protocol>::ErrorVectorCompound() const {
  return ::fidl::internal::NaturalThenable<::test_typesinprotocols::Protocol::ErrorVectorCompound>(
      &client_base(), {}, &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_ErrorVectorCompound_Ordinal, ::test_typesinprotocols::kProtocol_ErrorVectorCompound_DynamicFlags,
      [](NaturalMessageEncoder& encoder) mutable {
        return ZX_OK;
      },
      [](
          ::fidl::internal::ThenableBase* base,
          ::fidl::internal::NaturalMessageEncoder& encoder,
          ::fidl::internal::ResponseContext* response_context) {
        ::fidl::OutgoingMessage msg = encoder.GetMessage();
        return base->SendTwoWay(msg, response_context);
      });
}

::fidl::internal::NaturalThenable<::test_typesinprotocols::Protocol::TwoWayVectorOptional>
fidl::internal::NaturalClientImpl<::test_typesinprotocols::Protocol>::TwoWayVectorOptional(const ::fidl::Request<::test_typesinprotocols::Protocol::TwoWayVectorOptional>& request) const {
  return ::fidl::internal::NaturalThenable<::test_typesinprotocols::Protocol::TwoWayVectorOptional>(
      &client_base(), {}, &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_TwoWayVectorOptional_Ordinal, ::test_typesinprotocols::kProtocol_TwoWayVectorOptional_DynamicFlags,
      [request = request](NaturalMessageEncoder& encoder) mutable {
        encoder.EncodeBody(request);
        return ZX_OK;
      },
      [](
          ::fidl::internal::ThenableBase* base,
          ::fidl::internal::NaturalMessageEncoder& encoder,
          ::fidl::internal::ResponseContext* response_context) {
        ::fidl::OutgoingMessage msg = encoder.GetMessage();
        return base->SendTwoWay(msg, response_context);
      });
}

::fidl::internal::NaturalThenable<::test_typesinprotocols::Protocol::ErrorVectorOptional>
fidl::internal::NaturalClientImpl<::test_typesinprotocols::Protocol>::ErrorVectorOptional() const {
  return ::fidl::internal::NaturalThenable<::test_typesinprotocols::Protocol::ErrorVectorOptional>(
      &client_base(), {}, &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_ErrorVectorOptional_Ordinal, ::test_typesinprotocols::kProtocol_ErrorVectorOptional_DynamicFlags,
      [](NaturalMessageEncoder& encoder) mutable {
        return ZX_OK;
      },
      [](
          ::fidl::internal::ThenableBase* base,
          ::fidl::internal::NaturalMessageEncoder& encoder,
          ::fidl::internal::ResponseContext* response_context) {
        ::fidl::OutgoingMessage msg = encoder.GetMessage();
        return base->SendTwoWay(msg, response_context);
      });
}

::fidl::internal::NaturalThenable<::test_typesinprotocols::Protocol::TwoWayArrayVectorNested>
fidl::internal::NaturalClientImpl<::test_typesinprotocols::Protocol>::TwoWayArrayVectorNested(const ::fidl::Request<::test_typesinprotocols::Protocol::TwoWayArrayVectorNested>& request) const {
  return ::fidl::internal::NaturalThenable<::test_typesinprotocols::Protocol::TwoWayArrayVectorNested>(
      &client_base(), {}, &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_TwoWayArrayVectorNested_Ordinal, ::test_typesinprotocols::kProtocol_TwoWayArrayVectorNested_DynamicFlags,
      [request = request](NaturalMessageEncoder& encoder) mutable {
        encoder.EncodeBody(request);
        return ZX_OK;
      },
      [](
          ::fidl::internal::ThenableBase* base,
          ::fidl::internal::NaturalMessageEncoder& encoder,
          ::fidl::internal::ResponseContext* response_context) {
        ::fidl::OutgoingMessage msg = encoder.GetMessage();
        return base->SendTwoWay(msg, response_context);
      });
}

::fidl::internal::NaturalThenable<::test_typesinprotocols::Protocol::ErrorArrayVectorNested>
fidl::internal::NaturalClientImpl<::test_typesinprotocols::Protocol>::ErrorArrayVectorNested() const {
  return ::fidl::internal::NaturalThenable<::test_typesinprotocols::Protocol::ErrorArrayVectorNested>(
      &client_base(), {}, &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_ErrorArrayVectorNested_Ordinal, ::test_typesinprotocols::kProtocol_ErrorArrayVectorNested_DynamicFlags,
      [](NaturalMessageEncoder& encoder) mutable {
        return ZX_OK;
      },
      [](
          ::fidl::internal::ThenableBase* base,
          ::fidl::internal::NaturalMessageEncoder& encoder,
          ::fidl::internal::ResponseContext* response_context) {
        ::fidl::OutgoingMessage msg = encoder.GetMessage();
        return base->SendTwoWay(msg, response_context);
      });
}

::fidl::internal::NaturalThenable<::test_typesinprotocols::Protocol::TwoWayResource>
fidl::internal::NaturalClientImpl<::test_typesinprotocols::Protocol>::TwoWayResource(::fidl::Request<::test_typesinprotocols::Protocol::TwoWayResource> request) const {
  return ::fidl::internal::NaturalThenable<::test_typesinprotocols::Protocol::TwoWayResource>(
      &client_base(), {}, &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_TwoWayResource_Ordinal, ::test_typesinprotocols::kProtocol_TwoWayResource_DynamicFlags,
      [request = std::move(request)](NaturalMessageEncoder& encoder) mutable {
        encoder.EncodeBody(std::move(request));
        return ZX_OK;
      },
      [](
          ::fidl::internal::ThenableBase* base,
          ::fidl::internal::NaturalMessageEncoder& encoder,
          ::fidl::internal::ResponseContext* response_context) {
        ::fidl::OutgoingMessage msg = encoder.GetMessage();
        return base->SendTwoWay(msg, response_context);
      });
}

::fidl::internal::NaturalThenable<::test_typesinprotocols::Protocol::ErrorResource>
fidl::internal::NaturalClientImpl<::test_typesinprotocols::Protocol>::ErrorResource() const {
  return ::fidl::internal::NaturalThenable<::test_typesinprotocols::Protocol::ErrorResource>(
      &client_base(), {}, &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_ErrorResource_Ordinal, ::test_typesinprotocols::kProtocol_ErrorResource_DynamicFlags,
      [](NaturalMessageEncoder& encoder) mutable {
        return ZX_OK;
      },
      [](
          ::fidl::internal::ThenableBase* base,
          ::fidl::internal::NaturalMessageEncoder& encoder,
          ::fidl::internal::ResponseContext* response_context) {
        ::fidl::OutgoingMessage msg = encoder.GetMessage();
        return base->SendTwoWay(msg, response_context);
      });
}

::fit::result<::fidl::OneWayError>
fidl::internal::NaturalClientImpl<::test_typesinprotocols::Protocol>::OneWayBasic(const ::fidl::Request<::test_typesinprotocols::Protocol::OneWayBasic>& request) const {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_OneWayBasic_Ordinal, ::test_typesinprotocols::kProtocol_OneWayBasic_DynamicFlags};
  _encoder.EncodeBody(request);

  ::fidl::OutgoingMessage _encoded_message = _encoder.GetMessage();
  ::fidl::OneWayStatus status = client_base().SendOneWay(_encoded_message);
  return ::fidl::internal::ToFitxResult(status);
}

::fit::result<::fidl::OneWayError>
fidl::internal::NaturalClientImpl<::test_typesinprotocols::Protocol>::OneWayCompound(const ::fidl::Request<::test_typesinprotocols::Protocol::OneWayCompound>& request) const {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_OneWayCompound_Ordinal, ::test_typesinprotocols::kProtocol_OneWayCompound_DynamicFlags};
  _encoder.EncodeBody(request);

  ::fidl::OutgoingMessage _encoded_message = _encoder.GetMessage();
  ::fidl::OneWayStatus status = client_base().SendOneWay(_encoded_message);
  return ::fidl::internal::ToFitxResult(status);
}

::fit::result<::fidl::OneWayError>
fidl::internal::NaturalClientImpl<::test_typesinprotocols::Protocol>::OneWayArrayBasic(const ::fidl::Request<::test_typesinprotocols::Protocol::OneWayArrayBasic>& request) const {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_OneWayArrayBasic_Ordinal, ::test_typesinprotocols::kProtocol_OneWayArrayBasic_DynamicFlags};
  _encoder.EncodeBody(request);

  ::fidl::OutgoingMessage _encoded_message = _encoder.GetMessage();
  ::fidl::OneWayStatus status = client_base().SendOneWay(_encoded_message);
  return ::fidl::internal::ToFitxResult(status);
}

::fit::result<::fidl::OneWayError>
fidl::internal::NaturalClientImpl<::test_typesinprotocols::Protocol>::OneWayArrayCompound(const ::fidl::Request<::test_typesinprotocols::Protocol::OneWayArrayCompound>& request) const {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_OneWayArrayCompound_Ordinal, ::test_typesinprotocols::kProtocol_OneWayArrayCompound_DynamicFlags};
  _encoder.EncodeBody(request);

  ::fidl::OutgoingMessage _encoded_message = _encoder.GetMessage();
  ::fidl::OneWayStatus status = client_base().SendOneWay(_encoded_message);
  return ::fidl::internal::ToFitxResult(status);
}

::fit::result<::fidl::OneWayError>
fidl::internal::NaturalClientImpl<::test_typesinprotocols::Protocol>::OneWayVectorBasic(const ::fidl::Request<::test_typesinprotocols::Protocol::OneWayVectorBasic>& request) const {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_OneWayVectorBasic_Ordinal, ::test_typesinprotocols::kProtocol_OneWayVectorBasic_DynamicFlags};
  _encoder.EncodeBody(request);

  ::fidl::OutgoingMessage _encoded_message = _encoder.GetMessage();
  ::fidl::OneWayStatus status = client_base().SendOneWay(_encoded_message);
  return ::fidl::internal::ToFitxResult(status);
}

::fit::result<::fidl::OneWayError>
fidl::internal::NaturalClientImpl<::test_typesinprotocols::Protocol>::OneWayVectorCompound(const ::fidl::Request<::test_typesinprotocols::Protocol::OneWayVectorCompound>& request) const {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_OneWayVectorCompound_Ordinal, ::test_typesinprotocols::kProtocol_OneWayVectorCompound_DynamicFlags};
  _encoder.EncodeBody(request);

  ::fidl::OutgoingMessage _encoded_message = _encoder.GetMessage();
  ::fidl::OneWayStatus status = client_base().SendOneWay(_encoded_message);
  return ::fidl::internal::ToFitxResult(status);
}

::fit::result<::fidl::OneWayError>
fidl::internal::NaturalClientImpl<::test_typesinprotocols::Protocol>::OneWayVectorOptional(const ::fidl::Request<::test_typesinprotocols::Protocol::OneWayVectorOptional>& request) const {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_OneWayVectorOptional_Ordinal, ::test_typesinprotocols::kProtocol_OneWayVectorOptional_DynamicFlags};
  _encoder.EncodeBody(request);

  ::fidl::OutgoingMessage _encoded_message = _encoder.GetMessage();
  ::fidl::OneWayStatus status = client_base().SendOneWay(_encoded_message);
  return ::fidl::internal::ToFitxResult(status);
}

::fit::result<::fidl::OneWayError>
fidl::internal::NaturalClientImpl<::test_typesinprotocols::Protocol>::OneWayArrayVectorNested(const ::fidl::Request<::test_typesinprotocols::Protocol::OneWayArrayVectorNested>& request) const {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_OneWayArrayVectorNested_Ordinal, ::test_typesinprotocols::kProtocol_OneWayArrayVectorNested_DynamicFlags};
  _encoder.EncodeBody(request);

  ::fidl::OutgoingMessage _encoded_message = _encoder.GetMessage();
  ::fidl::OneWayStatus status = client_base().SendOneWay(_encoded_message);
  return ::fidl::internal::ToFitxResult(status);
}

::fit::result<::fidl::OneWayError>
fidl::internal::NaturalClientImpl<::test_typesinprotocols::Protocol>::OneWayResource(::fidl::Request<::test_typesinprotocols::Protocol::OneWayResource> request) const {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_OneWayResource_Ordinal, ::test_typesinprotocols::kProtocol_OneWayResource_DynamicFlags};
  _encoder.EncodeBody(std::move(request));

  ::fidl::OutgoingMessage _encoded_message = _encoder.GetMessage();
  ::fidl::OneWayStatus status = client_base().SendOneWay(_encoded_message);
  return ::fidl::internal::ToFitxResult(status);
}
namespace test_typesinprotocols {

#endif  // __Fuchsia__

}  // namespace test_typesinprotocols

#ifdef __Fuchsia__

::fidl::Result<::test_typesinprotocols::Protocol::TwoWayBasic>
fidl::internal::NaturalSyncClientImpl<::test_typesinprotocols::Protocol>::TwoWayBasic(const ::fidl::Request<::test_typesinprotocols::Protocol::TwoWayBasic>& request) {
  ::fidl::internal::NaturalMessageEncoder encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_TwoWayBasic_Ordinal, ::test_typesinprotocols::kProtocol_TwoWayBasic_DynamicFlags};
  encoder.EncodeBody(request);
  ::fidl::OutgoingMessage msg = encoder.GetMessage();
  ::fidl::internal::IncomingMessageStorage<::fidl::internal::TransactionalResponse<::test_typesinprotocols::Protocol::TwoWayBasic>> response_storage;
  return ::fidl::internal::DecodeResponseAndFoldError<::test_typesinprotocols::Protocol::TwoWayBasic>(
      msg.Call(_client_end().handle(), response_storage.view()), nullptr);
}

::fidl::Result<::test_typesinprotocols::Protocol::ErrorBasic>
fidl::internal::NaturalSyncClientImpl<::test_typesinprotocols::Protocol>::ErrorBasic() {
  ::fidl::internal::NaturalMessageEncoder encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_ErrorBasic_Ordinal, ::test_typesinprotocols::kProtocol_ErrorBasic_DynamicFlags};
  ::fidl::OutgoingMessage msg = encoder.GetMessage();
  ::fidl::internal::IncomingMessageStorage<::fidl::internal::TransactionalResponse<::test_typesinprotocols::Protocol::ErrorBasic>> response_storage;
  return ::fidl::internal::DecodeResponseAndFoldError<::test_typesinprotocols::Protocol::ErrorBasic>(
      msg.Call(_client_end().handle(), response_storage.view()), nullptr);
}

::fidl::Result<::test_typesinprotocols::Protocol::TwoWayCompound>
fidl::internal::NaturalSyncClientImpl<::test_typesinprotocols::Protocol>::TwoWayCompound(const ::fidl::Request<::test_typesinprotocols::Protocol::TwoWayCompound>& request) {
  ::fidl::internal::NaturalMessageEncoder encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_TwoWayCompound_Ordinal, ::test_typesinprotocols::kProtocol_TwoWayCompound_DynamicFlags};
  encoder.EncodeBody(request);
  ::fidl::OutgoingMessage msg = encoder.GetMessage();
  ::fidl::internal::IncomingMessageStorage<::fidl::internal::TransactionalResponse<::test_typesinprotocols::Protocol::TwoWayCompound>> response_storage;
  return ::fidl::internal::DecodeResponseAndFoldError<::test_typesinprotocols::Protocol::TwoWayCompound>(
      msg.Call(_client_end().handle(), response_storage.view()), nullptr);
}

::fidl::Result<::test_typesinprotocols::Protocol::ErrorCompound>
fidl::internal::NaturalSyncClientImpl<::test_typesinprotocols::Protocol>::ErrorCompound() {
  ::fidl::internal::NaturalMessageEncoder encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_ErrorCompound_Ordinal, ::test_typesinprotocols::kProtocol_ErrorCompound_DynamicFlags};
  ::fidl::OutgoingMessage msg = encoder.GetMessage();
  ::fidl::internal::IncomingMessageStorage<::fidl::internal::TransactionalResponse<::test_typesinprotocols::Protocol::ErrorCompound>> response_storage;
  return ::fidl::internal::DecodeResponseAndFoldError<::test_typesinprotocols::Protocol::ErrorCompound>(
      msg.Call(_client_end().handle(), response_storage.view()), nullptr);
}

::fidl::Result<::test_typesinprotocols::Protocol::TwoWayArrayBasic>
fidl::internal::NaturalSyncClientImpl<::test_typesinprotocols::Protocol>::TwoWayArrayBasic(const ::fidl::Request<::test_typesinprotocols::Protocol::TwoWayArrayBasic>& request) {
  ::fidl::internal::NaturalMessageEncoder encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_TwoWayArrayBasic_Ordinal, ::test_typesinprotocols::kProtocol_TwoWayArrayBasic_DynamicFlags};
  encoder.EncodeBody(request);
  ::fidl::OutgoingMessage msg = encoder.GetMessage();
  ::fidl::internal::IncomingMessageStorage<::fidl::internal::TransactionalResponse<::test_typesinprotocols::Protocol::TwoWayArrayBasic>> response_storage;
  return ::fidl::internal::DecodeResponseAndFoldError<::test_typesinprotocols::Protocol::TwoWayArrayBasic>(
      msg.Call(_client_end().handle(), response_storage.view()), nullptr);
}

::fidl::Result<::test_typesinprotocols::Protocol::ErrorArrayBasic>
fidl::internal::NaturalSyncClientImpl<::test_typesinprotocols::Protocol>::ErrorArrayBasic() {
  ::fidl::internal::NaturalMessageEncoder encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_ErrorArrayBasic_Ordinal, ::test_typesinprotocols::kProtocol_ErrorArrayBasic_DynamicFlags};
  ::fidl::OutgoingMessage msg = encoder.GetMessage();
  ::fidl::internal::IncomingMessageStorage<::fidl::internal::TransactionalResponse<::test_typesinprotocols::Protocol::ErrorArrayBasic>> response_storage;
  return ::fidl::internal::DecodeResponseAndFoldError<::test_typesinprotocols::Protocol::ErrorArrayBasic>(
      msg.Call(_client_end().handle(), response_storage.view()), nullptr);
}

::fidl::Result<::test_typesinprotocols::Protocol::TwoWayArrayCompound>
fidl::internal::NaturalSyncClientImpl<::test_typesinprotocols::Protocol>::TwoWayArrayCompound(const ::fidl::Request<::test_typesinprotocols::Protocol::TwoWayArrayCompound>& request) {
  ::fidl::internal::NaturalMessageEncoder encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_TwoWayArrayCompound_Ordinal, ::test_typesinprotocols::kProtocol_TwoWayArrayCompound_DynamicFlags};
  encoder.EncodeBody(request);
  ::fidl::OutgoingMessage msg = encoder.GetMessage();
  ::fidl::internal::IncomingMessageStorage<::fidl::internal::TransactionalResponse<::test_typesinprotocols::Protocol::TwoWayArrayCompound>> response_storage;
  return ::fidl::internal::DecodeResponseAndFoldError<::test_typesinprotocols::Protocol::TwoWayArrayCompound>(
      msg.Call(_client_end().handle(), response_storage.view()), nullptr);
}

::fidl::Result<::test_typesinprotocols::Protocol::ErrorArrayCompound>
fidl::internal::NaturalSyncClientImpl<::test_typesinprotocols::Protocol>::ErrorArrayCompound() {
  ::fidl::internal::NaturalMessageEncoder encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_ErrorArrayCompound_Ordinal, ::test_typesinprotocols::kProtocol_ErrorArrayCompound_DynamicFlags};
  ::fidl::OutgoingMessage msg = encoder.GetMessage();
  ::fidl::internal::IncomingMessageStorage<::fidl::internal::TransactionalResponse<::test_typesinprotocols::Protocol::ErrorArrayCompound>> response_storage;
  return ::fidl::internal::DecodeResponseAndFoldError<::test_typesinprotocols::Protocol::ErrorArrayCompound>(
      msg.Call(_client_end().handle(), response_storage.view()), nullptr);
}

::fidl::Result<::test_typesinprotocols::Protocol::TwoWayVectorBasic>
fidl::internal::NaturalSyncClientImpl<::test_typesinprotocols::Protocol>::TwoWayVectorBasic(const ::fidl::Request<::test_typesinprotocols::Protocol::TwoWayVectorBasic>& request) {
  ::fidl::internal::NaturalMessageEncoder encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_TwoWayVectorBasic_Ordinal, ::test_typesinprotocols::kProtocol_TwoWayVectorBasic_DynamicFlags};
  encoder.EncodeBody(request);
  ::fidl::OutgoingMessage msg = encoder.GetMessage();
  ::fidl::internal::IncomingMessageStorage<::fidl::internal::TransactionalResponse<::test_typesinprotocols::Protocol::TwoWayVectorBasic>> response_storage;
  return ::fidl::internal::DecodeResponseAndFoldError<::test_typesinprotocols::Protocol::TwoWayVectorBasic>(
      msg.Call(_client_end().handle(), response_storage.view()), nullptr);
}

::fidl::Result<::test_typesinprotocols::Protocol::ErrorVectorBasic>
fidl::internal::NaturalSyncClientImpl<::test_typesinprotocols::Protocol>::ErrorVectorBasic() {
  ::fidl::internal::NaturalMessageEncoder encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_ErrorVectorBasic_Ordinal, ::test_typesinprotocols::kProtocol_ErrorVectorBasic_DynamicFlags};
  ::fidl::OutgoingMessage msg = encoder.GetMessage();
  ::fidl::internal::IncomingMessageStorage<::fidl::internal::TransactionalResponse<::test_typesinprotocols::Protocol::ErrorVectorBasic>> response_storage;
  return ::fidl::internal::DecodeResponseAndFoldError<::test_typesinprotocols::Protocol::ErrorVectorBasic>(
      msg.Call(_client_end().handle(), response_storage.view()), nullptr);
}

::fidl::Result<::test_typesinprotocols::Protocol::TwoWayVectorCompound>
fidl::internal::NaturalSyncClientImpl<::test_typesinprotocols::Protocol>::TwoWayVectorCompound(const ::fidl::Request<::test_typesinprotocols::Protocol::TwoWayVectorCompound>& request) {
  ::fidl::internal::NaturalMessageEncoder encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_TwoWayVectorCompound_Ordinal, ::test_typesinprotocols::kProtocol_TwoWayVectorCompound_DynamicFlags};
  encoder.EncodeBody(request);
  ::fidl::OutgoingMessage msg = encoder.GetMessage();
  ::fidl::internal::IncomingMessageStorage<::fidl::internal::TransactionalResponse<::test_typesinprotocols::Protocol::TwoWayVectorCompound>> response_storage;
  return ::fidl::internal::DecodeResponseAndFoldError<::test_typesinprotocols::Protocol::TwoWayVectorCompound>(
      msg.Call(_client_end().handle(), response_storage.view()), nullptr);
}

::fidl::Result<::test_typesinprotocols::Protocol::ErrorVectorCompound>
fidl::internal::NaturalSyncClientImpl<::test_typesinprotocols::Protocol>::ErrorVectorCompound() {
  ::fidl::internal::NaturalMessageEncoder encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_ErrorVectorCompound_Ordinal, ::test_typesinprotocols::kProtocol_ErrorVectorCompound_DynamicFlags};
  ::fidl::OutgoingMessage msg = encoder.GetMessage();
  ::fidl::internal::IncomingMessageStorage<::fidl::internal::TransactionalResponse<::test_typesinprotocols::Protocol::ErrorVectorCompound>> response_storage;
  return ::fidl::internal::DecodeResponseAndFoldError<::test_typesinprotocols::Protocol::ErrorVectorCompound>(
      msg.Call(_client_end().handle(), response_storage.view()), nullptr);
}

::fidl::Result<::test_typesinprotocols::Protocol::TwoWayVectorOptional>
fidl::internal::NaturalSyncClientImpl<::test_typesinprotocols::Protocol>::TwoWayVectorOptional(const ::fidl::Request<::test_typesinprotocols::Protocol::TwoWayVectorOptional>& request) {
  ::fidl::internal::NaturalMessageEncoder encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_TwoWayVectorOptional_Ordinal, ::test_typesinprotocols::kProtocol_TwoWayVectorOptional_DynamicFlags};
  encoder.EncodeBody(request);
  ::fidl::OutgoingMessage msg = encoder.GetMessage();
  ::fidl::internal::IncomingMessageStorage<::fidl::internal::TransactionalResponse<::test_typesinprotocols::Protocol::TwoWayVectorOptional>> response_storage;
  return ::fidl::internal::DecodeResponseAndFoldError<::test_typesinprotocols::Protocol::TwoWayVectorOptional>(
      msg.Call(_client_end().handle(), response_storage.view()), nullptr);
}

::fidl::Result<::test_typesinprotocols::Protocol::ErrorVectorOptional>
fidl::internal::NaturalSyncClientImpl<::test_typesinprotocols::Protocol>::ErrorVectorOptional() {
  ::fidl::internal::NaturalMessageEncoder encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_ErrorVectorOptional_Ordinal, ::test_typesinprotocols::kProtocol_ErrorVectorOptional_DynamicFlags};
  ::fidl::OutgoingMessage msg = encoder.GetMessage();
  ::fidl::internal::IncomingMessageStorage<::fidl::internal::TransactionalResponse<::test_typesinprotocols::Protocol::ErrorVectorOptional>> response_storage;
  return ::fidl::internal::DecodeResponseAndFoldError<::test_typesinprotocols::Protocol::ErrorVectorOptional>(
      msg.Call(_client_end().handle(), response_storage.view()), nullptr);
}

::fidl::Result<::test_typesinprotocols::Protocol::TwoWayArrayVectorNested>
fidl::internal::NaturalSyncClientImpl<::test_typesinprotocols::Protocol>::TwoWayArrayVectorNested(const ::fidl::Request<::test_typesinprotocols::Protocol::TwoWayArrayVectorNested>& request) {
  ::fidl::internal::NaturalMessageEncoder encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_TwoWayArrayVectorNested_Ordinal, ::test_typesinprotocols::kProtocol_TwoWayArrayVectorNested_DynamicFlags};
  encoder.EncodeBody(request);
  ::fidl::OutgoingMessage msg = encoder.GetMessage();
  ::fidl::internal::IncomingMessageStorage<::fidl::internal::TransactionalResponse<::test_typesinprotocols::Protocol::TwoWayArrayVectorNested>> response_storage;
  return ::fidl::internal::DecodeResponseAndFoldError<::test_typesinprotocols::Protocol::TwoWayArrayVectorNested>(
      msg.Call(_client_end().handle(), response_storage.view()), nullptr);
}

::fidl::Result<::test_typesinprotocols::Protocol::ErrorArrayVectorNested>
fidl::internal::NaturalSyncClientImpl<::test_typesinprotocols::Protocol>::ErrorArrayVectorNested() {
  ::fidl::internal::NaturalMessageEncoder encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_ErrorArrayVectorNested_Ordinal, ::test_typesinprotocols::kProtocol_ErrorArrayVectorNested_DynamicFlags};
  ::fidl::OutgoingMessage msg = encoder.GetMessage();
  ::fidl::internal::IncomingMessageStorage<::fidl::internal::TransactionalResponse<::test_typesinprotocols::Protocol::ErrorArrayVectorNested>> response_storage;
  return ::fidl::internal::DecodeResponseAndFoldError<::test_typesinprotocols::Protocol::ErrorArrayVectorNested>(
      msg.Call(_client_end().handle(), response_storage.view()), nullptr);
}

::fidl::Result<::test_typesinprotocols::Protocol::TwoWayResource>
fidl::internal::NaturalSyncClientImpl<::test_typesinprotocols::Protocol>::TwoWayResource(::fidl::Request<::test_typesinprotocols::Protocol::TwoWayResource> request) {
  ::fidl::internal::NaturalMessageEncoder encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_TwoWayResource_Ordinal, ::test_typesinprotocols::kProtocol_TwoWayResource_DynamicFlags};
  encoder.EncodeBody(std::move(request));
  ::fidl::OutgoingMessage msg = encoder.GetMessage();
  ::fidl::internal::IncomingMessageStorage<::fidl::internal::TransactionalResponse<::test_typesinprotocols::Protocol::TwoWayResource>> response_storage;
  return ::fidl::internal::DecodeResponseAndFoldError<::test_typesinprotocols::Protocol::TwoWayResource>(
      msg.Call(_client_end().handle(), response_storage.view()), nullptr);
}

::fidl::Result<::test_typesinprotocols::Protocol::ErrorResource>
fidl::internal::NaturalSyncClientImpl<::test_typesinprotocols::Protocol>::ErrorResource() {
  ::fidl::internal::NaturalMessageEncoder encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_ErrorResource_Ordinal, ::test_typesinprotocols::kProtocol_ErrorResource_DynamicFlags};
  ::fidl::OutgoingMessage msg = encoder.GetMessage();
  ::fidl::internal::IncomingMessageStorage<::fidl::internal::TransactionalResponse<::test_typesinprotocols::Protocol::ErrorResource>> response_storage;
  return ::fidl::internal::DecodeResponseAndFoldError<::test_typesinprotocols::Protocol::ErrorResource>(
      msg.Call(_client_end().handle(), response_storage.view()), nullptr);
}

::fit::result<::fidl::OneWayError>
fidl::internal::NaturalSyncClientImpl<::test_typesinprotocols::Protocol>::OneWayBasic(const ::fidl::Request<::test_typesinprotocols::Protocol::OneWayBasic>& request) {
  ::fidl::internal::NaturalMessageEncoder encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_OneWayBasic_Ordinal, ::test_typesinprotocols::kProtocol_OneWayBasic_DynamicFlags};
  encoder.EncodeBody(request);
  ::fidl::OutgoingMessage msg = encoder.GetMessage();
  msg.Write(_client_end().handle());
  return ::fidl::internal::ToFitxResult(::fidl::OneWayStatus{msg});
}

::fit::result<::fidl::OneWayError>
fidl::internal::NaturalSyncClientImpl<::test_typesinprotocols::Protocol>::OneWayCompound(const ::fidl::Request<::test_typesinprotocols::Protocol::OneWayCompound>& request) {
  ::fidl::internal::NaturalMessageEncoder encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_OneWayCompound_Ordinal, ::test_typesinprotocols::kProtocol_OneWayCompound_DynamicFlags};
  encoder.EncodeBody(request);
  ::fidl::OutgoingMessage msg = encoder.GetMessage();
  msg.Write(_client_end().handle());
  return ::fidl::internal::ToFitxResult(::fidl::OneWayStatus{msg});
}

::fit::result<::fidl::OneWayError>
fidl::internal::NaturalSyncClientImpl<::test_typesinprotocols::Protocol>::OneWayArrayBasic(const ::fidl::Request<::test_typesinprotocols::Protocol::OneWayArrayBasic>& request) {
  ::fidl::internal::NaturalMessageEncoder encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_OneWayArrayBasic_Ordinal, ::test_typesinprotocols::kProtocol_OneWayArrayBasic_DynamicFlags};
  encoder.EncodeBody(request);
  ::fidl::OutgoingMessage msg = encoder.GetMessage();
  msg.Write(_client_end().handle());
  return ::fidl::internal::ToFitxResult(::fidl::OneWayStatus{msg});
}

::fit::result<::fidl::OneWayError>
fidl::internal::NaturalSyncClientImpl<::test_typesinprotocols::Protocol>::OneWayArrayCompound(const ::fidl::Request<::test_typesinprotocols::Protocol::OneWayArrayCompound>& request) {
  ::fidl::internal::NaturalMessageEncoder encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_OneWayArrayCompound_Ordinal, ::test_typesinprotocols::kProtocol_OneWayArrayCompound_DynamicFlags};
  encoder.EncodeBody(request);
  ::fidl::OutgoingMessage msg = encoder.GetMessage();
  msg.Write(_client_end().handle());
  return ::fidl::internal::ToFitxResult(::fidl::OneWayStatus{msg});
}

::fit::result<::fidl::OneWayError>
fidl::internal::NaturalSyncClientImpl<::test_typesinprotocols::Protocol>::OneWayVectorBasic(const ::fidl::Request<::test_typesinprotocols::Protocol::OneWayVectorBasic>& request) {
  ::fidl::internal::NaturalMessageEncoder encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_OneWayVectorBasic_Ordinal, ::test_typesinprotocols::kProtocol_OneWayVectorBasic_DynamicFlags};
  encoder.EncodeBody(request);
  ::fidl::OutgoingMessage msg = encoder.GetMessage();
  msg.Write(_client_end().handle());
  return ::fidl::internal::ToFitxResult(::fidl::OneWayStatus{msg});
}

::fit::result<::fidl::OneWayError>
fidl::internal::NaturalSyncClientImpl<::test_typesinprotocols::Protocol>::OneWayVectorCompound(const ::fidl::Request<::test_typesinprotocols::Protocol::OneWayVectorCompound>& request) {
  ::fidl::internal::NaturalMessageEncoder encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_OneWayVectorCompound_Ordinal, ::test_typesinprotocols::kProtocol_OneWayVectorCompound_DynamicFlags};
  encoder.EncodeBody(request);
  ::fidl::OutgoingMessage msg = encoder.GetMessage();
  msg.Write(_client_end().handle());
  return ::fidl::internal::ToFitxResult(::fidl::OneWayStatus{msg});
}

::fit::result<::fidl::OneWayError>
fidl::internal::NaturalSyncClientImpl<::test_typesinprotocols::Protocol>::OneWayVectorOptional(const ::fidl::Request<::test_typesinprotocols::Protocol::OneWayVectorOptional>& request) {
  ::fidl::internal::NaturalMessageEncoder encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_OneWayVectorOptional_Ordinal, ::test_typesinprotocols::kProtocol_OneWayVectorOptional_DynamicFlags};
  encoder.EncodeBody(request);
  ::fidl::OutgoingMessage msg = encoder.GetMessage();
  msg.Write(_client_end().handle());
  return ::fidl::internal::ToFitxResult(::fidl::OneWayStatus{msg});
}

::fit::result<::fidl::OneWayError>
fidl::internal::NaturalSyncClientImpl<::test_typesinprotocols::Protocol>::OneWayArrayVectorNested(const ::fidl::Request<::test_typesinprotocols::Protocol::OneWayArrayVectorNested>& request) {
  ::fidl::internal::NaturalMessageEncoder encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_OneWayArrayVectorNested_Ordinal, ::test_typesinprotocols::kProtocol_OneWayArrayVectorNested_DynamicFlags};
  encoder.EncodeBody(request);
  ::fidl::OutgoingMessage msg = encoder.GetMessage();
  msg.Write(_client_end().handle());
  return ::fidl::internal::ToFitxResult(::fidl::OneWayStatus{msg});
}

::fit::result<::fidl::OneWayError>
fidl::internal::NaturalSyncClientImpl<::test_typesinprotocols::Protocol>::OneWayResource(::fidl::Request<::test_typesinprotocols::Protocol::OneWayResource> request) {
  ::fidl::internal::NaturalMessageEncoder encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_OneWayResource_Ordinal, ::test_typesinprotocols::kProtocol_OneWayResource_DynamicFlags};
  encoder.EncodeBody(std::move(request));
  ::fidl::OutgoingMessage msg = encoder.GetMessage();
  msg.Write(_client_end().handle());
  return ::fidl::internal::ToFitxResult(::fidl::OneWayStatus{msg});
}

#endif  // __Fuchsia__

#ifdef __Fuchsia__

::fidl::Status fidl::SyncEventHandler<::test_typesinprotocols::Protocol>::HandleOneEvent(
    ::fidl::UnownedClientEnd<::test_typesinprotocols::Protocol> client_end) {
  ::fidl::internal::IncomingEventsStorage<::test_typesinprotocols::Protocol> event_storage;
  fidl::internal::NaturalEventDispatcher<::test_typesinprotocols::Protocol> dispatcher{this};
  return HandleOneEventImpl_(client_end.channel(), event_storage.view(), dispatcher);
}
::fidl::Status
fidl::internal::NaturalEventDispatcher<::test_typesinprotocols::Protocol>::DispatchEvent(
    ::fidl::IncomingHeaderAndMessage& msg,
    ::fidl::internal::MessageStorageViewBase* storage_view) {
  switch (msg.header()->ordinal) {
    case ::test_typesinprotocols::kProtocol_EventBasic_Ordinal: {
      ::fit::result decoded = ::fidl::internal::DecodeTransactionalMessage<::test_typesinprotocols::Basic>(std::move(msg));
      if (decoded.is_error()) {
        return decoded.error_value();
      }
      if (event_handler()) {
        ::fidl::Event<::test_typesinprotocols::Protocol::EventBasic> event = std::move(decoded.value());
        event_handler()->EventBasic(event);
      }
      return ::fidl::Status::Ok();
    }
    case ::test_typesinprotocols::kProtocol_EventCompound_Ordinal: {
      ::fit::result decoded = ::fidl::internal::DecodeTransactionalMessage<::test_typesinprotocols::Compound>(std::move(msg));
      if (decoded.is_error()) {
        return decoded.error_value();
      }
      if (event_handler()) {
        ::fidl::Event<::test_typesinprotocols::Protocol::EventCompound> event = std::move(decoded.value());
        event_handler()->EventCompound(event);
      }
      return ::fidl::Status::Ok();
    }
    case ::test_typesinprotocols::kProtocol_EventArrayBasic_Ordinal: {
      ::fit::result decoded = ::fidl::internal::DecodeTransactionalMessage<::test_typesinprotocols::ArrayBasic>(std::move(msg));
      if (decoded.is_error()) {
        return decoded.error_value();
      }
      if (event_handler()) {
        ::fidl::Event<::test_typesinprotocols::Protocol::EventArrayBasic> event = std::move(decoded.value());
        event_handler()->EventArrayBasic(event);
      }
      return ::fidl::Status::Ok();
    }
    case ::test_typesinprotocols::kProtocol_EventArrayCompound_Ordinal: {
      ::fit::result decoded = ::fidl::internal::DecodeTransactionalMessage<::test_typesinprotocols::ArrayCompound>(std::move(msg));
      if (decoded.is_error()) {
        return decoded.error_value();
      }
      if (event_handler()) {
        ::fidl::Event<::test_typesinprotocols::Protocol::EventArrayCompound> event = std::move(decoded.value());
        event_handler()->EventArrayCompound(event);
      }
      return ::fidl::Status::Ok();
    }
    case ::test_typesinprotocols::kProtocol_EventVectorBasic_Ordinal: {
      ::fit::result decoded = ::fidl::internal::DecodeTransactionalMessage<::test_typesinprotocols::VectorBasic>(std::move(msg));
      if (decoded.is_error()) {
        return decoded.error_value();
      }
      if (event_handler()) {
        ::fidl::Event<::test_typesinprotocols::Protocol::EventVectorBasic> event = std::move(decoded.value());
        event_handler()->EventVectorBasic(event);
      }
      return ::fidl::Status::Ok();
    }
    case ::test_typesinprotocols::kProtocol_EventVectorCompound_Ordinal: {
      ::fit::result decoded = ::fidl::internal::DecodeTransactionalMessage<::test_typesinprotocols::VectorCompound>(std::move(msg));
      if (decoded.is_error()) {
        return decoded.error_value();
      }
      if (event_handler()) {
        ::fidl::Event<::test_typesinprotocols::Protocol::EventVectorCompound> event = std::move(decoded.value());
        event_handler()->EventVectorCompound(event);
      }
      return ::fidl::Status::Ok();
    }
    case ::test_typesinprotocols::kProtocol_EventVectorOptional_Ordinal: {
      ::fit::result decoded = ::fidl::internal::DecodeTransactionalMessage<::test_typesinprotocols::VectorOptional>(std::move(msg));
      if (decoded.is_error()) {
        return decoded.error_value();
      }
      if (event_handler()) {
        ::fidl::Event<::test_typesinprotocols::Protocol::EventVectorOptional> event = std::move(decoded.value());
        event_handler()->EventVectorOptional(event);
      }
      return ::fidl::Status::Ok();
    }
    case ::test_typesinprotocols::kProtocol_EventArrayVectorNested_Ordinal: {
      ::fit::result decoded = ::fidl::internal::DecodeTransactionalMessage<::test_typesinprotocols::ArrayVectorNested>(std::move(msg));
      if (decoded.is_error()) {
        return decoded.error_value();
      }
      if (event_handler()) {
        ::fidl::Event<::test_typesinprotocols::Protocol::EventArrayVectorNested> event = std::move(decoded.value());
        event_handler()->EventArrayVectorNested(event);
      }
      return ::fidl::Status::Ok();
    }
    case ::test_typesinprotocols::kProtocol_EventResource_Ordinal: {
      ::fit::result decoded = ::fidl::internal::DecodeTransactionalMessage<::test_typesinprotocols::Resource>(std::move(msg));
      if (decoded.is_error()) {
        return decoded.error_value();
      }
      if (event_handler()) {
        ::fidl::Event<::test_typesinprotocols::Protocol::EventResource> event = std::move(decoded.value());
        event_handler()->EventResource(event);
      }
      return ::fidl::Status::Ok();
    }
    default:
      std::move(msg).CloseHandles();
      return ::fidl::Status::UnknownOrdinal();
  }
}

#endif  // __Fuchsia__

#ifdef __Fuchsia__

::fit::result<::fidl::OneWayError> fidl::internal::NaturalWeakEventSender<::test_typesinprotocols::Protocol>::EventBasic(const ::test_typesinprotocols::Basic& payload) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_EventBasic_Ordinal, ::test_typesinprotocols::kProtocol_EventBasic_DynamicFlags};
  _encoder.EncodeBody(payload);
  ::fidl::OutgoingMessage _encoded_message = _encoder.GetMessage();
  return ::fidl::internal::ToFitxResult(_inner().SendEvent(_encoded_message));
}

::fit::result<::fidl::OneWayError> fidl::internal::NaturalEventSender<::test_typesinprotocols::Protocol>::EventBasic(const ::test_typesinprotocols::Basic& payload) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_EventBasic_Ordinal, ::test_typesinprotocols::kProtocol_EventBasic_DynamicFlags};
  _encoder.EncodeBody(payload);
  ::fidl::OutgoingMessage _encoded_message = _encoder.GetMessage();
  _encoded_message.Write(_transport());
  return ::fidl::internal::ToFitxResult(::fidl::OneWayStatus{::fidl::Status{_encoded_message}});
}

::fit::result<::fidl::OneWayError> fidl::internal::NaturalWeakEventSender<::test_typesinprotocols::Protocol>::EventCompound(const ::test_typesinprotocols::Compound& payload) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_EventCompound_Ordinal, ::test_typesinprotocols::kProtocol_EventCompound_DynamicFlags};
  _encoder.EncodeBody(payload);
  ::fidl::OutgoingMessage _encoded_message = _encoder.GetMessage();
  return ::fidl::internal::ToFitxResult(_inner().SendEvent(_encoded_message));
}

::fit::result<::fidl::OneWayError> fidl::internal::NaturalEventSender<::test_typesinprotocols::Protocol>::EventCompound(const ::test_typesinprotocols::Compound& payload) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_EventCompound_Ordinal, ::test_typesinprotocols::kProtocol_EventCompound_DynamicFlags};
  _encoder.EncodeBody(payload);
  ::fidl::OutgoingMessage _encoded_message = _encoder.GetMessage();
  _encoded_message.Write(_transport());
  return ::fidl::internal::ToFitxResult(::fidl::OneWayStatus{::fidl::Status{_encoded_message}});
}

::fit::result<::fidl::OneWayError> fidl::internal::NaturalWeakEventSender<::test_typesinprotocols::Protocol>::EventArrayBasic(const ::test_typesinprotocols::ArrayBasic& payload) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_EventArrayBasic_Ordinal, ::test_typesinprotocols::kProtocol_EventArrayBasic_DynamicFlags};
  _encoder.EncodeBody(payload);
  ::fidl::OutgoingMessage _encoded_message = _encoder.GetMessage();
  return ::fidl::internal::ToFitxResult(_inner().SendEvent(_encoded_message));
}

::fit::result<::fidl::OneWayError> fidl::internal::NaturalEventSender<::test_typesinprotocols::Protocol>::EventArrayBasic(const ::test_typesinprotocols::ArrayBasic& payload) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_EventArrayBasic_Ordinal, ::test_typesinprotocols::kProtocol_EventArrayBasic_DynamicFlags};
  _encoder.EncodeBody(payload);
  ::fidl::OutgoingMessage _encoded_message = _encoder.GetMessage();
  _encoded_message.Write(_transport());
  return ::fidl::internal::ToFitxResult(::fidl::OneWayStatus{::fidl::Status{_encoded_message}});
}

::fit::result<::fidl::OneWayError> fidl::internal::NaturalWeakEventSender<::test_typesinprotocols::Protocol>::EventArrayCompound(const ::test_typesinprotocols::ArrayCompound& payload) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_EventArrayCompound_Ordinal, ::test_typesinprotocols::kProtocol_EventArrayCompound_DynamicFlags};
  _encoder.EncodeBody(payload);
  ::fidl::OutgoingMessage _encoded_message = _encoder.GetMessage();
  return ::fidl::internal::ToFitxResult(_inner().SendEvent(_encoded_message));
}

::fit::result<::fidl::OneWayError> fidl::internal::NaturalEventSender<::test_typesinprotocols::Protocol>::EventArrayCompound(const ::test_typesinprotocols::ArrayCompound& payload) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_EventArrayCompound_Ordinal, ::test_typesinprotocols::kProtocol_EventArrayCompound_DynamicFlags};
  _encoder.EncodeBody(payload);
  ::fidl::OutgoingMessage _encoded_message = _encoder.GetMessage();
  _encoded_message.Write(_transport());
  return ::fidl::internal::ToFitxResult(::fidl::OneWayStatus{::fidl::Status{_encoded_message}});
}

::fit::result<::fidl::OneWayError> fidl::internal::NaturalWeakEventSender<::test_typesinprotocols::Protocol>::EventVectorBasic(const ::test_typesinprotocols::VectorBasic& payload) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_EventVectorBasic_Ordinal, ::test_typesinprotocols::kProtocol_EventVectorBasic_DynamicFlags};
  _encoder.EncodeBody(payload);
  ::fidl::OutgoingMessage _encoded_message = _encoder.GetMessage();
  return ::fidl::internal::ToFitxResult(_inner().SendEvent(_encoded_message));
}

::fit::result<::fidl::OneWayError> fidl::internal::NaturalEventSender<::test_typesinprotocols::Protocol>::EventVectorBasic(const ::test_typesinprotocols::VectorBasic& payload) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_EventVectorBasic_Ordinal, ::test_typesinprotocols::kProtocol_EventVectorBasic_DynamicFlags};
  _encoder.EncodeBody(payload);
  ::fidl::OutgoingMessage _encoded_message = _encoder.GetMessage();
  _encoded_message.Write(_transport());
  return ::fidl::internal::ToFitxResult(::fidl::OneWayStatus{::fidl::Status{_encoded_message}});
}

::fit::result<::fidl::OneWayError> fidl::internal::NaturalWeakEventSender<::test_typesinprotocols::Protocol>::EventVectorCompound(const ::test_typesinprotocols::VectorCompound& payload) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_EventVectorCompound_Ordinal, ::test_typesinprotocols::kProtocol_EventVectorCompound_DynamicFlags};
  _encoder.EncodeBody(payload);
  ::fidl::OutgoingMessage _encoded_message = _encoder.GetMessage();
  return ::fidl::internal::ToFitxResult(_inner().SendEvent(_encoded_message));
}

::fit::result<::fidl::OneWayError> fidl::internal::NaturalEventSender<::test_typesinprotocols::Protocol>::EventVectorCompound(const ::test_typesinprotocols::VectorCompound& payload) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_EventVectorCompound_Ordinal, ::test_typesinprotocols::kProtocol_EventVectorCompound_DynamicFlags};
  _encoder.EncodeBody(payload);
  ::fidl::OutgoingMessage _encoded_message = _encoder.GetMessage();
  _encoded_message.Write(_transport());
  return ::fidl::internal::ToFitxResult(::fidl::OneWayStatus{::fidl::Status{_encoded_message}});
}

::fit::result<::fidl::OneWayError> fidl::internal::NaturalWeakEventSender<::test_typesinprotocols::Protocol>::EventVectorOptional(const ::test_typesinprotocols::VectorOptional& payload) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_EventVectorOptional_Ordinal, ::test_typesinprotocols::kProtocol_EventVectorOptional_DynamicFlags};
  _encoder.EncodeBody(payload);
  ::fidl::OutgoingMessage _encoded_message = _encoder.GetMessage();
  return ::fidl::internal::ToFitxResult(_inner().SendEvent(_encoded_message));
}

::fit::result<::fidl::OneWayError> fidl::internal::NaturalEventSender<::test_typesinprotocols::Protocol>::EventVectorOptional(const ::test_typesinprotocols::VectorOptional& payload) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_EventVectorOptional_Ordinal, ::test_typesinprotocols::kProtocol_EventVectorOptional_DynamicFlags};
  _encoder.EncodeBody(payload);
  ::fidl::OutgoingMessage _encoded_message = _encoder.GetMessage();
  _encoded_message.Write(_transport());
  return ::fidl::internal::ToFitxResult(::fidl::OneWayStatus{::fidl::Status{_encoded_message}});
}

::fit::result<::fidl::OneWayError> fidl::internal::NaturalWeakEventSender<::test_typesinprotocols::Protocol>::EventArrayVectorNested(const ::test_typesinprotocols::ArrayVectorNested& payload) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_EventArrayVectorNested_Ordinal, ::test_typesinprotocols::kProtocol_EventArrayVectorNested_DynamicFlags};
  _encoder.EncodeBody(payload);
  ::fidl::OutgoingMessage _encoded_message = _encoder.GetMessage();
  return ::fidl::internal::ToFitxResult(_inner().SendEvent(_encoded_message));
}

::fit::result<::fidl::OneWayError> fidl::internal::NaturalEventSender<::test_typesinprotocols::Protocol>::EventArrayVectorNested(const ::test_typesinprotocols::ArrayVectorNested& payload) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_EventArrayVectorNested_Ordinal, ::test_typesinprotocols::kProtocol_EventArrayVectorNested_DynamicFlags};
  _encoder.EncodeBody(payload);
  ::fidl::OutgoingMessage _encoded_message = _encoder.GetMessage();
  _encoded_message.Write(_transport());
  return ::fidl::internal::ToFitxResult(::fidl::OneWayStatus{::fidl::Status{_encoded_message}});
}

::fit::result<::fidl::OneWayError> fidl::internal::NaturalWeakEventSender<::test_typesinprotocols::Protocol>::EventResource(::test_typesinprotocols::Resource payload) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_EventResource_Ordinal, ::test_typesinprotocols::kProtocol_EventResource_DynamicFlags};
  _encoder.EncodeBody(std::move(payload));
  ::fidl::OutgoingMessage _encoded_message = _encoder.GetMessage();
  return ::fidl::internal::ToFitxResult(_inner().SendEvent(_encoded_message));
}

::fit::result<::fidl::OneWayError> fidl::internal::NaturalEventSender<::test_typesinprotocols::Protocol>::EventResource(::test_typesinprotocols::Resource payload) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_EventResource_Ordinal, ::test_typesinprotocols::kProtocol_EventResource_DynamicFlags};
  _encoder.EncodeBody(std::move(payload));
  ::fidl::OutgoingMessage _encoded_message = _encoder.GetMessage();
  _encoded_message.Write(_transport());
  return ::fidl::internal::ToFitxResult(::fidl::OneWayStatus{::fidl::Status{_encoded_message}});
}

#endif  // __Fuchsia__

void fidl::internal::NaturalCompleterBase<::test_typesinprotocols::Protocol::TwoWayBasic>::Reply(const ::fidl::Response<::test_typesinprotocols::Protocol::TwoWayBasic>& response) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_TwoWayBasic_Ordinal, ::test_typesinprotocols::kProtocol_TwoWayBasic_DynamicFlags};
  _encoder.EncodeBody(
      ::fidl::internal::ResponseMessageConverter<::test_typesinprotocols::Protocol::TwoWayBasic>::IntoDomainObject(response));
  ::fidl::OutgoingMessage _encoded_message = _encoder.GetMessage();
  SendReply(&_encoded_message, ::fidl::internal::OutgoingTransportContext{});
}

void fidl::internal::NaturalCompleterBase<::test_typesinprotocols::Protocol::ErrorBasic>::Reply(const ::fidl::Response<::test_typesinprotocols::Protocol::ErrorBasic>& response) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_ErrorBasic_Ordinal, ::test_typesinprotocols::kProtocol_ErrorBasic_DynamicFlags};
  _encoder.EncodeBody(
      ::fidl::internal::ResponseMessageConverter<::test_typesinprotocols::Protocol::ErrorBasic>::IntoDomainObject(response));
  ::fidl::OutgoingMessage _encoded_message = _encoder.GetMessage();
  SendReply(&_encoded_message, ::fidl::internal::OutgoingTransportContext{});
}

void fidl::internal::NaturalCompleterBase<::test_typesinprotocols::Protocol::TwoWayCompound>::Reply(const ::fidl::Response<::test_typesinprotocols::Protocol::TwoWayCompound>& response) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_TwoWayCompound_Ordinal, ::test_typesinprotocols::kProtocol_TwoWayCompound_DynamicFlags};
  _encoder.EncodeBody(
      ::fidl::internal::ResponseMessageConverter<::test_typesinprotocols::Protocol::TwoWayCompound>::IntoDomainObject(response));
  ::fidl::OutgoingMessage _encoded_message = _encoder.GetMessage();
  SendReply(&_encoded_message, ::fidl::internal::OutgoingTransportContext{});
}

void fidl::internal::NaturalCompleterBase<::test_typesinprotocols::Protocol::ErrorCompound>::Reply(const ::fidl::Response<::test_typesinprotocols::Protocol::ErrorCompound>& response) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_ErrorCompound_Ordinal, ::test_typesinprotocols::kProtocol_ErrorCompound_DynamicFlags};
  _encoder.EncodeBody(
      ::fidl::internal::ResponseMessageConverter<::test_typesinprotocols::Protocol::ErrorCompound>::IntoDomainObject(response));
  ::fidl::OutgoingMessage _encoded_message = _encoder.GetMessage();
  SendReply(&_encoded_message, ::fidl::internal::OutgoingTransportContext{});
}

void fidl::internal::NaturalCompleterBase<::test_typesinprotocols::Protocol::TwoWayArrayBasic>::Reply(const ::fidl::Response<::test_typesinprotocols::Protocol::TwoWayArrayBasic>& response) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_TwoWayArrayBasic_Ordinal, ::test_typesinprotocols::kProtocol_TwoWayArrayBasic_DynamicFlags};
  _encoder.EncodeBody(
      ::fidl::internal::ResponseMessageConverter<::test_typesinprotocols::Protocol::TwoWayArrayBasic>::IntoDomainObject(response));
  ::fidl::OutgoingMessage _encoded_message = _encoder.GetMessage();
  SendReply(&_encoded_message, ::fidl::internal::OutgoingTransportContext{});
}

void fidl::internal::NaturalCompleterBase<::test_typesinprotocols::Protocol::ErrorArrayBasic>::Reply(const ::fidl::Response<::test_typesinprotocols::Protocol::ErrorArrayBasic>& response) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_ErrorArrayBasic_Ordinal, ::test_typesinprotocols::kProtocol_ErrorArrayBasic_DynamicFlags};
  _encoder.EncodeBody(
      ::fidl::internal::ResponseMessageConverter<::test_typesinprotocols::Protocol::ErrorArrayBasic>::IntoDomainObject(response));
  ::fidl::OutgoingMessage _encoded_message = _encoder.GetMessage();
  SendReply(&_encoded_message, ::fidl::internal::OutgoingTransportContext{});
}

void fidl::internal::NaturalCompleterBase<::test_typesinprotocols::Protocol::TwoWayArrayCompound>::Reply(const ::fidl::Response<::test_typesinprotocols::Protocol::TwoWayArrayCompound>& response) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_TwoWayArrayCompound_Ordinal, ::test_typesinprotocols::kProtocol_TwoWayArrayCompound_DynamicFlags};
  _encoder.EncodeBody(
      ::fidl::internal::ResponseMessageConverter<::test_typesinprotocols::Protocol::TwoWayArrayCompound>::IntoDomainObject(response));
  ::fidl::OutgoingMessage _encoded_message = _encoder.GetMessage();
  SendReply(&_encoded_message, ::fidl::internal::OutgoingTransportContext{});
}

void fidl::internal::NaturalCompleterBase<::test_typesinprotocols::Protocol::ErrorArrayCompound>::Reply(const ::fidl::Response<::test_typesinprotocols::Protocol::ErrorArrayCompound>& response) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_ErrorArrayCompound_Ordinal, ::test_typesinprotocols::kProtocol_ErrorArrayCompound_DynamicFlags};
  _encoder.EncodeBody(
      ::fidl::internal::ResponseMessageConverter<::test_typesinprotocols::Protocol::ErrorArrayCompound>::IntoDomainObject(response));
  ::fidl::OutgoingMessage _encoded_message = _encoder.GetMessage();
  SendReply(&_encoded_message, ::fidl::internal::OutgoingTransportContext{});
}

void fidl::internal::NaturalCompleterBase<::test_typesinprotocols::Protocol::TwoWayVectorBasic>::Reply(const ::fidl::Response<::test_typesinprotocols::Protocol::TwoWayVectorBasic>& response) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_TwoWayVectorBasic_Ordinal, ::test_typesinprotocols::kProtocol_TwoWayVectorBasic_DynamicFlags};
  _encoder.EncodeBody(
      ::fidl::internal::ResponseMessageConverter<::test_typesinprotocols::Protocol::TwoWayVectorBasic>::IntoDomainObject(response));
  ::fidl::OutgoingMessage _encoded_message = _encoder.GetMessage();
  SendReply(&_encoded_message, ::fidl::internal::OutgoingTransportContext{});
}

void fidl::internal::NaturalCompleterBase<::test_typesinprotocols::Protocol::ErrorVectorBasic>::Reply(const ::fidl::Response<::test_typesinprotocols::Protocol::ErrorVectorBasic>& response) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_ErrorVectorBasic_Ordinal, ::test_typesinprotocols::kProtocol_ErrorVectorBasic_DynamicFlags};
  _encoder.EncodeBody(
      ::fidl::internal::ResponseMessageConverter<::test_typesinprotocols::Protocol::ErrorVectorBasic>::IntoDomainObject(response));
  ::fidl::OutgoingMessage _encoded_message = _encoder.GetMessage();
  SendReply(&_encoded_message, ::fidl::internal::OutgoingTransportContext{});
}

void fidl::internal::NaturalCompleterBase<::test_typesinprotocols::Protocol::TwoWayVectorCompound>::Reply(const ::fidl::Response<::test_typesinprotocols::Protocol::TwoWayVectorCompound>& response) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_TwoWayVectorCompound_Ordinal, ::test_typesinprotocols::kProtocol_TwoWayVectorCompound_DynamicFlags};
  _encoder.EncodeBody(
      ::fidl::internal::ResponseMessageConverter<::test_typesinprotocols::Protocol::TwoWayVectorCompound>::IntoDomainObject(response));
  ::fidl::OutgoingMessage _encoded_message = _encoder.GetMessage();
  SendReply(&_encoded_message, ::fidl::internal::OutgoingTransportContext{});
}

void fidl::internal::NaturalCompleterBase<::test_typesinprotocols::Protocol::ErrorVectorCompound>::Reply(const ::fidl::Response<::test_typesinprotocols::Protocol::ErrorVectorCompound>& response) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_ErrorVectorCompound_Ordinal, ::test_typesinprotocols::kProtocol_ErrorVectorCompound_DynamicFlags};
  _encoder.EncodeBody(
      ::fidl::internal::ResponseMessageConverter<::test_typesinprotocols::Protocol::ErrorVectorCompound>::IntoDomainObject(response));
  ::fidl::OutgoingMessage _encoded_message = _encoder.GetMessage();
  SendReply(&_encoded_message, ::fidl::internal::OutgoingTransportContext{});
}

void fidl::internal::NaturalCompleterBase<::test_typesinprotocols::Protocol::TwoWayVectorOptional>::Reply(const ::fidl::Response<::test_typesinprotocols::Protocol::TwoWayVectorOptional>& response) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_TwoWayVectorOptional_Ordinal, ::test_typesinprotocols::kProtocol_TwoWayVectorOptional_DynamicFlags};
  _encoder.EncodeBody(
      ::fidl::internal::ResponseMessageConverter<::test_typesinprotocols::Protocol::TwoWayVectorOptional>::IntoDomainObject(response));
  ::fidl::OutgoingMessage _encoded_message = _encoder.GetMessage();
  SendReply(&_encoded_message, ::fidl::internal::OutgoingTransportContext{});
}

void fidl::internal::NaturalCompleterBase<::test_typesinprotocols::Protocol::ErrorVectorOptional>::Reply(const ::fidl::Response<::test_typesinprotocols::Protocol::ErrorVectorOptional>& response) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_ErrorVectorOptional_Ordinal, ::test_typesinprotocols::kProtocol_ErrorVectorOptional_DynamicFlags};
  _encoder.EncodeBody(
      ::fidl::internal::ResponseMessageConverter<::test_typesinprotocols::Protocol::ErrorVectorOptional>::IntoDomainObject(response));
  ::fidl::OutgoingMessage _encoded_message = _encoder.GetMessage();
  SendReply(&_encoded_message, ::fidl::internal::OutgoingTransportContext{});
}

void fidl::internal::NaturalCompleterBase<::test_typesinprotocols::Protocol::TwoWayArrayVectorNested>::Reply(const ::fidl::Response<::test_typesinprotocols::Protocol::TwoWayArrayVectorNested>& response) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_TwoWayArrayVectorNested_Ordinal, ::test_typesinprotocols::kProtocol_TwoWayArrayVectorNested_DynamicFlags};
  _encoder.EncodeBody(
      ::fidl::internal::ResponseMessageConverter<::test_typesinprotocols::Protocol::TwoWayArrayVectorNested>::IntoDomainObject(response));
  ::fidl::OutgoingMessage _encoded_message = _encoder.GetMessage();
  SendReply(&_encoded_message, ::fidl::internal::OutgoingTransportContext{});
}

void fidl::internal::NaturalCompleterBase<::test_typesinprotocols::Protocol::ErrorArrayVectorNested>::Reply(const ::fidl::Response<::test_typesinprotocols::Protocol::ErrorArrayVectorNested>& response) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_ErrorArrayVectorNested_Ordinal, ::test_typesinprotocols::kProtocol_ErrorArrayVectorNested_DynamicFlags};
  _encoder.EncodeBody(
      ::fidl::internal::ResponseMessageConverter<::test_typesinprotocols::Protocol::ErrorArrayVectorNested>::IntoDomainObject(response));
  ::fidl::OutgoingMessage _encoded_message = _encoder.GetMessage();
  SendReply(&_encoded_message, ::fidl::internal::OutgoingTransportContext{});
}

void fidl::internal::NaturalCompleterBase<::test_typesinprotocols::Protocol::TwoWayResource>::Reply(::fidl::Response<::test_typesinprotocols::Protocol::TwoWayResource> response) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_TwoWayResource_Ordinal, ::test_typesinprotocols::kProtocol_TwoWayResource_DynamicFlags};
  _encoder.EncodeBody(
      ::fidl::internal::ResponseMessageConverter<::test_typesinprotocols::Protocol::TwoWayResource>::IntoDomainObject(std::move(response)));
  ::fidl::OutgoingMessage _encoded_message = _encoder.GetMessage();
  SendReply(&_encoded_message, ::fidl::internal::OutgoingTransportContext{});
}

void fidl::internal::NaturalCompleterBase<::test_typesinprotocols::Protocol::ErrorResource>::Reply(::fidl::Response<::test_typesinprotocols::Protocol::ErrorResource> response) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::ChannelTransport::VTable, ::test_typesinprotocols::kProtocol_ErrorResource_Ordinal, ::test_typesinprotocols::kProtocol_ErrorResource_DynamicFlags};
  _encoder.EncodeBody(
      ::fidl::internal::ResponseMessageConverter<::test_typesinprotocols::Protocol::ErrorResource>::IntoDomainObject(std::move(response)));
  ::fidl::OutgoingMessage _encoded_message = _encoder.GetMessage();
  SendReply(&_encoded_message, ::fidl::internal::OutgoingTransportContext{});
}

#ifdef __Fuchsia__

constexpr ::fidl::internal::MethodEntry fidl::internal::NaturalServerDispatcher<::test_typesinprotocols::Protocol>::entries_[] = {
    {
        ::test_typesinprotocols::kProtocol_OneWayBasic_Ordinal,
        [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
           internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
          ::fit::result decoded = ::fidl::StandaloneDecode<::test_typesinprotocols::Basic>(
              std::move(msg), metadata);
          if (decoded.is_error()) {
            return decoded.error_value();
          }
          ::fidl::internal::NaturalCompleter<::test_typesinprotocols::Protocol::OneWayBasic>::Sync completer(txn);
          static_cast<::fidl::Server<::test_typesinprotocols::Protocol>*>(interface)->OneWayBasic(
              decoded.value(),
              completer);
          return ::fidl::Status::Ok();
        },
    },
    {
        ::test_typesinprotocols::kProtocol_TwoWayBasic_Ordinal,
        [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
           internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
          ::fit::result decoded = ::fidl::StandaloneDecode<::test_typesinprotocols::Basic>(
              std::move(msg), metadata);
          if (decoded.is_error()) {
            return decoded.error_value();
          }
          ::fidl::internal::NaturalCompleter<::test_typesinprotocols::Protocol::TwoWayBasic>::Sync completer(txn);
          static_cast<::fidl::Server<::test_typesinprotocols::Protocol>*>(interface)->TwoWayBasic(
              decoded.value(),
              completer);
          return ::fidl::Status::Ok();
        },
    },
    {
        ::test_typesinprotocols::kProtocol_ErrorBasic_Ordinal,
        [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
           internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
          ::fit::result decoded = ::fidl::internal::DecodeTransactionalMessageWithoutBody(
              msg, metadata);
          if (decoded.is_error()) {
            return decoded.error_value();
          }
          ::fidl::internal::NaturalCompleter<::test_typesinprotocols::Protocol::ErrorBasic>::Sync completer(txn);
          static_cast<::fidl::Server<::test_typesinprotocols::Protocol>*>(interface)->ErrorBasic(

              completer);
          return ::fidl::Status::Ok();
        },
    },
    {
        ::test_typesinprotocols::kProtocol_OneWayCompound_Ordinal,
        [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
           internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
          ::fit::result decoded = ::fidl::StandaloneDecode<::test_typesinprotocols::Compound>(
              std::move(msg), metadata);
          if (decoded.is_error()) {
            return decoded.error_value();
          }
          ::fidl::internal::NaturalCompleter<::test_typesinprotocols::Protocol::OneWayCompound>::Sync completer(txn);
          static_cast<::fidl::Server<::test_typesinprotocols::Protocol>*>(interface)->OneWayCompound(
              decoded.value(),
              completer);
          return ::fidl::Status::Ok();
        },
    },
    {
        ::test_typesinprotocols::kProtocol_TwoWayCompound_Ordinal,
        [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
           internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
          ::fit::result decoded = ::fidl::StandaloneDecode<::test_typesinprotocols::Compound>(
              std::move(msg), metadata);
          if (decoded.is_error()) {
            return decoded.error_value();
          }
          ::fidl::internal::NaturalCompleter<::test_typesinprotocols::Protocol::TwoWayCompound>::Sync completer(txn);
          static_cast<::fidl::Server<::test_typesinprotocols::Protocol>*>(interface)->TwoWayCompound(
              decoded.value(),
              completer);
          return ::fidl::Status::Ok();
        },
    },
    {
        ::test_typesinprotocols::kProtocol_ErrorCompound_Ordinal,
        [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
           internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
          ::fit::result decoded = ::fidl::internal::DecodeTransactionalMessageWithoutBody(
              msg, metadata);
          if (decoded.is_error()) {
            return decoded.error_value();
          }
          ::fidl::internal::NaturalCompleter<::test_typesinprotocols::Protocol::ErrorCompound>::Sync completer(txn);
          static_cast<::fidl::Server<::test_typesinprotocols::Protocol>*>(interface)->ErrorCompound(

              completer);
          return ::fidl::Status::Ok();
        },
    },
    {
        ::test_typesinprotocols::kProtocol_OneWayArrayBasic_Ordinal,
        [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
           internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
          ::fit::result decoded = ::fidl::StandaloneDecode<::test_typesinprotocols::ArrayBasic>(
              std::move(msg), metadata);
          if (decoded.is_error()) {
            return decoded.error_value();
          }
          ::fidl::internal::NaturalCompleter<::test_typesinprotocols::Protocol::OneWayArrayBasic>::Sync completer(txn);
          static_cast<::fidl::Server<::test_typesinprotocols::Protocol>*>(interface)->OneWayArrayBasic(
              decoded.value(),
              completer);
          return ::fidl::Status::Ok();
        },
    },
    {
        ::test_typesinprotocols::kProtocol_TwoWayArrayBasic_Ordinal,
        [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
           internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
          ::fit::result decoded = ::fidl::StandaloneDecode<::test_typesinprotocols::ArrayBasic>(
              std::move(msg), metadata);
          if (decoded.is_error()) {
            return decoded.error_value();
          }
          ::fidl::internal::NaturalCompleter<::test_typesinprotocols::Protocol::TwoWayArrayBasic>::Sync completer(txn);
          static_cast<::fidl::Server<::test_typesinprotocols::Protocol>*>(interface)->TwoWayArrayBasic(
              decoded.value(),
              completer);
          return ::fidl::Status::Ok();
        },
    },
    {
        ::test_typesinprotocols::kProtocol_ErrorArrayBasic_Ordinal,
        [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
           internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
          ::fit::result decoded = ::fidl::internal::DecodeTransactionalMessageWithoutBody(
              msg, metadata);
          if (decoded.is_error()) {
            return decoded.error_value();
          }
          ::fidl::internal::NaturalCompleter<::test_typesinprotocols::Protocol::ErrorArrayBasic>::Sync completer(txn);
          static_cast<::fidl::Server<::test_typesinprotocols::Protocol>*>(interface)->ErrorArrayBasic(

              completer);
          return ::fidl::Status::Ok();
        },
    },
    {
        ::test_typesinprotocols::kProtocol_OneWayArrayCompound_Ordinal,
        [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
           internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
          ::fit::result decoded = ::fidl::StandaloneDecode<::test_typesinprotocols::ArrayCompound>(
              std::move(msg), metadata);
          if (decoded.is_error()) {
            return decoded.error_value();
          }
          ::fidl::internal::NaturalCompleter<::test_typesinprotocols::Protocol::OneWayArrayCompound>::Sync completer(txn);
          static_cast<::fidl::Server<::test_typesinprotocols::Protocol>*>(interface)->OneWayArrayCompound(
              decoded.value(),
              completer);
          return ::fidl::Status::Ok();
        },
    },
    {
        ::test_typesinprotocols::kProtocol_TwoWayArrayCompound_Ordinal,
        [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
           internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
          ::fit::result decoded = ::fidl::StandaloneDecode<::test_typesinprotocols::ArrayCompound>(
              std::move(msg), metadata);
          if (decoded.is_error()) {
            return decoded.error_value();
          }
          ::fidl::internal::NaturalCompleter<::test_typesinprotocols::Protocol::TwoWayArrayCompound>::Sync completer(txn);
          static_cast<::fidl::Server<::test_typesinprotocols::Protocol>*>(interface)->TwoWayArrayCompound(
              decoded.value(),
              completer);
          return ::fidl::Status::Ok();
        },
    },
    {
        ::test_typesinprotocols::kProtocol_ErrorArrayCompound_Ordinal,
        [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
           internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
          ::fit::result decoded = ::fidl::internal::DecodeTransactionalMessageWithoutBody(
              msg, metadata);
          if (decoded.is_error()) {
            return decoded.error_value();
          }
          ::fidl::internal::NaturalCompleter<::test_typesinprotocols::Protocol::ErrorArrayCompound>::Sync completer(txn);
          static_cast<::fidl::Server<::test_typesinprotocols::Protocol>*>(interface)->ErrorArrayCompound(

              completer);
          return ::fidl::Status::Ok();
        },
    },
    {
        ::test_typesinprotocols::kProtocol_OneWayVectorBasic_Ordinal,
        [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
           internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
          ::fit::result decoded = ::fidl::StandaloneDecode<::test_typesinprotocols::VectorBasic>(
              std::move(msg), metadata);
          if (decoded.is_error()) {
            return decoded.error_value();
          }
          ::fidl::internal::NaturalCompleter<::test_typesinprotocols::Protocol::OneWayVectorBasic>::Sync completer(txn);
          static_cast<::fidl::Server<::test_typesinprotocols::Protocol>*>(interface)->OneWayVectorBasic(
              decoded.value(),
              completer);
          return ::fidl::Status::Ok();
        },
    },
    {
        ::test_typesinprotocols::kProtocol_TwoWayVectorBasic_Ordinal,
        [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
           internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
          ::fit::result decoded = ::fidl::StandaloneDecode<::test_typesinprotocols::VectorBasic>(
              std::move(msg), metadata);
          if (decoded.is_error()) {
            return decoded.error_value();
          }
          ::fidl::internal::NaturalCompleter<::test_typesinprotocols::Protocol::TwoWayVectorBasic>::Sync completer(txn);
          static_cast<::fidl::Server<::test_typesinprotocols::Protocol>*>(interface)->TwoWayVectorBasic(
              decoded.value(),
              completer);
          return ::fidl::Status::Ok();
        },
    },
    {
        ::test_typesinprotocols::kProtocol_ErrorVectorBasic_Ordinal,
        [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
           internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
          ::fit::result decoded = ::fidl::internal::DecodeTransactionalMessageWithoutBody(
              msg, metadata);
          if (decoded.is_error()) {
            return decoded.error_value();
          }
          ::fidl::internal::NaturalCompleter<::test_typesinprotocols::Protocol::ErrorVectorBasic>::Sync completer(txn);
          static_cast<::fidl::Server<::test_typesinprotocols::Protocol>*>(interface)->ErrorVectorBasic(

              completer);
          return ::fidl::Status::Ok();
        },
    },
    {
        ::test_typesinprotocols::kProtocol_OneWayVectorCompound_Ordinal,
        [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
           internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
          ::fit::result decoded = ::fidl::StandaloneDecode<::test_typesinprotocols::VectorCompound>(
              std::move(msg), metadata);
          if (decoded.is_error()) {
            return decoded.error_value();
          }
          ::fidl::internal::NaturalCompleter<::test_typesinprotocols::Protocol::OneWayVectorCompound>::Sync completer(txn);
          static_cast<::fidl::Server<::test_typesinprotocols::Protocol>*>(interface)->OneWayVectorCompound(
              decoded.value(),
              completer);
          return ::fidl::Status::Ok();
        },
    },
    {
        ::test_typesinprotocols::kProtocol_TwoWayVectorCompound_Ordinal,
        [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
           internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
          ::fit::result decoded = ::fidl::StandaloneDecode<::test_typesinprotocols::VectorCompound>(
              std::move(msg), metadata);
          if (decoded.is_error()) {
            return decoded.error_value();
          }
          ::fidl::internal::NaturalCompleter<::test_typesinprotocols::Protocol::TwoWayVectorCompound>::Sync completer(txn);
          static_cast<::fidl::Server<::test_typesinprotocols::Protocol>*>(interface)->TwoWayVectorCompound(
              decoded.value(),
              completer);
          return ::fidl::Status::Ok();
        },
    },
    {
        ::test_typesinprotocols::kProtocol_ErrorVectorCompound_Ordinal,
        [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
           internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
          ::fit::result decoded = ::fidl::internal::DecodeTransactionalMessageWithoutBody(
              msg, metadata);
          if (decoded.is_error()) {
            return decoded.error_value();
          }
          ::fidl::internal::NaturalCompleter<::test_typesinprotocols::Protocol::ErrorVectorCompound>::Sync completer(txn);
          static_cast<::fidl::Server<::test_typesinprotocols::Protocol>*>(interface)->ErrorVectorCompound(

              completer);
          return ::fidl::Status::Ok();
        },
    },
    {
        ::test_typesinprotocols::kProtocol_OneWayVectorOptional_Ordinal,
        [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
           internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
          ::fit::result decoded = ::fidl::StandaloneDecode<::test_typesinprotocols::VectorOptional>(
              std::move(msg), metadata);
          if (decoded.is_error()) {
            return decoded.error_value();
          }
          ::fidl::internal::NaturalCompleter<::test_typesinprotocols::Protocol::OneWayVectorOptional>::Sync completer(txn);
          static_cast<::fidl::Server<::test_typesinprotocols::Protocol>*>(interface)->OneWayVectorOptional(
              decoded.value(),
              completer);
          return ::fidl::Status::Ok();
        },
    },
    {
        ::test_typesinprotocols::kProtocol_TwoWayVectorOptional_Ordinal,
        [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
           internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
          ::fit::result decoded = ::fidl::StandaloneDecode<::test_typesinprotocols::VectorOptional>(
              std::move(msg), metadata);
          if (decoded.is_error()) {
            return decoded.error_value();
          }
          ::fidl::internal::NaturalCompleter<::test_typesinprotocols::Protocol::TwoWayVectorOptional>::Sync completer(txn);
          static_cast<::fidl::Server<::test_typesinprotocols::Protocol>*>(interface)->TwoWayVectorOptional(
              decoded.value(),
              completer);
          return ::fidl::Status::Ok();
        },
    },
    {
        ::test_typesinprotocols::kProtocol_ErrorVectorOptional_Ordinal,
        [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
           internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
          ::fit::result decoded = ::fidl::internal::DecodeTransactionalMessageWithoutBody(
              msg, metadata);
          if (decoded.is_error()) {
            return decoded.error_value();
          }
          ::fidl::internal::NaturalCompleter<::test_typesinprotocols::Protocol::ErrorVectorOptional>::Sync completer(txn);
          static_cast<::fidl::Server<::test_typesinprotocols::Protocol>*>(interface)->ErrorVectorOptional(

              completer);
          return ::fidl::Status::Ok();
        },
    },
    {
        ::test_typesinprotocols::kProtocol_OneWayArrayVectorNested_Ordinal,
        [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
           internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
          ::fit::result decoded = ::fidl::StandaloneDecode<::test_typesinprotocols::ArrayVectorNested>(
              std::move(msg), metadata);
          if (decoded.is_error()) {
            return decoded.error_value();
          }
          ::fidl::internal::NaturalCompleter<::test_typesinprotocols::Protocol::OneWayArrayVectorNested>::Sync completer(txn);
          static_cast<::fidl::Server<::test_typesinprotocols::Protocol>*>(interface)->OneWayArrayVectorNested(
              decoded.value(),
              completer);
          return ::fidl::Status::Ok();
        },
    },
    {
        ::test_typesinprotocols::kProtocol_TwoWayArrayVectorNested_Ordinal,
        [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
           internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
          ::fit::result decoded = ::fidl::StandaloneDecode<::test_typesinprotocols::ArrayVectorNested>(
              std::move(msg), metadata);
          if (decoded.is_error()) {
            return decoded.error_value();
          }
          ::fidl::internal::NaturalCompleter<::test_typesinprotocols::Protocol::TwoWayArrayVectorNested>::Sync completer(txn);
          static_cast<::fidl::Server<::test_typesinprotocols::Protocol>*>(interface)->TwoWayArrayVectorNested(
              decoded.value(),
              completer);
          return ::fidl::Status::Ok();
        },
    },
    {
        ::test_typesinprotocols::kProtocol_ErrorArrayVectorNested_Ordinal,
        [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
           internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
          ::fit::result decoded = ::fidl::internal::DecodeTransactionalMessageWithoutBody(
              msg, metadata);
          if (decoded.is_error()) {
            return decoded.error_value();
          }
          ::fidl::internal::NaturalCompleter<::test_typesinprotocols::Protocol::ErrorArrayVectorNested>::Sync completer(txn);
          static_cast<::fidl::Server<::test_typesinprotocols::Protocol>*>(interface)->ErrorArrayVectorNested(

              completer);
          return ::fidl::Status::Ok();
        },
    },
    {
        ::test_typesinprotocols::kProtocol_OneWayResource_Ordinal,
        [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
           internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
          ::fit::result decoded = ::fidl::StandaloneDecode<::test_typesinprotocols::Resource>(
              std::move(msg), metadata);
          if (decoded.is_error()) {
            return decoded.error_value();
          }
          ::fidl::internal::NaturalCompleter<::test_typesinprotocols::Protocol::OneWayResource>::Sync completer(txn);
          static_cast<::fidl::Server<::test_typesinprotocols::Protocol>*>(interface)->OneWayResource(
              decoded.value(),
              completer);
          return ::fidl::Status::Ok();
        },
    },
    {
        ::test_typesinprotocols::kProtocol_TwoWayResource_Ordinal,
        [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
           internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
          ::fit::result decoded = ::fidl::StandaloneDecode<::test_typesinprotocols::Resource>(
              std::move(msg), metadata);
          if (decoded.is_error()) {
            return decoded.error_value();
          }
          ::fidl::internal::NaturalCompleter<::test_typesinprotocols::Protocol::TwoWayResource>::Sync completer(txn);
          static_cast<::fidl::Server<::test_typesinprotocols::Protocol>*>(interface)->TwoWayResource(
              decoded.value(),
              completer);
          return ::fidl::Status::Ok();
        },
    },
    {
        ::test_typesinprotocols::kProtocol_ErrorResource_Ordinal,
        [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
           internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
          ::fit::result decoded = ::fidl::internal::DecodeTransactionalMessageWithoutBody(
              msg, metadata);
          if (decoded.is_error()) {
            return decoded.error_value();
          }
          ::fidl::internal::NaturalCompleter<::test_typesinprotocols::Protocol::ErrorResource>::Sync completer(txn);
          static_cast<::fidl::Server<::test_typesinprotocols::Protocol>*>(interface)->ErrorResource(

              completer);
          return ::fidl::Status::Ok();
        },
    },
};

const ::fidl::internal::MethodEntry* fidl::internal::NaturalServerDispatcher<::test_typesinprotocols::Protocol>::entries_end_ =
    &entries_[27];

void fidl::internal::NaturalServerDispatcher<::test_typesinprotocols::Protocol>::Dispatch(::fidl::Server<::test_typesinprotocols::Protocol>* impl, ::fidl::IncomingHeaderAndMessage&& msg,
                                                                                          internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
  ::fidl::internal::Dispatch(impl, msg, storage_view, txn, entries_, entries_end_, &unknown_method_handler_entry_);
}

void fidl::Server<::test_typesinprotocols::Protocol>::dispatch_message(
    ::fidl::IncomingHeaderAndMessage&& msg, ::fidl::Transaction* txn,
    ::fidl::internal::MessageStorageViewBase* storage_view) {
  ::fidl::internal::NaturalServerDispatcher<::test_typesinprotocols::Protocol>::Dispatch(this, std::move(msg), storage_view, txn);
}

#endif  // __Fuchsia__

#pragma clang diagnostic pop