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

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

// fidl_experiment = output_index_json

#include <fidl/test.protocollayoutssamelibrary/cpp/wire_messaging.h>

#include <memory>

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


  

namespace test_protocollayoutssamelibrary {

[[maybe_unused]]
constexpr uint64_t kComposedProtocol_OneWayAnonComposed_Ordinal = 7960710870216447007lu;


[[maybe_unused]]
constexpr ::fidl::MessageDynamicFlags kComposedProtocol_OneWayAnonComposed_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;


[[maybe_unused]]
constexpr uint64_t kComposedProtocol_TwoWayAnonComposed_Ordinal = 8107448265006659060lu;


[[maybe_unused]]
constexpr ::fidl::MessageDynamicFlags kComposedProtocol_TwoWayAnonComposed_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;


[[maybe_unused]]
constexpr uint64_t kComposedProtocol_TwoWayAnonComposedWithError_Ordinal = 5751989932125743144lu;


[[maybe_unused]]
constexpr ::fidl::MessageDynamicFlags kComposedProtocol_TwoWayAnonComposedWithError_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;


[[maybe_unused]]
constexpr uint64_t kComposedProtocol_OnAnonComposed_Ordinal = 5307191872315199016lu;


[[maybe_unused]]
constexpr ::fidl::MessageDynamicFlags kComposedProtocol_OnAnonComposed_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;


[[maybe_unused]]
constexpr uint64_t kComposedProtocol_OneWayNamedComposed_Ordinal = 1159174053475281336lu;


[[maybe_unused]]
constexpr ::fidl::MessageDynamicFlags kComposedProtocol_OneWayNamedComposed_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;


[[maybe_unused]]
constexpr uint64_t kComposedProtocol_TwoWayNamedComposed_Ordinal = 5022872388073111636lu;


[[maybe_unused]]
constexpr ::fidl::MessageDynamicFlags kComposedProtocol_TwoWayNamedComposed_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;


[[maybe_unused]]
constexpr uint64_t kComposedProtocol_TwoWayNamedComposedWithError_Ordinal = 4973436213756973807lu;


[[maybe_unused]]
constexpr ::fidl::MessageDynamicFlags kComposedProtocol_TwoWayNamedComposedWithError_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;


[[maybe_unused]]
constexpr uint64_t kComposedProtocol_OnNamedComposed_Ordinal = 1712755118419701115lu;


[[maybe_unused]]
constexpr ::fidl::MessageDynamicFlags kComposedProtocol_OnNamedComposed_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;
#ifdef __Fuchsia__
}  // namespace test_protocollayoutssamelibrary

::fidl::WireResult<::test_protocollayoutssamelibrary::ComposedProtocol::OneWayAnonComposed>::WireResult(
    ::fidl::UnownedClientEnd<::test_protocollayoutssamelibrary::ComposedProtocol> client,
    ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::ComposedProtocol::OneWayAnonComposed>* request
) {
  FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::ComposedProtocol::OneWayAnonComposed>, ::fidl::internal::ChannelTransport> request_message(
      ::fidl::internal::AllowUnownedInputRef{}, request);
  auto& outgoing = request_message.GetOutgoingMessage();
    outgoing.Write(client.handle());
    SetStatus(outgoing);
}namespace test_protocollayoutssamelibrary {

#endif  // __Fuchsia__


#ifdef __Fuchsia__
}  // namespace test_protocollayoutssamelibrary

::fidl::WireUnownedResult<::test_protocollayoutssamelibrary::ComposedProtocol::OneWayAnonComposed>::WireUnownedResult(::fidl::UnownedClientEnd<::test_protocollayoutssamelibrary::ComposedProtocol> client_end, ::fidl::internal::AnyBufferAllocator& allocator, ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::ComposedProtocol::OneWayAnonComposed>* request) {
  constexpr uint32_t buffer_size = ::fidl::SyncClientMethodBufferSizeInChannel<::test_protocollayoutssamelibrary::ComposedProtocol::OneWayAnonComposed>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> allocation = allocator.TryAllocate(buffer_size);
  if (!allocation.is_ok()) {
    SetStatus(allocation.error_value());
    return;
  }
  uint8_t* buffer = allocation->data;
    uint32_t request_byte_capacity = buffer_size;
    uint8_t* request_bytes = buffer;

  ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::ComposedProtocol::OneWayAnonComposed>> request_message(
      request_bytes, request_byte_capacity, request);
  auto& outgoing = request_message.GetOutgoingMessage();
    outgoing.Write(client_end.handle());
    SetStatus(outgoing);
}namespace test_protocollayoutssamelibrary {

#endif  // __Fuchsia__


#ifdef __Fuchsia__
}  // namespace test_protocollayoutssamelibrary

::fidl::WireResult<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposed>::WireResult(
    ::fidl::UnownedClientEnd<::test_protocollayoutssamelibrary::ComposedProtocol> client,
    ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposed>* request
) {
  FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposed>, ::fidl::internal::ChannelTransport> request_message(
      ::fidl::internal::AllowUnownedInputRef{}, request);
  auto& outgoing = request_message.GetOutgoingMessage();
    ::fidl::internal::IncomingMessageHandleStorage<::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposed>> handle_storage;
    ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalResponse<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposed>(
        outgoing.Call(client.handle(), handle_storage.view(bytes_.view()), fidl::CallOptions{})
    );
    SetStatus(::fidl::internal::StatusFromResult(decoded));
      if (ok()) {
        decoded_ = std::move(decoded.value());
        ExtractValueFromDecoded(decoded_.pointer());
      }
}namespace test_protocollayoutssamelibrary {

#endif  // __Fuchsia__


#ifdef __Fuchsia__
}  // namespace test_protocollayoutssamelibrary

::fidl::WireUnownedResult<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposed>::WireUnownedResult(::fidl::UnownedClientEnd<::test_protocollayoutssamelibrary::ComposedProtocol> client_end, ::fidl::internal::AnyBufferAllocator& allocator, ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposed>* request) {
  constexpr uint32_t buffer_size = ::fidl::SyncClientMethodBufferSizeInChannel<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposed>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> allocation = allocator.TryAllocate(buffer_size);
  if (!allocation.is_ok()) {
    SetStatus(allocation.error_value());
    return;
  }
  uint8_t* buffer = allocation->data;constexpr uint32_t request_byte_capacity = ::fidl::MaxSizeInChannel<
        ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposed>, ::fidl::MessageDirection::kSending>();
    uint8_t* request_bytes = buffer;
    static_assert(buffer_size > request_byte_capacity);
    uint32_t response_byte_capacity = buffer_size - request_byte_capacity;
    uint8_t* response_bytes = &buffer[request_byte_capacity];

  ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposed>> request_message(
      request_bytes, request_byte_capacity, request);
  auto& outgoing = request_message.GetOutgoingMessage();
    ::fidl::internal::IncomingMessageHandleStorage<::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposed>> handle_storage;
    ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalResponse<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposed>(
        outgoing.Call(
            client_end.handle(),
            handle_storage.view(fidl::BufferSpan(response_bytes, response_byte_capacity))
        )
    );
    SetStatus(::fidl::internal::StatusFromResult(decoded));
      if (ok()) {
        decoded_ = std::move(decoded.value());
        ExtractValueFromDecoded(decoded_.pointer());
      }
}namespace test_protocollayoutssamelibrary {

#endif  // __Fuchsia__


#ifdef __Fuchsia__
}  // namespace test_protocollayoutssamelibrary

::fidl::WireResult<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposedWithError>::WireResult(
    ::fidl::UnownedClientEnd<::test_protocollayoutssamelibrary::ComposedProtocol> client,
    ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposedWithError>* request
) {
  FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposedWithError>, ::fidl::internal::ChannelTransport> request_message(
      ::fidl::internal::AllowUnownedInputRef{}, request);
  auto& outgoing = request_message.GetOutgoingMessage();
    ::fidl::internal::IncomingMessageHandleStorage<::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposedWithError>> handle_storage;
    ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalResponse<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposedWithError>(
        outgoing.Call(client.handle(), handle_storage.view(bytes_.view()), fidl::CallOptions{})
    );
    SetStatus(::fidl::internal::StatusFromResult(decoded));
      if (ok()) {
        decoded_ = std::move(decoded.value());
        ExtractValueFromDecoded(decoded_.pointer());
      }
}namespace test_protocollayoutssamelibrary {

#endif  // __Fuchsia__


#ifdef __Fuchsia__
}  // namespace test_protocollayoutssamelibrary

::fidl::WireUnownedResult<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposedWithError>::WireUnownedResult(::fidl::UnownedClientEnd<::test_protocollayoutssamelibrary::ComposedProtocol> client_end, ::fidl::internal::AnyBufferAllocator& allocator, ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposedWithError>* request) {
  constexpr uint32_t buffer_size = ::fidl::SyncClientMethodBufferSizeInChannel<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposedWithError>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> allocation = allocator.TryAllocate(buffer_size);
  if (!allocation.is_ok()) {
    SetStatus(allocation.error_value());
    return;
  }
  uint8_t* buffer = allocation->data;constexpr uint32_t request_byte_capacity = ::fidl::MaxSizeInChannel<
        ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposedWithError>, ::fidl::MessageDirection::kSending>();
    uint8_t* request_bytes = buffer;
    static_assert(buffer_size > request_byte_capacity);
    uint32_t response_byte_capacity = buffer_size - request_byte_capacity;
    uint8_t* response_bytes = &buffer[request_byte_capacity];

  ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposedWithError>> request_message(
      request_bytes, request_byte_capacity, request);
  auto& outgoing = request_message.GetOutgoingMessage();
    ::fidl::internal::IncomingMessageHandleStorage<::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposedWithError>> handle_storage;
    ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalResponse<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposedWithError>(
        outgoing.Call(
            client_end.handle(),
            handle_storage.view(fidl::BufferSpan(response_bytes, response_byte_capacity))
        )
    );
    SetStatus(::fidl::internal::StatusFromResult(decoded));
      if (ok()) {
        decoded_ = std::move(decoded.value());
        ExtractValueFromDecoded(decoded_.pointer());
      }
}namespace test_protocollayoutssamelibrary {

#endif  // __Fuchsia__


#ifdef __Fuchsia__
}  // namespace test_protocollayoutssamelibrary

::fidl::WireResult<::test_protocollayoutssamelibrary::ComposedProtocol::OneWayNamedComposed>::WireResult(
    ::fidl::UnownedClientEnd<::test_protocollayoutssamelibrary::ComposedProtocol> client,
    ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::ComposedProtocol::OneWayNamedComposed>* request
) {
  FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::ComposedProtocol::OneWayNamedComposed>, ::fidl::internal::ChannelTransport> request_message(
      ::fidl::internal::AllowUnownedInputRef{}, request);
  auto& outgoing = request_message.GetOutgoingMessage();
    outgoing.Write(client.handle());
    SetStatus(outgoing);
}namespace test_protocollayoutssamelibrary {

#endif  // __Fuchsia__


#ifdef __Fuchsia__
}  // namespace test_protocollayoutssamelibrary

::fidl::WireUnownedResult<::test_protocollayoutssamelibrary::ComposedProtocol::OneWayNamedComposed>::WireUnownedResult(::fidl::UnownedClientEnd<::test_protocollayoutssamelibrary::ComposedProtocol> client_end, ::fidl::internal::AnyBufferAllocator& allocator, ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::ComposedProtocol::OneWayNamedComposed>* request) {
  constexpr uint32_t buffer_size = ::fidl::SyncClientMethodBufferSizeInChannel<::test_protocollayoutssamelibrary::ComposedProtocol::OneWayNamedComposed>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> allocation = allocator.TryAllocate(buffer_size);
  if (!allocation.is_ok()) {
    SetStatus(allocation.error_value());
    return;
  }
  uint8_t* buffer = allocation->data;
    uint32_t request_byte_capacity = buffer_size;
    uint8_t* request_bytes = buffer;

  ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::ComposedProtocol::OneWayNamedComposed>> request_message(
      request_bytes, request_byte_capacity, request);
  auto& outgoing = request_message.GetOutgoingMessage();
    outgoing.Write(client_end.handle());
    SetStatus(outgoing);
}namespace test_protocollayoutssamelibrary {

#endif  // __Fuchsia__


#ifdef __Fuchsia__
}  // namespace test_protocollayoutssamelibrary

::fidl::WireResult<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposed>::WireResult(
    ::fidl::UnownedClientEnd<::test_protocollayoutssamelibrary::ComposedProtocol> client,
    ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposed>* request
) {
  FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposed>, ::fidl::internal::ChannelTransport> request_message(
      ::fidl::internal::AllowUnownedInputRef{}, request);
  auto& outgoing = request_message.GetOutgoingMessage();
    ::fidl::internal::IncomingMessageHandleStorage<::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposed>> handle_storage;
    ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalResponse<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposed>(
        outgoing.Call(client.handle(), handle_storage.view(bytes_.view()), fidl::CallOptions{})
    );
    SetStatus(::fidl::internal::StatusFromResult(decoded));
      if (ok()) {
        decoded_ = std::move(decoded.value());
        ExtractValueFromDecoded(decoded_.pointer());
      }
}namespace test_protocollayoutssamelibrary {

#endif  // __Fuchsia__


#ifdef __Fuchsia__
}  // namespace test_protocollayoutssamelibrary

::fidl::WireUnownedResult<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposed>::WireUnownedResult(::fidl::UnownedClientEnd<::test_protocollayoutssamelibrary::ComposedProtocol> client_end, ::fidl::internal::AnyBufferAllocator& allocator, ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposed>* request) {
  constexpr uint32_t buffer_size = ::fidl::SyncClientMethodBufferSizeInChannel<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposed>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> allocation = allocator.TryAllocate(buffer_size);
  if (!allocation.is_ok()) {
    SetStatus(allocation.error_value());
    return;
  }
  uint8_t* buffer = allocation->data;constexpr uint32_t request_byte_capacity = ::fidl::MaxSizeInChannel<
        ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposed>, ::fidl::MessageDirection::kSending>();
    uint8_t* request_bytes = buffer;
    static_assert(buffer_size > request_byte_capacity);
    uint32_t response_byte_capacity = buffer_size - request_byte_capacity;
    uint8_t* response_bytes = &buffer[request_byte_capacity];

  ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposed>> request_message(
      request_bytes, request_byte_capacity, request);
  auto& outgoing = request_message.GetOutgoingMessage();
    ::fidl::internal::IncomingMessageHandleStorage<::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposed>> handle_storage;
    ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalResponse<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposed>(
        outgoing.Call(
            client_end.handle(),
            handle_storage.view(fidl::BufferSpan(response_bytes, response_byte_capacity))
        )
    );
    SetStatus(::fidl::internal::StatusFromResult(decoded));
      if (ok()) {
        decoded_ = std::move(decoded.value());
        ExtractValueFromDecoded(decoded_.pointer());
      }
}namespace test_protocollayoutssamelibrary {

#endif  // __Fuchsia__


#ifdef __Fuchsia__
}  // namespace test_protocollayoutssamelibrary

::fidl::WireResult<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposedWithError>::WireResult(
    ::fidl::UnownedClientEnd<::test_protocollayoutssamelibrary::ComposedProtocol> client,
    ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposedWithError>* request
) {
  FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposedWithError>, ::fidl::internal::ChannelTransport> request_message(
      ::fidl::internal::AllowUnownedInputRef{}, request);
  auto& outgoing = request_message.GetOutgoingMessage();
    ::fidl::internal::IncomingMessageHandleStorage<::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposedWithError>> handle_storage;
    ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalResponse<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposedWithError>(
        outgoing.Call(client.handle(), handle_storage.view(bytes_.view()), fidl::CallOptions{})
    );
    SetStatus(::fidl::internal::StatusFromResult(decoded));
      if (ok()) {
        decoded_ = std::move(decoded.value());
        ExtractValueFromDecoded(decoded_.pointer());
      }
}namespace test_protocollayoutssamelibrary {

#endif  // __Fuchsia__


#ifdef __Fuchsia__
}  // namespace test_protocollayoutssamelibrary

::fidl::WireUnownedResult<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposedWithError>::WireUnownedResult(::fidl::UnownedClientEnd<::test_protocollayoutssamelibrary::ComposedProtocol> client_end, ::fidl::internal::AnyBufferAllocator& allocator, ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposedWithError>* request) {
  constexpr uint32_t buffer_size = ::fidl::SyncClientMethodBufferSizeInChannel<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposedWithError>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> allocation = allocator.TryAllocate(buffer_size);
  if (!allocation.is_ok()) {
    SetStatus(allocation.error_value());
    return;
  }
  uint8_t* buffer = allocation->data;constexpr uint32_t request_byte_capacity = ::fidl::MaxSizeInChannel<
        ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposedWithError>, ::fidl::MessageDirection::kSending>();
    uint8_t* request_bytes = buffer;
    static_assert(buffer_size > request_byte_capacity);
    uint32_t response_byte_capacity = buffer_size - request_byte_capacity;
    uint8_t* response_bytes = &buffer[request_byte_capacity];

  ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposedWithError>> request_message(
      request_bytes, request_byte_capacity, request);
  auto& outgoing = request_message.GetOutgoingMessage();
    ::fidl::internal::IncomingMessageHandleStorage<::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposedWithError>> handle_storage;
    ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalResponse<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposedWithError>(
        outgoing.Call(
            client_end.handle(),
            handle_storage.view(fidl::BufferSpan(response_bytes, response_byte_capacity))
        )
    );
    SetStatus(::fidl::internal::StatusFromResult(decoded));
      if (ok()) {
        decoded_ = std::move(decoded.value());
        ExtractValueFromDecoded(decoded_.pointer());
      }
}namespace test_protocollayoutssamelibrary {

#endif  // __Fuchsia__



  }  // namespace test_protocollayoutssamelibrary

#ifdef __Fuchsia__

  ::fidl::OneWayStatus fidl::internal::WireWeakOnewayClientImpl<::test_protocollayoutssamelibrary::ComposedProtocol>::OneWayAnonComposed(::test_protocollayoutssamelibrary::wire::ComposedProtocolOneWayAnonComposedRequest ComposedProtocolOneWayAnonComposedRequest) {
    FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT
    ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::ComposedProtocol::OneWayAnonComposed> _request_object{ ComposedProtocolOneWayAnonComposedRequest };
    ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::ComposedProtocol::OneWayAnonComposed>, ::fidl::internal::ChannelTransport> _request_message(
        ::fidl::internal::AllowUnownedInputRef{}, &_request_object);
    return _client_base()->SendOneWay(_request_message.GetOutgoingMessage());
  }
  ::fidl::OneWayStatus fidl::internal::WireWeakOnewayClientImpl<::test_protocollayoutssamelibrary::ComposedProtocol>::OneWayNamedComposed(::test_protocollayoutssamelibrary::wire::TablePayload TablePayload) {
    FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT
    ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::ComposedProtocol::OneWayNamedComposed> _request_object{ TablePayload };
    ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::ComposedProtocol::OneWayNamedComposed>, ::fidl::internal::ChannelTransport> _request_message(
        ::fidl::internal::AllowUnownedInputRef{}, &_request_object);
    return _client_base()->SendOneWay(_request_message.GetOutgoingMessage());
  }

  ::fidl::internal::WireThenable<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposed> fidl::internal::WireWeakAsyncClientImpl<::test_protocollayoutssamelibrary::ComposedProtocol>::TwoWayAnonComposed(::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayAnonComposedRequest ComposedProtocolTwoWayAnonComposedRequest) {
    ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposed> _request{ ComposedProtocolTwoWayAnonComposedRequest };
    return ::fidl::internal::WireThenable<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposed>{
        _client_base(), ::fidl::WriteOptions{}, ::fidl::internal::AllowUnownedInputRef{}, &_request};
  }

  ::fidl::internal::WireThenable<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposedWithError> fidl::internal::WireWeakAsyncClientImpl<::test_protocollayoutssamelibrary::ComposedProtocol>::TwoWayAnonComposedWithError(::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayAnonComposedWithErrorRequest ComposedProtocolTwoWayAnonComposedWithErrorRequest) {
    ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposedWithError> _request{ ComposedProtocolTwoWayAnonComposedWithErrorRequest };
    return ::fidl::internal::WireThenable<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposedWithError>{
        _client_base(), ::fidl::WriteOptions{}, ::fidl::internal::AllowUnownedInputRef{}, &_request};
  }

  ::fidl::internal::WireThenable<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposed> fidl::internal::WireWeakAsyncClientImpl<::test_protocollayoutssamelibrary::ComposedProtocol>::TwoWayNamedComposed(::test_protocollayoutssamelibrary::wire::UnionPayload UnionPayload) {
    ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposed> _request{ UnionPayload };
    return ::fidl::internal::WireThenable<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposed>{
        _client_base(), ::fidl::WriteOptions{}, ::fidl::internal::AllowUnownedInputRef{}, &_request};
  }

  ::fidl::internal::WireThenable<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposedWithError> fidl::internal::WireWeakAsyncClientImpl<::test_protocollayoutssamelibrary::ComposedProtocol>::TwoWayNamedComposedWithError(::test_protocollayoutssamelibrary::wire::TablePayload TablePayload) {
    ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposedWithError> _request{ TablePayload };
    return ::fidl::internal::WireThenable<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposedWithError>{
        _client_base(), ::fidl::WriteOptions{}, ::fidl::internal::AllowUnownedInputRef{}, &_request};
  }
::fidl::OneWayStatus fidl::internal::WireWeakOnewayBufferClientImpl<::test_protocollayoutssamelibrary::ComposedProtocol>::OneWayAnonComposed(::test_protocollayoutssamelibrary::wire::ComposedProtocolOneWayAnonComposedRequest ComposedProtocolOneWayAnonComposedRequest) {
  constexpr uint32_t _buffer_size = ::fidl::AsyncClientMethodBufferSizeInChannel<::test_protocollayoutssamelibrary::ComposedProtocol::OneWayAnonComposed>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    return ::fidl::OneWayStatus{_allocation.error_value()};
  }

  ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::ComposedProtocol::OneWayAnonComposed> _request{ ComposedProtocolOneWayAnonComposedRequest };
  ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::ComposedProtocol::OneWayAnonComposed>> _request_message(
      _allocation->data, _buffer_size, &_request);
  return _client_base()->SendOneWay(_request_message.GetOutgoingMessage());
}
::fidl::OneWayStatus fidl::internal::WireWeakOnewayBufferClientImpl<::test_protocollayoutssamelibrary::ComposedProtocol>::OneWayNamedComposed(::test_protocollayoutssamelibrary::wire::TablePayload TablePayload) {
  constexpr uint32_t _buffer_size = ::fidl::AsyncClientMethodBufferSizeInChannel<::test_protocollayoutssamelibrary::ComposedProtocol::OneWayNamedComposed>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    return ::fidl::OneWayStatus{_allocation.error_value()};
  }

  ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::ComposedProtocol::OneWayNamedComposed> _request{ TablePayload };
  ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::ComposedProtocol::OneWayNamedComposed>> _request_message(
      _allocation->data, _buffer_size, &_request);
  return _client_base()->SendOneWay(_request_message.GetOutgoingMessage());
}
::fidl::internal::WireBufferThenable<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposed> fidl::internal::WireWeakAsyncBufferClientImpl<::test_protocollayoutssamelibrary::ComposedProtocol>::TwoWayAnonComposed(::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayAnonComposedRequest ComposedProtocolTwoWayAnonComposedRequest) {
  constexpr uint32_t _buffer_size = ::fidl::AsyncClientMethodBufferSizeInChannel<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposed>();
  ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposed> _request{ ComposedProtocolTwoWayAnonComposedRequest };
  return ::fidl::internal::WireBufferThenable<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposed>{
      _client_base(), ::fidl::WriteOptions{}, _allocator(), _buffer_size, &_request};
}
::fidl::internal::WireBufferThenable<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposedWithError> fidl::internal::WireWeakAsyncBufferClientImpl<::test_protocollayoutssamelibrary::ComposedProtocol>::TwoWayAnonComposedWithError(::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayAnonComposedWithErrorRequest ComposedProtocolTwoWayAnonComposedWithErrorRequest) {
  constexpr uint32_t _buffer_size = ::fidl::AsyncClientMethodBufferSizeInChannel<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposedWithError>();
  ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposedWithError> _request{ ComposedProtocolTwoWayAnonComposedWithErrorRequest };
  return ::fidl::internal::WireBufferThenable<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposedWithError>{
      _client_base(), ::fidl::WriteOptions{}, _allocator(), _buffer_size, &_request};
}
::fidl::internal::WireBufferThenable<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposed> fidl::internal::WireWeakAsyncBufferClientImpl<::test_protocollayoutssamelibrary::ComposedProtocol>::TwoWayNamedComposed(::test_protocollayoutssamelibrary::wire::UnionPayload UnionPayload) {
  constexpr uint32_t _buffer_size = ::fidl::AsyncClientMethodBufferSizeInChannel<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposed>();
  ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposed> _request{ UnionPayload };
  return ::fidl::internal::WireBufferThenable<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposed>{
      _client_base(), ::fidl::WriteOptions{}, _allocator(), _buffer_size, &_request};
}
::fidl::internal::WireBufferThenable<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposedWithError> fidl::internal::WireWeakAsyncBufferClientImpl<::test_protocollayoutssamelibrary::ComposedProtocol>::TwoWayNamedComposedWithError(::test_protocollayoutssamelibrary::wire::TablePayload TablePayload) {
  constexpr uint32_t _buffer_size = ::fidl::AsyncClientMethodBufferSizeInChannel<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposedWithError>();
  ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposedWithError> _request{ TablePayload };
  return ::fidl::internal::WireBufferThenable<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposedWithError>{
      _client_base(), ::fidl::WriteOptions{}, _allocator(), _buffer_size, &_request};
}
  


  ::fidl::WireResult<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposed>
  fidl::internal::WireWeakSyncClientImpl<::test_protocollayoutssamelibrary::ComposedProtocol>::TwoWayAnonComposed(::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayAnonComposedRequest ComposedProtocolTwoWayAnonComposedRequest) {
    return _client_base()->MakeSyncCallWith(
        [&] (std::shared_ptr<::fidl::internal::AnyTransport> _transport) {
          ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposed> _request{ ComposedProtocolTwoWayAnonComposedRequest };
          return ::fidl::WireResult<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposed>(::fidl::UnownedClientEnd<::test_protocollayoutssamelibrary::ComposedProtocol>(_transport->get<::fidl::internal::ChannelTransport>()), &_request);
        });
  }
  


  ::fidl::WireResult<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposedWithError>
  fidl::internal::WireWeakSyncClientImpl<::test_protocollayoutssamelibrary::ComposedProtocol>::TwoWayAnonComposedWithError(::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayAnonComposedWithErrorRequest ComposedProtocolTwoWayAnonComposedWithErrorRequest) {
    return _client_base()->MakeSyncCallWith(
        [&] (std::shared_ptr<::fidl::internal::AnyTransport> _transport) {
          ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposedWithError> _request{ ComposedProtocolTwoWayAnonComposedWithErrorRequest };
          return ::fidl::WireResult<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposedWithError>(::fidl::UnownedClientEnd<::test_protocollayoutssamelibrary::ComposedProtocol>(_transport->get<::fidl::internal::ChannelTransport>()), &_request);
        });
  }
  


  ::fidl::WireResult<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposed>
  fidl::internal::WireWeakSyncClientImpl<::test_protocollayoutssamelibrary::ComposedProtocol>::TwoWayNamedComposed(::test_protocollayoutssamelibrary::wire::UnionPayload UnionPayload) {
    return _client_base()->MakeSyncCallWith(
        [&] (std::shared_ptr<::fidl::internal::AnyTransport> _transport) {
          ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposed> _request{ UnionPayload };
          return ::fidl::WireResult<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposed>(::fidl::UnownedClientEnd<::test_protocollayoutssamelibrary::ComposedProtocol>(_transport->get<::fidl::internal::ChannelTransport>()), &_request);
        });
  }
  


  ::fidl::WireResult<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposedWithError>
  fidl::internal::WireWeakSyncClientImpl<::test_protocollayoutssamelibrary::ComposedProtocol>::TwoWayNamedComposedWithError(::test_protocollayoutssamelibrary::wire::TablePayload TablePayload) {
    return _client_base()->MakeSyncCallWith(
        [&] (std::shared_ptr<::fidl::internal::AnyTransport> _transport) {
          ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposedWithError> _request{ TablePayload };
          return ::fidl::WireResult<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposedWithError>(::fidl::UnownedClientEnd<::test_protocollayoutssamelibrary::ComposedProtocol>(_transport->get<::fidl::internal::ChannelTransport>()), &_request);
        });
  }

#endif  // __Fuchsia__





#ifdef __Fuchsia__



  ::fidl::Status fidl::WireSyncEventHandler<::test_protocollayoutssamelibrary::ComposedProtocol>::HandleOneEvent(
      ::fidl::UnownedClientEnd<::test_protocollayoutssamelibrary::ComposedProtocol> client_end) {
      ::fidl::internal::IncomingEventsStorage<::test_protocollayoutssamelibrary::ComposedProtocol> event_storage;
      fidl::internal::WireEventDispatcher<::test_protocollayoutssamelibrary::ComposedProtocol> dispatcher{this};
      return HandleOneEventImpl_(client_end.channel(), event_storage.view(), dispatcher);
  }
  ::fidl::Status
  fidl::internal::WireEventDispatcher<::test_protocollayoutssamelibrary::ComposedProtocol>::DispatchEvent(
      ::fidl::IncomingHeaderAndMessage& msg,
      ::fidl::internal::MessageStorageViewBase* storage_view) {
    switch (msg.header()->ordinal) {
      case ::test_protocollayoutssamelibrary::kComposedProtocol_OnAnonComposed_Ordinal:
      {
        ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalEvent<::test_protocollayoutssamelibrary::ComposedProtocol::OnAnonComposed>(
            std::move(msg));
        if (!decoded.is_ok()) {
          return decoded.error_value();
        }
        if (event_handler()) {
            auto* primary = decoded.value().pointer();
          event_handler()->OnAnonComposed(primary);
        }
        return ::fidl::Status::Ok();
      }
      case ::test_protocollayoutssamelibrary::kComposedProtocol_OnNamedComposed_Ordinal:
      {
        ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalEvent<::test_protocollayoutssamelibrary::ComposedProtocol::OnNamedComposed>(
            std::move(msg));
        if (!decoded.is_ok()) {
          return decoded.error_value();
        }
        if (event_handler()) {
            auto* primary = decoded.value().pointer();
          event_handler()->OnNamedComposed(primary);
        }
        return ::fidl::Status::Ok();
      }
      default:
        std::move(msg).CloseHandles();
        return ::fidl::Status::UnknownOrdinal();
    }
  }

#endif  // __Fuchsia__


#ifdef __Fuchsia__



constexpr ::fidl::internal::MethodEntry fidl::internal::WireServerDispatcher<::test_protocollayoutssamelibrary::ComposedProtocol>::entries_[] = {
    { ::test_protocollayoutssamelibrary::kComposedProtocol_OneWayAnonComposed_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::StandaloneInplaceDecode<::test_protocollayoutssamelibrary::wire::ComposedProtocolOneWayAnonComposedRequest>(
            std::move(msg), metadata);
        if (unlikely(!decoded.is_ok())) {
          return decoded.error_value();
        }
        ::fidl::internal::WireCompleter<::test_protocollayoutssamelibrary::ComposedProtocol::OneWayAnonComposed>::Sync completer(txn);
        reinterpret_cast<::fidl::WireServer<::test_protocollayoutssamelibrary::ComposedProtocol>*>(interface)->OneWayAnonComposed(
            decoded.value().pointer(),
            completer
        );
        return ::fidl::Status::Ok();
      },
    },
    { ::test_protocollayoutssamelibrary::kComposedProtocol_TwoWayAnonComposed_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::StandaloneInplaceDecode<::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayAnonComposedRequest>(
            std::move(msg), metadata);
        if (unlikely(!decoded.is_ok())) {
          return decoded.error_value();
        }
        ::fidl::internal::WireCompleter<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposed>::Sync completer(txn);
        reinterpret_cast<::fidl::WireServer<::test_protocollayoutssamelibrary::ComposedProtocol>*>(interface)->TwoWayAnonComposed(
            decoded.value().pointer(),
            completer
        );
        return ::fidl::Status::Ok();
      },
    },
    { ::test_protocollayoutssamelibrary::kComposedProtocol_TwoWayAnonComposedWithError_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::StandaloneInplaceDecode<::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayAnonComposedWithErrorRequest>(
            std::move(msg), metadata);
        if (unlikely(!decoded.is_ok())) {
          return decoded.error_value();
        }
        ::fidl::internal::WireCompleter<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposedWithError>::Sync completer(txn);
        reinterpret_cast<::fidl::WireServer<::test_protocollayoutssamelibrary::ComposedProtocol>*>(interface)->TwoWayAnonComposedWithError(
            decoded.value().pointer(),
            completer
        );
        return ::fidl::Status::Ok();
      },
    },
    { ::test_protocollayoutssamelibrary::kComposedProtocol_OneWayNamedComposed_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::StandaloneInplaceDecode<::test_protocollayoutssamelibrary::wire::TablePayload>(
            std::move(msg), metadata);
        if (unlikely(!decoded.is_ok())) {
          return decoded.error_value();
        }
        ::fidl::internal::WireCompleter<::test_protocollayoutssamelibrary::ComposedProtocol::OneWayNamedComposed>::Sync completer(txn);
        reinterpret_cast<::fidl::WireServer<::test_protocollayoutssamelibrary::ComposedProtocol>*>(interface)->OneWayNamedComposed(
            decoded.value().pointer(),
            completer
        );
        return ::fidl::Status::Ok();
      },
    },
    { ::test_protocollayoutssamelibrary::kComposedProtocol_TwoWayNamedComposed_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::StandaloneInplaceDecode<::test_protocollayoutssamelibrary::wire::UnionPayload>(
            std::move(msg), metadata);
        if (unlikely(!decoded.is_ok())) {
          return decoded.error_value();
        }
        ::fidl::internal::WireCompleter<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposed>::Sync completer(txn);
        reinterpret_cast<::fidl::WireServer<::test_protocollayoutssamelibrary::ComposedProtocol>*>(interface)->TwoWayNamedComposed(
            decoded.value().pointer(),
            completer
        );
        return ::fidl::Status::Ok();
      },
    },
    { ::test_protocollayoutssamelibrary::kComposedProtocol_TwoWayNamedComposedWithError_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::StandaloneInplaceDecode<::test_protocollayoutssamelibrary::wire::TablePayload>(
            std::move(msg), metadata);
        if (unlikely(!decoded.is_ok())) {
          return decoded.error_value();
        }
        ::fidl::internal::WireCompleter<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposedWithError>::Sync completer(txn);
        reinterpret_cast<::fidl::WireServer<::test_protocollayoutssamelibrary::ComposedProtocol>*>(interface)->TwoWayNamedComposedWithError(
            decoded.value().pointer(),
            completer
        );
        return ::fidl::Status::Ok();
      },
    },
};

const ::fidl::internal::MethodEntry* fidl::internal::WireServerDispatcher<::test_protocollayoutssamelibrary::ComposedProtocol>::entries_end_ =
    &entries_[6];

::fidl::DispatchResult fidl::internal::WireServerDispatcher<::test_protocollayoutssamelibrary::ComposedProtocol>::TryDispatch(
    ::fidl::WireServer<::test_protocollayoutssamelibrary::ComposedProtocol>* impl, ::fidl::IncomingHeaderAndMessage& msg,
    internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
  return ::fidl::internal::TryDispatch(
    impl, msg, storage_view, txn, entries_, entries_end_);
}



void fidl::internal::WireServerDispatcher<::test_protocollayoutssamelibrary::ComposedProtocol>::Dispatch(::fidl::WireServer<::test_protocollayoutssamelibrary::ComposedProtocol>* 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::WireServer<::test_protocollayoutssamelibrary::ComposedProtocol>::dispatch_message(
    ::fidl::IncomingHeaderAndMessage&& msg, ::fidl::Transaction* txn,
    ::fidl::internal::MessageStorageViewBase* storage_view) {
  ::fidl::internal::WireServerDispatcher<::test_protocollayoutssamelibrary::ComposedProtocol>::Dispatch(this, std::move(msg), storage_view, txn);
}

#endif  // __Fuchsia__



#ifdef __Fuchsia__
void
fidl::internal::WireCompleterImpl<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposed>::Reply(::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayAnonComposedResponse ComposedProtocolTwoWayAnonComposedResponse) {
  return MakeReply(ComposedProtocolTwoWayAnonComposedResponse);
}

void
fidl::internal::WireCompleterImpl<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposed>::MakeReply(::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayAnonComposedResponse ComposedProtocolTwoWayAnonComposedResponse) {
  ::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposed> _response{ ComposedProtocolTwoWayAnonComposedResponse };
  FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT
  ::fidl::internal::OwnedEncodedMessage<
      ::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposed>, ::fidl::internal::ChannelTransport> _response_message{
      ::fidl::internal::AllowUnownedInputRef{}, &_response};
  return _core()->SendReply(&_response_message.GetOutgoingMessage(),
                            ::fidl::internal::OutgoingTransportContext());
}


void
fidl::internal::WireBufferCompleterImpl<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposed>::Reply(::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayAnonComposedResponse ComposedProtocolTwoWayAnonComposedResponse) {
  return MakeReply(ComposedProtocolTwoWayAnonComposedResponse);
}

void
fidl::internal::WireBufferCompleterImpl<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposed>::MakeReply(::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayAnonComposedResponse ComposedProtocolTwoWayAnonComposedResponse) {
  ::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposed> _response{ ComposedProtocolTwoWayAnonComposedResponse };
  constexpr uint32_t _buffer_size = ::fidl::ServerReplyBufferSizeInChannel<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposed>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    ::fidl::OutgoingMessage _failure{_allocation.error_value()};
    return _core()->SendReply(&_failure, ::fidl::internal::OutgoingTransportContext());
  }
  ::fidl::internal::UnownedEncodedMessage<
      ::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposed>, ::fidl::internal::ChannelTransport> _response_message(
      _allocation->data, _buffer_size, &_response);
  return _core()->SendReply(&_response_message.GetOutgoingMessage(),
                            ::fidl::internal::OutgoingTransportContext());
}

#endif  // __Fuchsia__



#ifdef __Fuchsia__
void
fidl::internal::WireCompleterImpl<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposedWithError>::Reply(::fit::result<uint32_t, ::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayAnonComposedWithErrorResponse*> result) {
  if (result.is_ok()) {
    return MakeReply(::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayAnonComposedWithErrorResult::WithResponse(::fidl::ObjectView<::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayAnonComposedWithErrorResponse>::FromExternal(result.value())));
  }
  return ReplyError(std::move(result.error_value()));
}

void
fidl::internal::WireCompleterImpl<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposedWithError>::MakeReply(::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayAnonComposedWithErrorResult ComposedProtocolTwoWayAnonComposedWithErrorResult) {
  ::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposedWithError> _response{ ComposedProtocolTwoWayAnonComposedWithErrorResult };
  FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT
  ::fidl::internal::OwnedEncodedMessage<
      ::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposedWithError>, ::fidl::internal::ChannelTransport> _response_message{
      ::fidl::internal::AllowUnownedInputRef{}, &_response};
  return _core()->SendReply(&_response_message.GetOutgoingMessage(),
                            ::fidl::internal::OutgoingTransportContext());
}
  void
  fidl::internal::WireCompleterImpl<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposedWithError>::ReplySuccess(::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayAnonComposedWithErrorResponse ComposedProtocolTwoWayAnonComposedWithErrorResponse) {
    ::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayAnonComposedWithErrorResponse _response = std::move(ComposedProtocolTwoWayAnonComposedWithErrorResponse);
return MakeReply(::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayAnonComposedWithErrorResult::WithResponse(::fidl::ObjectView<::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayAnonComposedWithErrorResponse>::FromExternal(&_response)));
  }

  void
  fidl::internal::WireCompleterImpl<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposedWithError>::ReplyError(uint32_t error) {
    return MakeReply(::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayAnonComposedWithErrorResult::WithErr(std::move(error)));
  }


void
fidl::internal::WireBufferCompleterImpl<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposedWithError>::Reply(::fit::result<uint32_t, ::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayAnonComposedWithErrorResponse*> result) {
  if (result.is_ok()) {
    return MakeReply(::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayAnonComposedWithErrorResult::WithResponse(::fidl::ObjectView<::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayAnonComposedWithErrorResponse>::FromExternal(result.value())));
  }
  return ReplyError(std::move(result.error_value()));
}

void
fidl::internal::WireBufferCompleterImpl<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposedWithError>::MakeReply(::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayAnonComposedWithErrorResult ComposedProtocolTwoWayAnonComposedWithErrorResult) {
  ::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposedWithError> _response{ ComposedProtocolTwoWayAnonComposedWithErrorResult };
  constexpr uint32_t _buffer_size = ::fidl::ServerReplyBufferSizeInChannel<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposedWithError>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    ::fidl::OutgoingMessage _failure{_allocation.error_value()};
    return _core()->SendReply(&_failure, ::fidl::internal::OutgoingTransportContext());
  }
  ::fidl::internal::UnownedEncodedMessage<
      ::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposedWithError>, ::fidl::internal::ChannelTransport> _response_message(
      _allocation->data, _buffer_size, &_response);
  return _core()->SendReply(&_response_message.GetOutgoingMessage(),
                            ::fidl::internal::OutgoingTransportContext());
}
  void
  fidl::internal::WireBufferCompleterImpl<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposedWithError>::ReplySuccess(::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayAnonComposedWithErrorResponse ComposedProtocolTwoWayAnonComposedWithErrorResponse) {
    ::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayAnonComposedWithErrorResponse _response = std::move(ComposedProtocolTwoWayAnonComposedWithErrorResponse);
return MakeReply(::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayAnonComposedWithErrorResult::WithResponse(::fidl::ObjectView<::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayAnonComposedWithErrorResponse>::FromExternal(&_response)));
  }

  void
  fidl::internal::WireBufferCompleterImpl<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposedWithError>::ReplyError(uint32_t error) {
    return MakeReply(::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayAnonComposedWithErrorResult::WithErr(std::move(error)));
  }

#endif  // __Fuchsia__



#ifdef __Fuchsia__
void
fidl::internal::WireCompleterImpl<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposed>::Reply(::test_protocollayoutssamelibrary::wire::TablePayload TablePayload) {
  return MakeReply(TablePayload);
}

void
fidl::internal::WireCompleterImpl<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposed>::MakeReply(::test_protocollayoutssamelibrary::wire::TablePayload TablePayload) {
  ::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposed> _response{ TablePayload };
  FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT
  ::fidl::internal::OwnedEncodedMessage<
      ::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposed>, ::fidl::internal::ChannelTransport> _response_message{
      ::fidl::internal::AllowUnownedInputRef{}, &_response};
  return _core()->SendReply(&_response_message.GetOutgoingMessage(),
                            ::fidl::internal::OutgoingTransportContext());
}


void
fidl::internal::WireBufferCompleterImpl<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposed>::Reply(::test_protocollayoutssamelibrary::wire::TablePayload TablePayload) {
  return MakeReply(TablePayload);
}

void
fidl::internal::WireBufferCompleterImpl<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposed>::MakeReply(::test_protocollayoutssamelibrary::wire::TablePayload TablePayload) {
  ::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposed> _response{ TablePayload };
  constexpr uint32_t _buffer_size = ::fidl::ServerReplyBufferSizeInChannel<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposed>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    ::fidl::OutgoingMessage _failure{_allocation.error_value()};
    return _core()->SendReply(&_failure, ::fidl::internal::OutgoingTransportContext());
  }
  ::fidl::internal::UnownedEncodedMessage<
      ::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposed>, ::fidl::internal::ChannelTransport> _response_message(
      _allocation->data, _buffer_size, &_response);
  return _core()->SendReply(&_response_message.GetOutgoingMessage(),
                            ::fidl::internal::OutgoingTransportContext());
}

#endif  // __Fuchsia__



#ifdef __Fuchsia__
void
fidl::internal::WireCompleterImpl<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposedWithError>::Reply(::fit::result<uint32_t, ::test_protocollayoutssamelibrary::wire::UnionPayload*> result) {
  if (result.is_ok()) {
    return MakeReply(::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayNamedComposedWithErrorResult::WithResponse(::fidl::ObjectView<::test_protocollayoutssamelibrary::wire::UnionPayload>::FromExternal(result.value())));
  }
  return ReplyError(std::move(result.error_value()));
}

void
fidl::internal::WireCompleterImpl<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposedWithError>::MakeReply(::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayNamedComposedWithErrorResult ComposedProtocolTwoWayNamedComposedWithErrorResult) {
  ::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposedWithError> _response{ ComposedProtocolTwoWayNamedComposedWithErrorResult };
  FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT
  ::fidl::internal::OwnedEncodedMessage<
      ::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposedWithError>, ::fidl::internal::ChannelTransport> _response_message{
      ::fidl::internal::AllowUnownedInputRef{}, &_response};
  return _core()->SendReply(&_response_message.GetOutgoingMessage(),
                            ::fidl::internal::OutgoingTransportContext());
}
  void
  fidl::internal::WireCompleterImpl<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposedWithError>::ReplySuccess(::test_protocollayoutssamelibrary::wire::UnionPayload UnionPayload) {
    ::test_protocollayoutssamelibrary::wire::UnionPayload _response = std::move(UnionPayload);
return MakeReply(::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayNamedComposedWithErrorResult::WithResponse(::fidl::ObjectView<::test_protocollayoutssamelibrary::wire::UnionPayload>::FromExternal(&_response)));
  }

  void
  fidl::internal::WireCompleterImpl<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposedWithError>::ReplyError(uint32_t error) {
    return MakeReply(::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayNamedComposedWithErrorResult::WithErr(std::move(error)));
  }


void
fidl::internal::WireBufferCompleterImpl<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposedWithError>::Reply(::fit::result<uint32_t, ::test_protocollayoutssamelibrary::wire::UnionPayload*> result) {
  if (result.is_ok()) {
    return MakeReply(::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayNamedComposedWithErrorResult::WithResponse(::fidl::ObjectView<::test_protocollayoutssamelibrary::wire::UnionPayload>::FromExternal(result.value())));
  }
  return ReplyError(std::move(result.error_value()));
}

void
fidl::internal::WireBufferCompleterImpl<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposedWithError>::MakeReply(::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayNamedComposedWithErrorResult ComposedProtocolTwoWayNamedComposedWithErrorResult) {
  ::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposedWithError> _response{ ComposedProtocolTwoWayNamedComposedWithErrorResult };
  constexpr uint32_t _buffer_size = ::fidl::ServerReplyBufferSizeInChannel<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposedWithError>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    ::fidl::OutgoingMessage _failure{_allocation.error_value()};
    return _core()->SendReply(&_failure, ::fidl::internal::OutgoingTransportContext());
  }
  ::fidl::internal::UnownedEncodedMessage<
      ::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposedWithError>, ::fidl::internal::ChannelTransport> _response_message(
      _allocation->data, _buffer_size, &_response);
  return _core()->SendReply(&_response_message.GetOutgoingMessage(),
                            ::fidl::internal::OutgoingTransportContext());
}
  void
  fidl::internal::WireBufferCompleterImpl<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposedWithError>::ReplySuccess(::test_protocollayoutssamelibrary::wire::UnionPayload UnionPayload) {
    ::test_protocollayoutssamelibrary::wire::UnionPayload _response = std::move(UnionPayload);
return MakeReply(::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayNamedComposedWithErrorResult::WithResponse(::fidl::ObjectView<::test_protocollayoutssamelibrary::wire::UnionPayload>::FromExternal(&_response)));
  }

  void
  fidl::internal::WireBufferCompleterImpl<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposedWithError>::ReplyError(uint32_t error) {
    return MakeReply(::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayNamedComposedWithErrorResult::WithErr(std::move(error)));
  }

#endif  // __Fuchsia__


#ifdef __Fuchsia__
void ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::ComposedProtocol::OneWayAnonComposed>::_InitHeader() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayoutssamelibrary::kComposedProtocol_OneWayAnonComposed_Ordinal, ::test_protocollayoutssamelibrary::kComposedProtocol_OneWayAnonComposed_DynamicFlags);
  }

#endif  // __Fuchsia__

    
    

#ifdef __Fuchsia__
void ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposed>::_InitHeader() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayoutssamelibrary::kComposedProtocol_TwoWayAnonComposed_Ordinal, ::test_protocollayoutssamelibrary::kComposedProtocol_TwoWayAnonComposed_DynamicFlags);
  }

#endif  // __Fuchsia__

    
    

  void ::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposed>::_InitHeader() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayoutssamelibrary::kComposedProtocol_TwoWayAnonComposed_Ordinal, ::test_protocollayoutssamelibrary::kComposedProtocol_TwoWayAnonComposed_DynamicFlags);
  }
    
    

#ifdef __Fuchsia__
void ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposedWithError>::_InitHeader() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayoutssamelibrary::kComposedProtocol_TwoWayAnonComposedWithError_Ordinal, ::test_protocollayoutssamelibrary::kComposedProtocol_TwoWayAnonComposedWithError_DynamicFlags);
  }

#endif  // __Fuchsia__

    
    

  void ::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayAnonComposedWithError>::_InitHeader() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayoutssamelibrary::kComposedProtocol_TwoWayAnonComposedWithError_Ordinal, ::test_protocollayoutssamelibrary::kComposedProtocol_TwoWayAnonComposedWithError_DynamicFlags);
  }
    
    
    
    

#ifdef __Fuchsia__
void ::fidl::internal::TransactionalEvent<::test_protocollayoutssamelibrary::ComposedProtocol::OnAnonComposed>::_InitHeader() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayoutssamelibrary::kComposedProtocol_OnAnonComposed_Ordinal, ::test_protocollayoutssamelibrary::kComposedProtocol_OnAnonComposed_DynamicFlags);
  }

#endif  // __Fuchsia__

    
    

#ifdef __Fuchsia__
void ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::ComposedProtocol::OneWayNamedComposed>::_InitHeader() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayoutssamelibrary::kComposedProtocol_OneWayNamedComposed_Ordinal, ::test_protocollayoutssamelibrary::kComposedProtocol_OneWayNamedComposed_DynamicFlags);
  }

#endif  // __Fuchsia__

    
    

#ifdef __Fuchsia__
void ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposed>::_InitHeader() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayoutssamelibrary::kComposedProtocol_TwoWayNamedComposed_Ordinal, ::test_protocollayoutssamelibrary::kComposedProtocol_TwoWayNamedComposed_DynamicFlags);
  }

#endif  // __Fuchsia__

    
    

  void ::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposed>::_InitHeader() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayoutssamelibrary::kComposedProtocol_TwoWayNamedComposed_Ordinal, ::test_protocollayoutssamelibrary::kComposedProtocol_TwoWayNamedComposed_DynamicFlags);
  }
    
    

#ifdef __Fuchsia__
void ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposedWithError>::_InitHeader() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayoutssamelibrary::kComposedProtocol_TwoWayNamedComposedWithError_Ordinal, ::test_protocollayoutssamelibrary::kComposedProtocol_TwoWayNamedComposedWithError_DynamicFlags);
  }

#endif  // __Fuchsia__

    
    

  void ::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::ComposedProtocol::TwoWayNamedComposedWithError>::_InitHeader() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayoutssamelibrary::kComposedProtocol_TwoWayNamedComposedWithError_Ordinal, ::test_protocollayoutssamelibrary::kComposedProtocol_TwoWayNamedComposedWithError_DynamicFlags);
  }
    
    
    
    

#ifdef __Fuchsia__
void ::fidl::internal::TransactionalEvent<::test_protocollayoutssamelibrary::ComposedProtocol::OnNamedComposed>::_InitHeader() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayoutssamelibrary::kComposedProtocol_OnNamedComposed_Ordinal, ::test_protocollayoutssamelibrary::kComposedProtocol_OnNamedComposed_DynamicFlags);
  }

#endif  // __Fuchsia__

    
    
  


#ifdef __Fuchsia__

::fidl::OneWayStatus fidl::internal::WireWeakEventSender<::test_protocollayoutssamelibrary::ComposedProtocol>::OnAnonComposed(::test_protocollayoutssamelibrary::wire::ComposedProtocolOnAnonComposedRequest ComposedProtocolOnAnonComposedRequest) {
  ::fidl::internal::TransactionalEvent<::test_protocollayoutssamelibrary::ComposedProtocol::OnAnonComposed> _response{ComposedProtocolOnAnonComposedRequest };
  FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalEvent<::test_protocollayoutssamelibrary::ComposedProtocol::OnAnonComposed>, ::fidl::internal::ChannelTransport> _response_message{
      ::fidl::internal::AllowUnownedInputRef{}, &_response
  };
  return _inner().SendEvent(_response_message.GetOutgoingMessage());
}

fidl::OneWayStatus fidl::internal::WireWeakBufferEventSender<::test_protocollayoutssamelibrary::ComposedProtocol>::OnAnonComposed(::test_protocollayoutssamelibrary::wire::ComposedProtocolOnAnonComposedRequest ComposedProtocolOnAnonComposedRequest) {
  constexpr uint32_t _buffer_size = ::fidl::EventReplyBufferSizeInChannel<::test_protocollayoutssamelibrary::ComposedProtocol::OnAnonComposed>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    _inner().HandleSendError(_allocation.error_value());
    return fidl::OneWayStatus{_allocation.error_value()};
  }

  ::fidl::internal::TransactionalEvent<::test_protocollayoutssamelibrary::ComposedProtocol::OnAnonComposed> _response{ComposedProtocolOnAnonComposedRequest };
  ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalEvent<::test_protocollayoutssamelibrary::ComposedProtocol::OnAnonComposed>, ::fidl::internal::ChannelTransport> _response_message(
      _allocation->data, _buffer_size, &_response);
  return _inner().SendEvent(_response_message.GetOutgoingMessage());
}

fidl::OneWayStatus fidl::internal::WireEventSender<::test_protocollayoutssamelibrary::ComposedProtocol>::OnAnonComposed(::test_protocollayoutssamelibrary::wire::ComposedProtocolOnAnonComposedRequest ComposedProtocolOnAnonComposedRequest) {
  ::fidl::internal::TransactionalEvent<::test_protocollayoutssamelibrary::ComposedProtocol::OnAnonComposed> _response{ComposedProtocolOnAnonComposedRequest };
  FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalEvent<::test_protocollayoutssamelibrary::ComposedProtocol::OnAnonComposed>, ::fidl::internal::ChannelTransport> _response_message{
      ::fidl::internal::AllowUnownedInputRef{}, &_response
  };
  auto& _message = _response_message.GetOutgoingMessage();
  _message.Write(_transport());
  return ::fidl::OneWayStatus{::fidl::Status{_message}};
}

fidl::OneWayStatus fidl::internal::WireBufferEventSender<::test_protocollayoutssamelibrary::ComposedProtocol>::OnAnonComposed(::test_protocollayoutssamelibrary::wire::ComposedProtocolOnAnonComposedRequest ComposedProtocolOnAnonComposedRequest) {
  constexpr uint32_t _buffer_size = ::fidl::EventReplyBufferSizeInChannel<::test_protocollayoutssamelibrary::ComposedProtocol::OnAnonComposed>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    return fidl::OneWayStatus{_allocation.error_value()};
  }

  ::fidl::internal::TransactionalEvent<::test_protocollayoutssamelibrary::ComposedProtocol::OnAnonComposed> _response{ComposedProtocolOnAnonComposedRequest };
  ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalEvent<::test_protocollayoutssamelibrary::ComposedProtocol::OnAnonComposed>, ::fidl::internal::ChannelTransport> _response_message(
        _allocation->data, _buffer_size, &_response);
  auto& _message = _response_message.GetOutgoingMessage();
  _message.Write(_transport());
  return ::fidl::OneWayStatus{::fidl::Status{_message}};
}

::fidl::OneWayStatus fidl::internal::WireWeakEventSender<::test_protocollayoutssamelibrary::ComposedProtocol>::OnNamedComposed(::test_protocollayoutssamelibrary::wire::UnionPayload UnionPayload) {
  ::fidl::internal::TransactionalEvent<::test_protocollayoutssamelibrary::ComposedProtocol::OnNamedComposed> _response{UnionPayload };
  FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalEvent<::test_protocollayoutssamelibrary::ComposedProtocol::OnNamedComposed>, ::fidl::internal::ChannelTransport> _response_message{
      ::fidl::internal::AllowUnownedInputRef{}, &_response
  };
  return _inner().SendEvent(_response_message.GetOutgoingMessage());
}

fidl::OneWayStatus fidl::internal::WireWeakBufferEventSender<::test_protocollayoutssamelibrary::ComposedProtocol>::OnNamedComposed(::test_protocollayoutssamelibrary::wire::UnionPayload UnionPayload) {
  constexpr uint32_t _buffer_size = ::fidl::EventReplyBufferSizeInChannel<::test_protocollayoutssamelibrary::ComposedProtocol::OnNamedComposed>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    _inner().HandleSendError(_allocation.error_value());
    return fidl::OneWayStatus{_allocation.error_value()};
  }

  ::fidl::internal::TransactionalEvent<::test_protocollayoutssamelibrary::ComposedProtocol::OnNamedComposed> _response{UnionPayload };
  ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalEvent<::test_protocollayoutssamelibrary::ComposedProtocol::OnNamedComposed>, ::fidl::internal::ChannelTransport> _response_message(
      _allocation->data, _buffer_size, &_response);
  return _inner().SendEvent(_response_message.GetOutgoingMessage());
}

fidl::OneWayStatus fidl::internal::WireEventSender<::test_protocollayoutssamelibrary::ComposedProtocol>::OnNamedComposed(::test_protocollayoutssamelibrary::wire::UnionPayload UnionPayload) {
  ::fidl::internal::TransactionalEvent<::test_protocollayoutssamelibrary::ComposedProtocol::OnNamedComposed> _response{UnionPayload };
  FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalEvent<::test_protocollayoutssamelibrary::ComposedProtocol::OnNamedComposed>, ::fidl::internal::ChannelTransport> _response_message{
      ::fidl::internal::AllowUnownedInputRef{}, &_response
  };
  auto& _message = _response_message.GetOutgoingMessage();
  _message.Write(_transport());
  return ::fidl::OneWayStatus{::fidl::Status{_message}};
}

fidl::OneWayStatus fidl::internal::WireBufferEventSender<::test_protocollayoutssamelibrary::ComposedProtocol>::OnNamedComposed(::test_protocollayoutssamelibrary::wire::UnionPayload UnionPayload) {
  constexpr uint32_t _buffer_size = ::fidl::EventReplyBufferSizeInChannel<::test_protocollayoutssamelibrary::ComposedProtocol::OnNamedComposed>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    return fidl::OneWayStatus{_allocation.error_value()};
  }

  ::fidl::internal::TransactionalEvent<::test_protocollayoutssamelibrary::ComposedProtocol::OnNamedComposed> _response{UnionPayload };
  ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalEvent<::test_protocollayoutssamelibrary::ComposedProtocol::OnNamedComposed>, ::fidl::internal::ChannelTransport> _response_message(
        _allocation->data, _buffer_size, &_response);
  auto& _message = _response_message.GetOutgoingMessage();
  _message.Write(_transport());
  return ::fidl::OneWayStatus{::fidl::Status{_message}};
}


#endif  // __Fuchsia__


  

namespace test_protocollayoutssamelibrary {

[[maybe_unused]]
constexpr uint64_t kMainProtocol_OneWayAnonComposed_Ordinal = 7960710870216447007lu;


[[maybe_unused]]
constexpr ::fidl::MessageDynamicFlags kMainProtocol_OneWayAnonComposed_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;


[[maybe_unused]]
constexpr uint64_t kMainProtocol_TwoWayAnonComposed_Ordinal = 8107448265006659060lu;


[[maybe_unused]]
constexpr ::fidl::MessageDynamicFlags kMainProtocol_TwoWayAnonComposed_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;


[[maybe_unused]]
constexpr uint64_t kMainProtocol_TwoWayAnonComposedWithError_Ordinal = 5751989932125743144lu;


[[maybe_unused]]
constexpr ::fidl::MessageDynamicFlags kMainProtocol_TwoWayAnonComposedWithError_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;


[[maybe_unused]]
constexpr uint64_t kMainProtocol_OnAnonComposed_Ordinal = 5307191872315199016lu;


[[maybe_unused]]
constexpr ::fidl::MessageDynamicFlags kMainProtocol_OnAnonComposed_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;


[[maybe_unused]]
constexpr uint64_t kMainProtocol_OneWayNamedComposed_Ordinal = 1159174053475281336lu;


[[maybe_unused]]
constexpr ::fidl::MessageDynamicFlags kMainProtocol_OneWayNamedComposed_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;


[[maybe_unused]]
constexpr uint64_t kMainProtocol_TwoWayNamedComposed_Ordinal = 5022872388073111636lu;


[[maybe_unused]]
constexpr ::fidl::MessageDynamicFlags kMainProtocol_TwoWayNamedComposed_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;


[[maybe_unused]]
constexpr uint64_t kMainProtocol_TwoWayNamedComposedWithError_Ordinal = 4973436213756973807lu;


[[maybe_unused]]
constexpr ::fidl::MessageDynamicFlags kMainProtocol_TwoWayNamedComposedWithError_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;


[[maybe_unused]]
constexpr uint64_t kMainProtocol_OnNamedComposed_Ordinal = 1712755118419701115lu;


[[maybe_unused]]
constexpr ::fidl::MessageDynamicFlags kMainProtocol_OnNamedComposed_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;


[[maybe_unused]]
constexpr uint64_t kMainProtocol_OneWayLocal_Ordinal = 4131125523789731521lu;


[[maybe_unused]]
constexpr ::fidl::MessageDynamicFlags kMainProtocol_OneWayLocal_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;


[[maybe_unused]]
constexpr uint64_t kMainProtocol_TwoWayLocal_Ordinal = 2781407403924167255lu;


[[maybe_unused]]
constexpr ::fidl::MessageDynamicFlags kMainProtocol_TwoWayLocal_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;


[[maybe_unused]]
constexpr uint64_t kMainProtocol_TwoWayLocalWithError_Ordinal = 5367158046384127463lu;


[[maybe_unused]]
constexpr ::fidl::MessageDynamicFlags kMainProtocol_TwoWayLocalWithError_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;


[[maybe_unused]]
constexpr uint64_t kMainProtocol_OnLocal_Ordinal = 8208103053879750285lu;


[[maybe_unused]]
constexpr ::fidl::MessageDynamicFlags kMainProtocol_OnLocal_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;


[[maybe_unused]]
constexpr uint64_t kMainProtocol_OneWayAnon_Ordinal = 8596232895075765804lu;


[[maybe_unused]]
constexpr ::fidl::MessageDynamicFlags kMainProtocol_OneWayAnon_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;


[[maybe_unused]]
constexpr uint64_t kMainProtocol_TwoWayAnon_Ordinal = 4600336371166510638lu;


[[maybe_unused]]
constexpr ::fidl::MessageDynamicFlags kMainProtocol_TwoWayAnon_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;


[[maybe_unused]]
constexpr uint64_t kMainProtocol_TwoWayAnonWithError_Ordinal = 2104032160763523653lu;


[[maybe_unused]]
constexpr ::fidl::MessageDynamicFlags kMainProtocol_TwoWayAnonWithError_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;


[[maybe_unused]]
constexpr uint64_t kMainProtocol_OnAnon_Ordinal = 977183060572945300lu;


[[maybe_unused]]
constexpr ::fidl::MessageDynamicFlags kMainProtocol_OnAnon_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;
#ifdef __Fuchsia__
}  // namespace test_protocollayoutssamelibrary

::fidl::WireResult<::test_protocollayoutssamelibrary::MainProtocol::OneWayAnonComposed>::WireResult(
    ::fidl::UnownedClientEnd<::test_protocollayoutssamelibrary::MainProtocol> client,
    ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::OneWayAnonComposed>* request
) {
  FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::OneWayAnonComposed>, ::fidl::internal::ChannelTransport> request_message(
      ::fidl::internal::AllowUnownedInputRef{}, request);
  auto& outgoing = request_message.GetOutgoingMessage();
    outgoing.Write(client.handle());
    SetStatus(outgoing);
}namespace test_protocollayoutssamelibrary {

#endif  // __Fuchsia__


#ifdef __Fuchsia__
}  // namespace test_protocollayoutssamelibrary

::fidl::WireUnownedResult<::test_protocollayoutssamelibrary::MainProtocol::OneWayAnonComposed>::WireUnownedResult(::fidl::UnownedClientEnd<::test_protocollayoutssamelibrary::MainProtocol> client_end, ::fidl::internal::AnyBufferAllocator& allocator, ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::OneWayAnonComposed>* request) {
  constexpr uint32_t buffer_size = ::fidl::SyncClientMethodBufferSizeInChannel<::test_protocollayoutssamelibrary::MainProtocol::OneWayAnonComposed>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> allocation = allocator.TryAllocate(buffer_size);
  if (!allocation.is_ok()) {
    SetStatus(allocation.error_value());
    return;
  }
  uint8_t* buffer = allocation->data;
    uint32_t request_byte_capacity = buffer_size;
    uint8_t* request_bytes = buffer;

  ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::OneWayAnonComposed>> request_message(
      request_bytes, request_byte_capacity, request);
  auto& outgoing = request_message.GetOutgoingMessage();
    outgoing.Write(client_end.handle());
    SetStatus(outgoing);
}namespace test_protocollayoutssamelibrary {

#endif  // __Fuchsia__


#ifdef __Fuchsia__
}  // namespace test_protocollayoutssamelibrary

::fidl::WireResult<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposed>::WireResult(
    ::fidl::UnownedClientEnd<::test_protocollayoutssamelibrary::MainProtocol> client,
    ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposed>* request
) {
  FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposed>, ::fidl::internal::ChannelTransport> request_message(
      ::fidl::internal::AllowUnownedInputRef{}, request);
  auto& outgoing = request_message.GetOutgoingMessage();
    ::fidl::internal::IncomingMessageHandleStorage<::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposed>> handle_storage;
    ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposed>(
        outgoing.Call(client.handle(), handle_storage.view(bytes_.view()), fidl::CallOptions{})
    );
    SetStatus(::fidl::internal::StatusFromResult(decoded));
      if (ok()) {
        decoded_ = std::move(decoded.value());
        ExtractValueFromDecoded(decoded_.pointer());
      }
}namespace test_protocollayoutssamelibrary {

#endif  // __Fuchsia__


#ifdef __Fuchsia__
}  // namespace test_protocollayoutssamelibrary

::fidl::WireUnownedResult<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposed>::WireUnownedResult(::fidl::UnownedClientEnd<::test_protocollayoutssamelibrary::MainProtocol> client_end, ::fidl::internal::AnyBufferAllocator& allocator, ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposed>* request) {
  constexpr uint32_t buffer_size = ::fidl::SyncClientMethodBufferSizeInChannel<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposed>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> allocation = allocator.TryAllocate(buffer_size);
  if (!allocation.is_ok()) {
    SetStatus(allocation.error_value());
    return;
  }
  uint8_t* buffer = allocation->data;constexpr uint32_t request_byte_capacity = ::fidl::MaxSizeInChannel<
        ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposed>, ::fidl::MessageDirection::kSending>();
    uint8_t* request_bytes = buffer;
    static_assert(buffer_size > request_byte_capacity);
    uint32_t response_byte_capacity = buffer_size - request_byte_capacity;
    uint8_t* response_bytes = &buffer[request_byte_capacity];

  ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposed>> request_message(
      request_bytes, request_byte_capacity, request);
  auto& outgoing = request_message.GetOutgoingMessage();
    ::fidl::internal::IncomingMessageHandleStorage<::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposed>> handle_storage;
    ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposed>(
        outgoing.Call(
            client_end.handle(),
            handle_storage.view(fidl::BufferSpan(response_bytes, response_byte_capacity))
        )
    );
    SetStatus(::fidl::internal::StatusFromResult(decoded));
      if (ok()) {
        decoded_ = std::move(decoded.value());
        ExtractValueFromDecoded(decoded_.pointer());
      }
}namespace test_protocollayoutssamelibrary {

#endif  // __Fuchsia__


#ifdef __Fuchsia__
}  // namespace test_protocollayoutssamelibrary

::fidl::WireResult<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposedWithError>::WireResult(
    ::fidl::UnownedClientEnd<::test_protocollayoutssamelibrary::MainProtocol> client,
    ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposedWithError>* request
) {
  FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposedWithError>, ::fidl::internal::ChannelTransport> request_message(
      ::fidl::internal::AllowUnownedInputRef{}, request);
  auto& outgoing = request_message.GetOutgoingMessage();
    ::fidl::internal::IncomingMessageHandleStorage<::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposedWithError>> handle_storage;
    ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposedWithError>(
        outgoing.Call(client.handle(), handle_storage.view(bytes_.view()), fidl::CallOptions{})
    );
    SetStatus(::fidl::internal::StatusFromResult(decoded));
      if (ok()) {
        decoded_ = std::move(decoded.value());
        ExtractValueFromDecoded(decoded_.pointer());
      }
}namespace test_protocollayoutssamelibrary {

#endif  // __Fuchsia__


#ifdef __Fuchsia__
}  // namespace test_protocollayoutssamelibrary

::fidl::WireUnownedResult<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposedWithError>::WireUnownedResult(::fidl::UnownedClientEnd<::test_protocollayoutssamelibrary::MainProtocol> client_end, ::fidl::internal::AnyBufferAllocator& allocator, ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposedWithError>* request) {
  constexpr uint32_t buffer_size = ::fidl::SyncClientMethodBufferSizeInChannel<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposedWithError>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> allocation = allocator.TryAllocate(buffer_size);
  if (!allocation.is_ok()) {
    SetStatus(allocation.error_value());
    return;
  }
  uint8_t* buffer = allocation->data;constexpr uint32_t request_byte_capacity = ::fidl::MaxSizeInChannel<
        ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposedWithError>, ::fidl::MessageDirection::kSending>();
    uint8_t* request_bytes = buffer;
    static_assert(buffer_size > request_byte_capacity);
    uint32_t response_byte_capacity = buffer_size - request_byte_capacity;
    uint8_t* response_bytes = &buffer[request_byte_capacity];

  ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposedWithError>> request_message(
      request_bytes, request_byte_capacity, request);
  auto& outgoing = request_message.GetOutgoingMessage();
    ::fidl::internal::IncomingMessageHandleStorage<::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposedWithError>> handle_storage;
    ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposedWithError>(
        outgoing.Call(
            client_end.handle(),
            handle_storage.view(fidl::BufferSpan(response_bytes, response_byte_capacity))
        )
    );
    SetStatus(::fidl::internal::StatusFromResult(decoded));
      if (ok()) {
        decoded_ = std::move(decoded.value());
        ExtractValueFromDecoded(decoded_.pointer());
      }
}namespace test_protocollayoutssamelibrary {

#endif  // __Fuchsia__


#ifdef __Fuchsia__
}  // namespace test_protocollayoutssamelibrary

::fidl::WireResult<::test_protocollayoutssamelibrary::MainProtocol::OneWayNamedComposed>::WireResult(
    ::fidl::UnownedClientEnd<::test_protocollayoutssamelibrary::MainProtocol> client,
    ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::OneWayNamedComposed>* request
) {
  FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::OneWayNamedComposed>, ::fidl::internal::ChannelTransport> request_message(
      ::fidl::internal::AllowUnownedInputRef{}, request);
  auto& outgoing = request_message.GetOutgoingMessage();
    outgoing.Write(client.handle());
    SetStatus(outgoing);
}namespace test_protocollayoutssamelibrary {

#endif  // __Fuchsia__


#ifdef __Fuchsia__
}  // namespace test_protocollayoutssamelibrary

::fidl::WireUnownedResult<::test_protocollayoutssamelibrary::MainProtocol::OneWayNamedComposed>::WireUnownedResult(::fidl::UnownedClientEnd<::test_protocollayoutssamelibrary::MainProtocol> client_end, ::fidl::internal::AnyBufferAllocator& allocator, ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::OneWayNamedComposed>* request) {
  constexpr uint32_t buffer_size = ::fidl::SyncClientMethodBufferSizeInChannel<::test_protocollayoutssamelibrary::MainProtocol::OneWayNamedComposed>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> allocation = allocator.TryAllocate(buffer_size);
  if (!allocation.is_ok()) {
    SetStatus(allocation.error_value());
    return;
  }
  uint8_t* buffer = allocation->data;
    uint32_t request_byte_capacity = buffer_size;
    uint8_t* request_bytes = buffer;

  ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::OneWayNamedComposed>> request_message(
      request_bytes, request_byte_capacity, request);
  auto& outgoing = request_message.GetOutgoingMessage();
    outgoing.Write(client_end.handle());
    SetStatus(outgoing);
}namespace test_protocollayoutssamelibrary {

#endif  // __Fuchsia__


#ifdef __Fuchsia__
}  // namespace test_protocollayoutssamelibrary

::fidl::WireResult<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposed>::WireResult(
    ::fidl::UnownedClientEnd<::test_protocollayoutssamelibrary::MainProtocol> client,
    ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposed>* request
) {
  FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposed>, ::fidl::internal::ChannelTransport> request_message(
      ::fidl::internal::AllowUnownedInputRef{}, request);
  auto& outgoing = request_message.GetOutgoingMessage();
    ::fidl::internal::IncomingMessageHandleStorage<::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposed>> handle_storage;
    ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposed>(
        outgoing.Call(client.handle(), handle_storage.view(bytes_.view()), fidl::CallOptions{})
    );
    SetStatus(::fidl::internal::StatusFromResult(decoded));
      if (ok()) {
        decoded_ = std::move(decoded.value());
        ExtractValueFromDecoded(decoded_.pointer());
      }
}namespace test_protocollayoutssamelibrary {

#endif  // __Fuchsia__


#ifdef __Fuchsia__
}  // namespace test_protocollayoutssamelibrary

::fidl::WireUnownedResult<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposed>::WireUnownedResult(::fidl::UnownedClientEnd<::test_protocollayoutssamelibrary::MainProtocol> client_end, ::fidl::internal::AnyBufferAllocator& allocator, ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposed>* request) {
  constexpr uint32_t buffer_size = ::fidl::SyncClientMethodBufferSizeInChannel<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposed>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> allocation = allocator.TryAllocate(buffer_size);
  if (!allocation.is_ok()) {
    SetStatus(allocation.error_value());
    return;
  }
  uint8_t* buffer = allocation->data;constexpr uint32_t request_byte_capacity = ::fidl::MaxSizeInChannel<
        ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposed>, ::fidl::MessageDirection::kSending>();
    uint8_t* request_bytes = buffer;
    static_assert(buffer_size > request_byte_capacity);
    uint32_t response_byte_capacity = buffer_size - request_byte_capacity;
    uint8_t* response_bytes = &buffer[request_byte_capacity];

  ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposed>> request_message(
      request_bytes, request_byte_capacity, request);
  auto& outgoing = request_message.GetOutgoingMessage();
    ::fidl::internal::IncomingMessageHandleStorage<::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposed>> handle_storage;
    ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposed>(
        outgoing.Call(
            client_end.handle(),
            handle_storage.view(fidl::BufferSpan(response_bytes, response_byte_capacity))
        )
    );
    SetStatus(::fidl::internal::StatusFromResult(decoded));
      if (ok()) {
        decoded_ = std::move(decoded.value());
        ExtractValueFromDecoded(decoded_.pointer());
      }
}namespace test_protocollayoutssamelibrary {

#endif  // __Fuchsia__


#ifdef __Fuchsia__
}  // namespace test_protocollayoutssamelibrary

::fidl::WireResult<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposedWithError>::WireResult(
    ::fidl::UnownedClientEnd<::test_protocollayoutssamelibrary::MainProtocol> client,
    ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposedWithError>* request
) {
  FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposedWithError>, ::fidl::internal::ChannelTransport> request_message(
      ::fidl::internal::AllowUnownedInputRef{}, request);
  auto& outgoing = request_message.GetOutgoingMessage();
    ::fidl::internal::IncomingMessageHandleStorage<::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposedWithError>> handle_storage;
    ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposedWithError>(
        outgoing.Call(client.handle(), handle_storage.view(bytes_.view()), fidl::CallOptions{})
    );
    SetStatus(::fidl::internal::StatusFromResult(decoded));
      if (ok()) {
        decoded_ = std::move(decoded.value());
        ExtractValueFromDecoded(decoded_.pointer());
      }
}namespace test_protocollayoutssamelibrary {

#endif  // __Fuchsia__


#ifdef __Fuchsia__
}  // namespace test_protocollayoutssamelibrary

::fidl::WireUnownedResult<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposedWithError>::WireUnownedResult(::fidl::UnownedClientEnd<::test_protocollayoutssamelibrary::MainProtocol> client_end, ::fidl::internal::AnyBufferAllocator& allocator, ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposedWithError>* request) {
  constexpr uint32_t buffer_size = ::fidl::SyncClientMethodBufferSizeInChannel<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposedWithError>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> allocation = allocator.TryAllocate(buffer_size);
  if (!allocation.is_ok()) {
    SetStatus(allocation.error_value());
    return;
  }
  uint8_t* buffer = allocation->data;constexpr uint32_t request_byte_capacity = ::fidl::MaxSizeInChannel<
        ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposedWithError>, ::fidl::MessageDirection::kSending>();
    uint8_t* request_bytes = buffer;
    static_assert(buffer_size > request_byte_capacity);
    uint32_t response_byte_capacity = buffer_size - request_byte_capacity;
    uint8_t* response_bytes = &buffer[request_byte_capacity];

  ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposedWithError>> request_message(
      request_bytes, request_byte_capacity, request);
  auto& outgoing = request_message.GetOutgoingMessage();
    ::fidl::internal::IncomingMessageHandleStorage<::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposedWithError>> handle_storage;
    ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposedWithError>(
        outgoing.Call(
            client_end.handle(),
            handle_storage.view(fidl::BufferSpan(response_bytes, response_byte_capacity))
        )
    );
    SetStatus(::fidl::internal::StatusFromResult(decoded));
      if (ok()) {
        decoded_ = std::move(decoded.value());
        ExtractValueFromDecoded(decoded_.pointer());
      }
}namespace test_protocollayoutssamelibrary {

#endif  // __Fuchsia__


#ifdef __Fuchsia__
}  // namespace test_protocollayoutssamelibrary

::fidl::WireResult<::test_protocollayoutssamelibrary::MainProtocol::OneWayLocal>::WireResult(
    ::fidl::UnownedClientEnd<::test_protocollayoutssamelibrary::MainProtocol> client,
    ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::OneWayLocal>* request
) {
  FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::OneWayLocal>, ::fidl::internal::ChannelTransport> request_message(
      ::fidl::internal::AllowUnownedInputRef{}, request);
  auto& outgoing = request_message.GetOutgoingMessage();
    outgoing.Write(client.handle());
    SetStatus(outgoing);
}namespace test_protocollayoutssamelibrary {

#endif  // __Fuchsia__


#ifdef __Fuchsia__
}  // namespace test_protocollayoutssamelibrary

::fidl::WireUnownedResult<::test_protocollayoutssamelibrary::MainProtocol::OneWayLocal>::WireUnownedResult(::fidl::UnownedClientEnd<::test_protocollayoutssamelibrary::MainProtocol> client_end, ::fidl::internal::AnyBufferAllocator& allocator, ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::OneWayLocal>* request) {
  constexpr uint32_t buffer_size = ::fidl::SyncClientMethodBufferSizeInChannel<::test_protocollayoutssamelibrary::MainProtocol::OneWayLocal>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> allocation = allocator.TryAllocate(buffer_size);
  if (!allocation.is_ok()) {
    SetStatus(allocation.error_value());
    return;
  }
  uint8_t* buffer = allocation->data;
    uint32_t request_byte_capacity = buffer_size;
    uint8_t* request_bytes = buffer;

  ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::OneWayLocal>> request_message(
      request_bytes, request_byte_capacity, request);
  auto& outgoing = request_message.GetOutgoingMessage();
    outgoing.Write(client_end.handle());
    SetStatus(outgoing);
}namespace test_protocollayoutssamelibrary {

#endif  // __Fuchsia__


#ifdef __Fuchsia__
}  // namespace test_protocollayoutssamelibrary

::fidl::WireResult<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocal>::WireResult(
    ::fidl::UnownedClientEnd<::test_protocollayoutssamelibrary::MainProtocol> client,
    ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocal>* request
) {
  FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocal>, ::fidl::internal::ChannelTransport> request_message(
      ::fidl::internal::AllowUnownedInputRef{}, request);
  auto& outgoing = request_message.GetOutgoingMessage();
    ::fidl::internal::IncomingMessageHandleStorage<::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocal>> handle_storage;
    ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocal>(
        outgoing.Call(client.handle(), handle_storage.view(bytes_.view()), fidl::CallOptions{})
    );
    SetStatus(::fidl::internal::StatusFromResult(decoded));
      if (ok()) {
        decoded_ = std::move(decoded.value());
        ExtractValueFromDecoded(decoded_.pointer());
      }
}namespace test_protocollayoutssamelibrary {

#endif  // __Fuchsia__


#ifdef __Fuchsia__
}  // namespace test_protocollayoutssamelibrary

::fidl::WireUnownedResult<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocal>::WireUnownedResult(::fidl::UnownedClientEnd<::test_protocollayoutssamelibrary::MainProtocol> client_end, ::fidl::internal::AnyBufferAllocator& allocator, ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocal>* request) {
  constexpr uint32_t buffer_size = ::fidl::SyncClientMethodBufferSizeInChannel<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocal>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> allocation = allocator.TryAllocate(buffer_size);
  if (!allocation.is_ok()) {
    SetStatus(allocation.error_value());
    return;
  }
  uint8_t* buffer = allocation->data;constexpr uint32_t request_byte_capacity = ::fidl::MaxSizeInChannel<
        ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocal>, ::fidl::MessageDirection::kSending>();
    uint8_t* request_bytes = buffer;
    static_assert(buffer_size > request_byte_capacity);
    uint32_t response_byte_capacity = buffer_size - request_byte_capacity;
    uint8_t* response_bytes = &buffer[request_byte_capacity];

  ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocal>> request_message(
      request_bytes, request_byte_capacity, request);
  auto& outgoing = request_message.GetOutgoingMessage();
    ::fidl::internal::IncomingMessageHandleStorage<::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocal>> handle_storage;
    ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocal>(
        outgoing.Call(
            client_end.handle(),
            handle_storage.view(fidl::BufferSpan(response_bytes, response_byte_capacity))
        )
    );
    SetStatus(::fidl::internal::StatusFromResult(decoded));
      if (ok()) {
        decoded_ = std::move(decoded.value());
        ExtractValueFromDecoded(decoded_.pointer());
      }
}namespace test_protocollayoutssamelibrary {

#endif  // __Fuchsia__


#ifdef __Fuchsia__
}  // namespace test_protocollayoutssamelibrary

::fidl::WireResult<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocalWithError>::WireResult(
    ::fidl::UnownedClientEnd<::test_protocollayoutssamelibrary::MainProtocol> client,
    ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocalWithError>* request
) {
  FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocalWithError>, ::fidl::internal::ChannelTransport> request_message(
      ::fidl::internal::AllowUnownedInputRef{}, request);
  auto& outgoing = request_message.GetOutgoingMessage();
    ::fidl::internal::IncomingMessageHandleStorage<::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocalWithError>> handle_storage;
    ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocalWithError>(
        outgoing.Call(client.handle(), handle_storage.view(bytes_.view()), fidl::CallOptions{})
    );
    SetStatus(::fidl::internal::StatusFromResult(decoded));
      if (ok()) {
        decoded_ = std::move(decoded.value());
        ExtractValueFromDecoded(decoded_.pointer());
      }
}namespace test_protocollayoutssamelibrary {

#endif  // __Fuchsia__


#ifdef __Fuchsia__
}  // namespace test_protocollayoutssamelibrary

::fidl::WireUnownedResult<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocalWithError>::WireUnownedResult(::fidl::UnownedClientEnd<::test_protocollayoutssamelibrary::MainProtocol> client_end, ::fidl::internal::AnyBufferAllocator& allocator, ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocalWithError>* request) {
  constexpr uint32_t buffer_size = ::fidl::SyncClientMethodBufferSizeInChannel<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocalWithError>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> allocation = allocator.TryAllocate(buffer_size);
  if (!allocation.is_ok()) {
    SetStatus(allocation.error_value());
    return;
  }
  uint8_t* buffer = allocation->data;constexpr uint32_t request_byte_capacity = ::fidl::MaxSizeInChannel<
        ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocalWithError>, ::fidl::MessageDirection::kSending>();
    uint8_t* request_bytes = buffer;
    static_assert(buffer_size > request_byte_capacity);
    uint32_t response_byte_capacity = buffer_size - request_byte_capacity;
    uint8_t* response_bytes = &buffer[request_byte_capacity];

  ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocalWithError>> request_message(
      request_bytes, request_byte_capacity, request);
  auto& outgoing = request_message.GetOutgoingMessage();
    ::fidl::internal::IncomingMessageHandleStorage<::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocalWithError>> handle_storage;
    ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocalWithError>(
        outgoing.Call(
            client_end.handle(),
            handle_storage.view(fidl::BufferSpan(response_bytes, response_byte_capacity))
        )
    );
    SetStatus(::fidl::internal::StatusFromResult(decoded));
      if (ok()) {
        decoded_ = std::move(decoded.value());
        ExtractValueFromDecoded(decoded_.pointer());
      }
}namespace test_protocollayoutssamelibrary {

#endif  // __Fuchsia__


#ifdef __Fuchsia__
}  // namespace test_protocollayoutssamelibrary

::fidl::WireResult<::test_protocollayoutssamelibrary::MainProtocol::OneWayAnon>::WireResult(
    ::fidl::UnownedClientEnd<::test_protocollayoutssamelibrary::MainProtocol> client,
    ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::OneWayAnon>* request
) {
  FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::OneWayAnon>, ::fidl::internal::ChannelTransport> request_message(
      ::fidl::internal::AllowUnownedInputRef{}, request);
  auto& outgoing = request_message.GetOutgoingMessage();
    outgoing.Write(client.handle());
    SetStatus(outgoing);
}namespace test_protocollayoutssamelibrary {

#endif  // __Fuchsia__


#ifdef __Fuchsia__
}  // namespace test_protocollayoutssamelibrary

::fidl::WireUnownedResult<::test_protocollayoutssamelibrary::MainProtocol::OneWayAnon>::WireUnownedResult(::fidl::UnownedClientEnd<::test_protocollayoutssamelibrary::MainProtocol> client_end, ::fidl::internal::AnyBufferAllocator& allocator, ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::OneWayAnon>* request) {
  constexpr uint32_t buffer_size = ::fidl::SyncClientMethodBufferSizeInChannel<::test_protocollayoutssamelibrary::MainProtocol::OneWayAnon>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> allocation = allocator.TryAllocate(buffer_size);
  if (!allocation.is_ok()) {
    SetStatus(allocation.error_value());
    return;
  }
  uint8_t* buffer = allocation->data;
    uint32_t request_byte_capacity = buffer_size;
    uint8_t* request_bytes = buffer;

  ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::OneWayAnon>> request_message(
      request_bytes, request_byte_capacity, request);
  auto& outgoing = request_message.GetOutgoingMessage();
    outgoing.Write(client_end.handle());
    SetStatus(outgoing);
}namespace test_protocollayoutssamelibrary {

#endif  // __Fuchsia__


#ifdef __Fuchsia__
}  // namespace test_protocollayoutssamelibrary

::fidl::WireResult<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnon>::WireResult(
    ::fidl::UnownedClientEnd<::test_protocollayoutssamelibrary::MainProtocol> client,
    ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnon>* request
) {
  FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnon>, ::fidl::internal::ChannelTransport> request_message(
      ::fidl::internal::AllowUnownedInputRef{}, request);
  auto& outgoing = request_message.GetOutgoingMessage();
    ::fidl::internal::IncomingMessageHandleStorage<::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnon>> handle_storage;
    ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnon>(
        outgoing.Call(client.handle(), handle_storage.view(bytes_.view()), fidl::CallOptions{})
    );
    SetStatus(::fidl::internal::StatusFromResult(decoded));
      if (ok()) {
        decoded_ = std::move(decoded.value());
        ExtractValueFromDecoded(decoded_.pointer());
      }
}namespace test_protocollayoutssamelibrary {

#endif  // __Fuchsia__


#ifdef __Fuchsia__
}  // namespace test_protocollayoutssamelibrary

::fidl::WireUnownedResult<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnon>::WireUnownedResult(::fidl::UnownedClientEnd<::test_protocollayoutssamelibrary::MainProtocol> client_end, ::fidl::internal::AnyBufferAllocator& allocator, ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnon>* request) {
  constexpr uint32_t buffer_size = ::fidl::SyncClientMethodBufferSizeInChannel<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnon>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> allocation = allocator.TryAllocate(buffer_size);
  if (!allocation.is_ok()) {
    SetStatus(allocation.error_value());
    return;
  }
  uint8_t* buffer = allocation->data;constexpr uint32_t request_byte_capacity = ::fidl::MaxSizeInChannel<
        ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnon>, ::fidl::MessageDirection::kSending>();
    uint8_t* request_bytes = buffer;
    static_assert(buffer_size > request_byte_capacity);
    uint32_t response_byte_capacity = buffer_size - request_byte_capacity;
    uint8_t* response_bytes = &buffer[request_byte_capacity];

  ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnon>> request_message(
      request_bytes, request_byte_capacity, request);
  auto& outgoing = request_message.GetOutgoingMessage();
    ::fidl::internal::IncomingMessageHandleStorage<::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnon>> handle_storage;
    ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnon>(
        outgoing.Call(
            client_end.handle(),
            handle_storage.view(fidl::BufferSpan(response_bytes, response_byte_capacity))
        )
    );
    SetStatus(::fidl::internal::StatusFromResult(decoded));
      if (ok()) {
        decoded_ = std::move(decoded.value());
        ExtractValueFromDecoded(decoded_.pointer());
      }
}namespace test_protocollayoutssamelibrary {

#endif  // __Fuchsia__


#ifdef __Fuchsia__
}  // namespace test_protocollayoutssamelibrary

::fidl::WireResult<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonWithError>::WireResult(
    ::fidl::UnownedClientEnd<::test_protocollayoutssamelibrary::MainProtocol> client,
    ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonWithError>* request
) {
  FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonWithError>, ::fidl::internal::ChannelTransport> request_message(
      ::fidl::internal::AllowUnownedInputRef{}, request);
  auto& outgoing = request_message.GetOutgoingMessage();
    ::fidl::internal::IncomingMessageHandleStorage<::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonWithError>> handle_storage;
    ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonWithError>(
        outgoing.Call(client.handle(), handle_storage.view(bytes_.view()), fidl::CallOptions{})
    );
    SetStatus(::fidl::internal::StatusFromResult(decoded));
      if (ok()) {
        decoded_ = std::move(decoded.value());
        ExtractValueFromDecoded(decoded_.pointer());
      }
}namespace test_protocollayoutssamelibrary {

#endif  // __Fuchsia__


#ifdef __Fuchsia__
}  // namespace test_protocollayoutssamelibrary

::fidl::WireUnownedResult<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonWithError>::WireUnownedResult(::fidl::UnownedClientEnd<::test_protocollayoutssamelibrary::MainProtocol> client_end, ::fidl::internal::AnyBufferAllocator& allocator, ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonWithError>* request) {
  constexpr uint32_t buffer_size = ::fidl::SyncClientMethodBufferSizeInChannel<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonWithError>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> allocation = allocator.TryAllocate(buffer_size);
  if (!allocation.is_ok()) {
    SetStatus(allocation.error_value());
    return;
  }
  uint8_t* buffer = allocation->data;constexpr uint32_t request_byte_capacity = ::fidl::MaxSizeInChannel<
        ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonWithError>, ::fidl::MessageDirection::kSending>();
    uint8_t* request_bytes = buffer;
    static_assert(buffer_size > request_byte_capacity);
    uint32_t response_byte_capacity = buffer_size - request_byte_capacity;
    uint8_t* response_bytes = &buffer[request_byte_capacity];

  ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonWithError>> request_message(
      request_bytes, request_byte_capacity, request);
  auto& outgoing = request_message.GetOutgoingMessage();
    ::fidl::internal::IncomingMessageHandleStorage<::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonWithError>> handle_storage;
    ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonWithError>(
        outgoing.Call(
            client_end.handle(),
            handle_storage.view(fidl::BufferSpan(response_bytes, response_byte_capacity))
        )
    );
    SetStatus(::fidl::internal::StatusFromResult(decoded));
      if (ok()) {
        decoded_ = std::move(decoded.value());
        ExtractValueFromDecoded(decoded_.pointer());
      }
}namespace test_protocollayoutssamelibrary {

#endif  // __Fuchsia__



  }  // namespace test_protocollayoutssamelibrary

#ifdef __Fuchsia__

  ::fidl::OneWayStatus fidl::internal::WireWeakOnewayClientImpl<::test_protocollayoutssamelibrary::MainProtocol>::OneWayAnonComposed(::test_protocollayoutssamelibrary::wire::ComposedProtocolOneWayAnonComposedRequest ComposedProtocolOneWayAnonComposedRequest) {
    FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT
    ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::OneWayAnonComposed> _request_object{ ComposedProtocolOneWayAnonComposedRequest };
    ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::OneWayAnonComposed>, ::fidl::internal::ChannelTransport> _request_message(
        ::fidl::internal::AllowUnownedInputRef{}, &_request_object);
    return _client_base()->SendOneWay(_request_message.GetOutgoingMessage());
  }
  ::fidl::OneWayStatus fidl::internal::WireWeakOnewayClientImpl<::test_protocollayoutssamelibrary::MainProtocol>::OneWayNamedComposed(::test_protocollayoutssamelibrary::wire::TablePayload TablePayload) {
    FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT
    ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::OneWayNamedComposed> _request_object{ TablePayload };
    ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::OneWayNamedComposed>, ::fidl::internal::ChannelTransport> _request_message(
        ::fidl::internal::AllowUnownedInputRef{}, &_request_object);
    return _client_base()->SendOneWay(_request_message.GetOutgoingMessage());
  }
  ::fidl::OneWayStatus fidl::internal::WireWeakOnewayClientImpl<::test_protocollayoutssamelibrary::MainProtocol>::OneWayLocal(::test_protocollayoutssamelibrary::wire::TablePayload TablePayload) {
    FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT
    ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::OneWayLocal> _request_object{ TablePayload };
    ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::OneWayLocal>, ::fidl::internal::ChannelTransport> _request_message(
        ::fidl::internal::AllowUnownedInputRef{}, &_request_object);
    return _client_base()->SendOneWay(_request_message.GetOutgoingMessage());
  }
  ::fidl::OneWayStatus fidl::internal::WireWeakOnewayClientImpl<::test_protocollayoutssamelibrary::MainProtocol>::OneWayAnon(::test_protocollayoutssamelibrary::wire::MainProtocolOneWayAnonRequest MainProtocolOneWayAnonRequest) {
    FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT
    ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::OneWayAnon> _request_object{ MainProtocolOneWayAnonRequest };
    ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::OneWayAnon>, ::fidl::internal::ChannelTransport> _request_message(
        ::fidl::internal::AllowUnownedInputRef{}, &_request_object);
    return _client_base()->SendOneWay(_request_message.GetOutgoingMessage());
  }

  ::fidl::internal::WireThenable<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposed> fidl::internal::WireWeakAsyncClientImpl<::test_protocollayoutssamelibrary::MainProtocol>::TwoWayAnonComposed(::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayAnonComposedRequest ComposedProtocolTwoWayAnonComposedRequest) {
    ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposed> _request{ ComposedProtocolTwoWayAnonComposedRequest };
    return ::fidl::internal::WireThenable<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposed>{
        _client_base(), ::fidl::WriteOptions{}, ::fidl::internal::AllowUnownedInputRef{}, &_request};
  }

  ::fidl::internal::WireThenable<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposedWithError> fidl::internal::WireWeakAsyncClientImpl<::test_protocollayoutssamelibrary::MainProtocol>::TwoWayAnonComposedWithError(::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayAnonComposedWithErrorRequest ComposedProtocolTwoWayAnonComposedWithErrorRequest) {
    ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposedWithError> _request{ ComposedProtocolTwoWayAnonComposedWithErrorRequest };
    return ::fidl::internal::WireThenable<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposedWithError>{
        _client_base(), ::fidl::WriteOptions{}, ::fidl::internal::AllowUnownedInputRef{}, &_request};
  }

  ::fidl::internal::WireThenable<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposed> fidl::internal::WireWeakAsyncClientImpl<::test_protocollayoutssamelibrary::MainProtocol>::TwoWayNamedComposed(::test_protocollayoutssamelibrary::wire::UnionPayload UnionPayload) {
    ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposed> _request{ UnionPayload };
    return ::fidl::internal::WireThenable<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposed>{
        _client_base(), ::fidl::WriteOptions{}, ::fidl::internal::AllowUnownedInputRef{}, &_request};
  }

  ::fidl::internal::WireThenable<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposedWithError> fidl::internal::WireWeakAsyncClientImpl<::test_protocollayoutssamelibrary::MainProtocol>::TwoWayNamedComposedWithError(::test_protocollayoutssamelibrary::wire::TablePayload TablePayload) {
    ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposedWithError> _request{ TablePayload };
    return ::fidl::internal::WireThenable<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposedWithError>{
        _client_base(), ::fidl::WriteOptions{}, ::fidl::internal::AllowUnownedInputRef{}, &_request};
  }

  ::fidl::internal::WireThenable<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocal> fidl::internal::WireWeakAsyncClientImpl<::test_protocollayoutssamelibrary::MainProtocol>::TwoWayLocal(::test_protocollayoutssamelibrary::wire::UnionPayload UnionPayload) {
    ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocal> _request{ UnionPayload };
    return ::fidl::internal::WireThenable<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocal>{
        _client_base(), ::fidl::WriteOptions{}, ::fidl::internal::AllowUnownedInputRef{}, &_request};
  }

  ::fidl::internal::WireThenable<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocalWithError> fidl::internal::WireWeakAsyncClientImpl<::test_protocollayoutssamelibrary::MainProtocol>::TwoWayLocalWithError(::test_protocollayoutssamelibrary::wire::TablePayload TablePayload) {
    ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocalWithError> _request{ TablePayload };
    return ::fidl::internal::WireThenable<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocalWithError>{
        _client_base(), ::fidl::WriteOptions{}, ::fidl::internal::AllowUnownedInputRef{}, &_request};
  }

  ::fidl::internal::WireThenable<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnon> fidl::internal::WireWeakAsyncClientImpl<::test_protocollayoutssamelibrary::MainProtocol>::TwoWayAnon(::test_protocollayoutssamelibrary::wire::MainProtocolTwoWayAnonRequest MainProtocolTwoWayAnonRequest) {
    ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnon> _request{ MainProtocolTwoWayAnonRequest };
    return ::fidl::internal::WireThenable<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnon>{
        _client_base(), ::fidl::WriteOptions{}, ::fidl::internal::AllowUnownedInputRef{}, &_request};
  }

  ::fidl::internal::WireThenable<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonWithError> fidl::internal::WireWeakAsyncClientImpl<::test_protocollayoutssamelibrary::MainProtocol>::TwoWayAnonWithError(::test_protocollayoutssamelibrary::wire::MainProtocolTwoWayAnonWithErrorRequest MainProtocolTwoWayAnonWithErrorRequest) {
    ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonWithError> _request{ MainProtocolTwoWayAnonWithErrorRequest };
    return ::fidl::internal::WireThenable<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonWithError>{
        _client_base(), ::fidl::WriteOptions{}, ::fidl::internal::AllowUnownedInputRef{}, &_request};
  }
::fidl::OneWayStatus fidl::internal::WireWeakOnewayBufferClientImpl<::test_protocollayoutssamelibrary::MainProtocol>::OneWayAnonComposed(::test_protocollayoutssamelibrary::wire::ComposedProtocolOneWayAnonComposedRequest ComposedProtocolOneWayAnonComposedRequest) {
  constexpr uint32_t _buffer_size = ::fidl::AsyncClientMethodBufferSizeInChannel<::test_protocollayoutssamelibrary::MainProtocol::OneWayAnonComposed>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    return ::fidl::OneWayStatus{_allocation.error_value()};
  }

  ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::OneWayAnonComposed> _request{ ComposedProtocolOneWayAnonComposedRequest };
  ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::OneWayAnonComposed>> _request_message(
      _allocation->data, _buffer_size, &_request);
  return _client_base()->SendOneWay(_request_message.GetOutgoingMessage());
}
::fidl::OneWayStatus fidl::internal::WireWeakOnewayBufferClientImpl<::test_protocollayoutssamelibrary::MainProtocol>::OneWayNamedComposed(::test_protocollayoutssamelibrary::wire::TablePayload TablePayload) {
  constexpr uint32_t _buffer_size = ::fidl::AsyncClientMethodBufferSizeInChannel<::test_protocollayoutssamelibrary::MainProtocol::OneWayNamedComposed>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    return ::fidl::OneWayStatus{_allocation.error_value()};
  }

  ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::OneWayNamedComposed> _request{ TablePayload };
  ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::OneWayNamedComposed>> _request_message(
      _allocation->data, _buffer_size, &_request);
  return _client_base()->SendOneWay(_request_message.GetOutgoingMessage());
}
::fidl::OneWayStatus fidl::internal::WireWeakOnewayBufferClientImpl<::test_protocollayoutssamelibrary::MainProtocol>::OneWayLocal(::test_protocollayoutssamelibrary::wire::TablePayload TablePayload) {
  constexpr uint32_t _buffer_size = ::fidl::AsyncClientMethodBufferSizeInChannel<::test_protocollayoutssamelibrary::MainProtocol::OneWayLocal>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    return ::fidl::OneWayStatus{_allocation.error_value()};
  }

  ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::OneWayLocal> _request{ TablePayload };
  ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::OneWayLocal>> _request_message(
      _allocation->data, _buffer_size, &_request);
  return _client_base()->SendOneWay(_request_message.GetOutgoingMessage());
}
::fidl::OneWayStatus fidl::internal::WireWeakOnewayBufferClientImpl<::test_protocollayoutssamelibrary::MainProtocol>::OneWayAnon(::test_protocollayoutssamelibrary::wire::MainProtocolOneWayAnonRequest MainProtocolOneWayAnonRequest) {
  constexpr uint32_t _buffer_size = ::fidl::AsyncClientMethodBufferSizeInChannel<::test_protocollayoutssamelibrary::MainProtocol::OneWayAnon>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    return ::fidl::OneWayStatus{_allocation.error_value()};
  }

  ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::OneWayAnon> _request{ MainProtocolOneWayAnonRequest };
  ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::OneWayAnon>> _request_message(
      _allocation->data, _buffer_size, &_request);
  return _client_base()->SendOneWay(_request_message.GetOutgoingMessage());
}
::fidl::internal::WireBufferThenable<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposed> fidl::internal::WireWeakAsyncBufferClientImpl<::test_protocollayoutssamelibrary::MainProtocol>::TwoWayAnonComposed(::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayAnonComposedRequest ComposedProtocolTwoWayAnonComposedRequest) {
  constexpr uint32_t _buffer_size = ::fidl::AsyncClientMethodBufferSizeInChannel<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposed>();
  ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposed> _request{ ComposedProtocolTwoWayAnonComposedRequest };
  return ::fidl::internal::WireBufferThenable<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposed>{
      _client_base(), ::fidl::WriteOptions{}, _allocator(), _buffer_size, &_request};
}
::fidl::internal::WireBufferThenable<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposedWithError> fidl::internal::WireWeakAsyncBufferClientImpl<::test_protocollayoutssamelibrary::MainProtocol>::TwoWayAnonComposedWithError(::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayAnonComposedWithErrorRequest ComposedProtocolTwoWayAnonComposedWithErrorRequest) {
  constexpr uint32_t _buffer_size = ::fidl::AsyncClientMethodBufferSizeInChannel<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposedWithError>();
  ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposedWithError> _request{ ComposedProtocolTwoWayAnonComposedWithErrorRequest };
  return ::fidl::internal::WireBufferThenable<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposedWithError>{
      _client_base(), ::fidl::WriteOptions{}, _allocator(), _buffer_size, &_request};
}
::fidl::internal::WireBufferThenable<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposed> fidl::internal::WireWeakAsyncBufferClientImpl<::test_protocollayoutssamelibrary::MainProtocol>::TwoWayNamedComposed(::test_protocollayoutssamelibrary::wire::UnionPayload UnionPayload) {
  constexpr uint32_t _buffer_size = ::fidl::AsyncClientMethodBufferSizeInChannel<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposed>();
  ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposed> _request{ UnionPayload };
  return ::fidl::internal::WireBufferThenable<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposed>{
      _client_base(), ::fidl::WriteOptions{}, _allocator(), _buffer_size, &_request};
}
::fidl::internal::WireBufferThenable<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposedWithError> fidl::internal::WireWeakAsyncBufferClientImpl<::test_protocollayoutssamelibrary::MainProtocol>::TwoWayNamedComposedWithError(::test_protocollayoutssamelibrary::wire::TablePayload TablePayload) {
  constexpr uint32_t _buffer_size = ::fidl::AsyncClientMethodBufferSizeInChannel<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposedWithError>();
  ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposedWithError> _request{ TablePayload };
  return ::fidl::internal::WireBufferThenable<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposedWithError>{
      _client_base(), ::fidl::WriteOptions{}, _allocator(), _buffer_size, &_request};
}
::fidl::internal::WireBufferThenable<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocal> fidl::internal::WireWeakAsyncBufferClientImpl<::test_protocollayoutssamelibrary::MainProtocol>::TwoWayLocal(::test_protocollayoutssamelibrary::wire::UnionPayload UnionPayload) {
  constexpr uint32_t _buffer_size = ::fidl::AsyncClientMethodBufferSizeInChannel<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocal>();
  ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocal> _request{ UnionPayload };
  return ::fidl::internal::WireBufferThenable<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocal>{
      _client_base(), ::fidl::WriteOptions{}, _allocator(), _buffer_size, &_request};
}
::fidl::internal::WireBufferThenable<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocalWithError> fidl::internal::WireWeakAsyncBufferClientImpl<::test_protocollayoutssamelibrary::MainProtocol>::TwoWayLocalWithError(::test_protocollayoutssamelibrary::wire::TablePayload TablePayload) {
  constexpr uint32_t _buffer_size = ::fidl::AsyncClientMethodBufferSizeInChannel<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocalWithError>();
  ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocalWithError> _request{ TablePayload };
  return ::fidl::internal::WireBufferThenable<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocalWithError>{
      _client_base(), ::fidl::WriteOptions{}, _allocator(), _buffer_size, &_request};
}
::fidl::internal::WireBufferThenable<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnon> fidl::internal::WireWeakAsyncBufferClientImpl<::test_protocollayoutssamelibrary::MainProtocol>::TwoWayAnon(::test_protocollayoutssamelibrary::wire::MainProtocolTwoWayAnonRequest MainProtocolTwoWayAnonRequest) {
  constexpr uint32_t _buffer_size = ::fidl::AsyncClientMethodBufferSizeInChannel<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnon>();
  ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnon> _request{ MainProtocolTwoWayAnonRequest };
  return ::fidl::internal::WireBufferThenable<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnon>{
      _client_base(), ::fidl::WriteOptions{}, _allocator(), _buffer_size, &_request};
}
::fidl::internal::WireBufferThenable<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonWithError> fidl::internal::WireWeakAsyncBufferClientImpl<::test_protocollayoutssamelibrary::MainProtocol>::TwoWayAnonWithError(::test_protocollayoutssamelibrary::wire::MainProtocolTwoWayAnonWithErrorRequest MainProtocolTwoWayAnonWithErrorRequest) {
  constexpr uint32_t _buffer_size = ::fidl::AsyncClientMethodBufferSizeInChannel<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonWithError>();
  ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonWithError> _request{ MainProtocolTwoWayAnonWithErrorRequest };
  return ::fidl::internal::WireBufferThenable<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonWithError>{
      _client_base(), ::fidl::WriteOptions{}, _allocator(), _buffer_size, &_request};
}
  


  ::fidl::WireResult<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposed>
  fidl::internal::WireWeakSyncClientImpl<::test_protocollayoutssamelibrary::MainProtocol>::TwoWayAnonComposed(::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayAnonComposedRequest ComposedProtocolTwoWayAnonComposedRequest) {
    return _client_base()->MakeSyncCallWith(
        [&] (std::shared_ptr<::fidl::internal::AnyTransport> _transport) {
          ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposed> _request{ ComposedProtocolTwoWayAnonComposedRequest };
          return ::fidl::WireResult<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposed>(::fidl::UnownedClientEnd<::test_protocollayoutssamelibrary::MainProtocol>(_transport->get<::fidl::internal::ChannelTransport>()), &_request);
        });
  }
  


  ::fidl::WireResult<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposedWithError>
  fidl::internal::WireWeakSyncClientImpl<::test_protocollayoutssamelibrary::MainProtocol>::TwoWayAnonComposedWithError(::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayAnonComposedWithErrorRequest ComposedProtocolTwoWayAnonComposedWithErrorRequest) {
    return _client_base()->MakeSyncCallWith(
        [&] (std::shared_ptr<::fidl::internal::AnyTransport> _transport) {
          ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposedWithError> _request{ ComposedProtocolTwoWayAnonComposedWithErrorRequest };
          return ::fidl::WireResult<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposedWithError>(::fidl::UnownedClientEnd<::test_protocollayoutssamelibrary::MainProtocol>(_transport->get<::fidl::internal::ChannelTransport>()), &_request);
        });
  }
  


  ::fidl::WireResult<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposed>
  fidl::internal::WireWeakSyncClientImpl<::test_protocollayoutssamelibrary::MainProtocol>::TwoWayNamedComposed(::test_protocollayoutssamelibrary::wire::UnionPayload UnionPayload) {
    return _client_base()->MakeSyncCallWith(
        [&] (std::shared_ptr<::fidl::internal::AnyTransport> _transport) {
          ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposed> _request{ UnionPayload };
          return ::fidl::WireResult<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposed>(::fidl::UnownedClientEnd<::test_protocollayoutssamelibrary::MainProtocol>(_transport->get<::fidl::internal::ChannelTransport>()), &_request);
        });
  }
  


  ::fidl::WireResult<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposedWithError>
  fidl::internal::WireWeakSyncClientImpl<::test_protocollayoutssamelibrary::MainProtocol>::TwoWayNamedComposedWithError(::test_protocollayoutssamelibrary::wire::TablePayload TablePayload) {
    return _client_base()->MakeSyncCallWith(
        [&] (std::shared_ptr<::fidl::internal::AnyTransport> _transport) {
          ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposedWithError> _request{ TablePayload };
          return ::fidl::WireResult<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposedWithError>(::fidl::UnownedClientEnd<::test_protocollayoutssamelibrary::MainProtocol>(_transport->get<::fidl::internal::ChannelTransport>()), &_request);
        });
  }
  


  ::fidl::WireResult<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocal>
  fidl::internal::WireWeakSyncClientImpl<::test_protocollayoutssamelibrary::MainProtocol>::TwoWayLocal(::test_protocollayoutssamelibrary::wire::UnionPayload UnionPayload) {
    return _client_base()->MakeSyncCallWith(
        [&] (std::shared_ptr<::fidl::internal::AnyTransport> _transport) {
          ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocal> _request{ UnionPayload };
          return ::fidl::WireResult<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocal>(::fidl::UnownedClientEnd<::test_protocollayoutssamelibrary::MainProtocol>(_transport->get<::fidl::internal::ChannelTransport>()), &_request);
        });
  }
  


  ::fidl::WireResult<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocalWithError>
  fidl::internal::WireWeakSyncClientImpl<::test_protocollayoutssamelibrary::MainProtocol>::TwoWayLocalWithError(::test_protocollayoutssamelibrary::wire::TablePayload TablePayload) {
    return _client_base()->MakeSyncCallWith(
        [&] (std::shared_ptr<::fidl::internal::AnyTransport> _transport) {
          ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocalWithError> _request{ TablePayload };
          return ::fidl::WireResult<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocalWithError>(::fidl::UnownedClientEnd<::test_protocollayoutssamelibrary::MainProtocol>(_transport->get<::fidl::internal::ChannelTransport>()), &_request);
        });
  }
  


  ::fidl::WireResult<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnon>
  fidl::internal::WireWeakSyncClientImpl<::test_protocollayoutssamelibrary::MainProtocol>::TwoWayAnon(::test_protocollayoutssamelibrary::wire::MainProtocolTwoWayAnonRequest MainProtocolTwoWayAnonRequest) {
    return _client_base()->MakeSyncCallWith(
        [&] (std::shared_ptr<::fidl::internal::AnyTransport> _transport) {
          ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnon> _request{ MainProtocolTwoWayAnonRequest };
          return ::fidl::WireResult<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnon>(::fidl::UnownedClientEnd<::test_protocollayoutssamelibrary::MainProtocol>(_transport->get<::fidl::internal::ChannelTransport>()), &_request);
        });
  }
  


  ::fidl::WireResult<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonWithError>
  fidl::internal::WireWeakSyncClientImpl<::test_protocollayoutssamelibrary::MainProtocol>::TwoWayAnonWithError(::test_protocollayoutssamelibrary::wire::MainProtocolTwoWayAnonWithErrorRequest MainProtocolTwoWayAnonWithErrorRequest) {
    return _client_base()->MakeSyncCallWith(
        [&] (std::shared_ptr<::fidl::internal::AnyTransport> _transport) {
          ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonWithError> _request{ MainProtocolTwoWayAnonWithErrorRequest };
          return ::fidl::WireResult<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonWithError>(::fidl::UnownedClientEnd<::test_protocollayoutssamelibrary::MainProtocol>(_transport->get<::fidl::internal::ChannelTransport>()), &_request);
        });
  }

#endif  // __Fuchsia__





#ifdef __Fuchsia__



  ::fidl::Status fidl::WireSyncEventHandler<::test_protocollayoutssamelibrary::MainProtocol>::HandleOneEvent(
      ::fidl::UnownedClientEnd<::test_protocollayoutssamelibrary::MainProtocol> client_end) {
      ::fidl::internal::IncomingEventsStorage<::test_protocollayoutssamelibrary::MainProtocol> event_storage;
      fidl::internal::WireEventDispatcher<::test_protocollayoutssamelibrary::MainProtocol> dispatcher{this};
      return HandleOneEventImpl_(client_end.channel(), event_storage.view(), dispatcher);
  }
  ::fidl::Status
  fidl::internal::WireEventDispatcher<::test_protocollayoutssamelibrary::MainProtocol>::DispatchEvent(
      ::fidl::IncomingHeaderAndMessage& msg,
      ::fidl::internal::MessageStorageViewBase* storage_view) {
    switch (msg.header()->ordinal) {
      case ::test_protocollayoutssamelibrary::kMainProtocol_OnAnonComposed_Ordinal:
      {
        ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalEvent<::test_protocollayoutssamelibrary::MainProtocol::OnAnonComposed>(
            std::move(msg));
        if (!decoded.is_ok()) {
          return decoded.error_value();
        }
        if (event_handler()) {
            auto* primary = decoded.value().pointer();
          event_handler()->OnAnonComposed(primary);
        }
        return ::fidl::Status::Ok();
      }
      case ::test_protocollayoutssamelibrary::kMainProtocol_OnNamedComposed_Ordinal:
      {
        ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalEvent<::test_protocollayoutssamelibrary::MainProtocol::OnNamedComposed>(
            std::move(msg));
        if (!decoded.is_ok()) {
          return decoded.error_value();
        }
        if (event_handler()) {
            auto* primary = decoded.value().pointer();
          event_handler()->OnNamedComposed(primary);
        }
        return ::fidl::Status::Ok();
      }
      case ::test_protocollayoutssamelibrary::kMainProtocol_OnLocal_Ordinal:
      {
        ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalEvent<::test_protocollayoutssamelibrary::MainProtocol::OnLocal>(
            std::move(msg));
        if (!decoded.is_ok()) {
          return decoded.error_value();
        }
        if (event_handler()) {
            auto* primary = decoded.value().pointer();
          event_handler()->OnLocal(primary);
        }
        return ::fidl::Status::Ok();
      }
      case ::test_protocollayoutssamelibrary::kMainProtocol_OnAnon_Ordinal:
      {
        ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalEvent<::test_protocollayoutssamelibrary::MainProtocol::OnAnon>(
            std::move(msg));
        if (!decoded.is_ok()) {
          return decoded.error_value();
        }
        if (event_handler()) {
            auto* primary = decoded.value().pointer();
          event_handler()->OnAnon(primary);
        }
        return ::fidl::Status::Ok();
      }
      default:
        std::move(msg).CloseHandles();
        return ::fidl::Status::UnknownOrdinal();
    }
  }

#endif  // __Fuchsia__


#ifdef __Fuchsia__



constexpr ::fidl::internal::MethodEntry fidl::internal::WireServerDispatcher<::test_protocollayoutssamelibrary::MainProtocol>::entries_[] = {
    { ::test_protocollayoutssamelibrary::kMainProtocol_OneWayAnonComposed_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::StandaloneInplaceDecode<::test_protocollayoutssamelibrary::wire::ComposedProtocolOneWayAnonComposedRequest>(
            std::move(msg), metadata);
        if (unlikely(!decoded.is_ok())) {
          return decoded.error_value();
        }
        ::fidl::internal::WireCompleter<::test_protocollayoutssamelibrary::MainProtocol::OneWayAnonComposed>::Sync completer(txn);
        reinterpret_cast<::fidl::WireServer<::test_protocollayoutssamelibrary::MainProtocol>*>(interface)->OneWayAnonComposed(
            decoded.value().pointer(),
            completer
        );
        return ::fidl::Status::Ok();
      },
    },
    { ::test_protocollayoutssamelibrary::kMainProtocol_TwoWayAnonComposed_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::StandaloneInplaceDecode<::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayAnonComposedRequest>(
            std::move(msg), metadata);
        if (unlikely(!decoded.is_ok())) {
          return decoded.error_value();
        }
        ::fidl::internal::WireCompleter<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposed>::Sync completer(txn);
        reinterpret_cast<::fidl::WireServer<::test_protocollayoutssamelibrary::MainProtocol>*>(interface)->TwoWayAnonComposed(
            decoded.value().pointer(),
            completer
        );
        return ::fidl::Status::Ok();
      },
    },
    { ::test_protocollayoutssamelibrary::kMainProtocol_TwoWayAnonComposedWithError_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::StandaloneInplaceDecode<::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayAnonComposedWithErrorRequest>(
            std::move(msg), metadata);
        if (unlikely(!decoded.is_ok())) {
          return decoded.error_value();
        }
        ::fidl::internal::WireCompleter<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposedWithError>::Sync completer(txn);
        reinterpret_cast<::fidl::WireServer<::test_protocollayoutssamelibrary::MainProtocol>*>(interface)->TwoWayAnonComposedWithError(
            decoded.value().pointer(),
            completer
        );
        return ::fidl::Status::Ok();
      },
    },
    { ::test_protocollayoutssamelibrary::kMainProtocol_OneWayNamedComposed_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::StandaloneInplaceDecode<::test_protocollayoutssamelibrary::wire::TablePayload>(
            std::move(msg), metadata);
        if (unlikely(!decoded.is_ok())) {
          return decoded.error_value();
        }
        ::fidl::internal::WireCompleter<::test_protocollayoutssamelibrary::MainProtocol::OneWayNamedComposed>::Sync completer(txn);
        reinterpret_cast<::fidl::WireServer<::test_protocollayoutssamelibrary::MainProtocol>*>(interface)->OneWayNamedComposed(
            decoded.value().pointer(),
            completer
        );
        return ::fidl::Status::Ok();
      },
    },
    { ::test_protocollayoutssamelibrary::kMainProtocol_TwoWayNamedComposed_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::StandaloneInplaceDecode<::test_protocollayoutssamelibrary::wire::UnionPayload>(
            std::move(msg), metadata);
        if (unlikely(!decoded.is_ok())) {
          return decoded.error_value();
        }
        ::fidl::internal::WireCompleter<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposed>::Sync completer(txn);
        reinterpret_cast<::fidl::WireServer<::test_protocollayoutssamelibrary::MainProtocol>*>(interface)->TwoWayNamedComposed(
            decoded.value().pointer(),
            completer
        );
        return ::fidl::Status::Ok();
      },
    },
    { ::test_protocollayoutssamelibrary::kMainProtocol_TwoWayNamedComposedWithError_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::StandaloneInplaceDecode<::test_protocollayoutssamelibrary::wire::TablePayload>(
            std::move(msg), metadata);
        if (unlikely(!decoded.is_ok())) {
          return decoded.error_value();
        }
        ::fidl::internal::WireCompleter<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposedWithError>::Sync completer(txn);
        reinterpret_cast<::fidl::WireServer<::test_protocollayoutssamelibrary::MainProtocol>*>(interface)->TwoWayNamedComposedWithError(
            decoded.value().pointer(),
            completer
        );
        return ::fidl::Status::Ok();
      },
    },
    { ::test_protocollayoutssamelibrary::kMainProtocol_OneWayLocal_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::StandaloneInplaceDecode<::test_protocollayoutssamelibrary::wire::TablePayload>(
            std::move(msg), metadata);
        if (unlikely(!decoded.is_ok())) {
          return decoded.error_value();
        }
        ::fidl::internal::WireCompleter<::test_protocollayoutssamelibrary::MainProtocol::OneWayLocal>::Sync completer(txn);
        reinterpret_cast<::fidl::WireServer<::test_protocollayoutssamelibrary::MainProtocol>*>(interface)->OneWayLocal(
            decoded.value().pointer(),
            completer
        );
        return ::fidl::Status::Ok();
      },
    },
    { ::test_protocollayoutssamelibrary::kMainProtocol_TwoWayLocal_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::StandaloneInplaceDecode<::test_protocollayoutssamelibrary::wire::UnionPayload>(
            std::move(msg), metadata);
        if (unlikely(!decoded.is_ok())) {
          return decoded.error_value();
        }
        ::fidl::internal::WireCompleter<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocal>::Sync completer(txn);
        reinterpret_cast<::fidl::WireServer<::test_protocollayoutssamelibrary::MainProtocol>*>(interface)->TwoWayLocal(
            decoded.value().pointer(),
            completer
        );
        return ::fidl::Status::Ok();
      },
    },
    { ::test_protocollayoutssamelibrary::kMainProtocol_TwoWayLocalWithError_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::StandaloneInplaceDecode<::test_protocollayoutssamelibrary::wire::TablePayload>(
            std::move(msg), metadata);
        if (unlikely(!decoded.is_ok())) {
          return decoded.error_value();
        }
        ::fidl::internal::WireCompleter<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocalWithError>::Sync completer(txn);
        reinterpret_cast<::fidl::WireServer<::test_protocollayoutssamelibrary::MainProtocol>*>(interface)->TwoWayLocalWithError(
            decoded.value().pointer(),
            completer
        );
        return ::fidl::Status::Ok();
      },
    },
    { ::test_protocollayoutssamelibrary::kMainProtocol_OneWayAnon_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::StandaloneInplaceDecode<::test_protocollayoutssamelibrary::wire::MainProtocolOneWayAnonRequest>(
            std::move(msg), metadata);
        if (unlikely(!decoded.is_ok())) {
          return decoded.error_value();
        }
        ::fidl::internal::WireCompleter<::test_protocollayoutssamelibrary::MainProtocol::OneWayAnon>::Sync completer(txn);
        reinterpret_cast<::fidl::WireServer<::test_protocollayoutssamelibrary::MainProtocol>*>(interface)->OneWayAnon(
            decoded.value().pointer(),
            completer
        );
        return ::fidl::Status::Ok();
      },
    },
    { ::test_protocollayoutssamelibrary::kMainProtocol_TwoWayAnon_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::StandaloneInplaceDecode<::test_protocollayoutssamelibrary::wire::MainProtocolTwoWayAnonRequest>(
            std::move(msg), metadata);
        if (unlikely(!decoded.is_ok())) {
          return decoded.error_value();
        }
        ::fidl::internal::WireCompleter<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnon>::Sync completer(txn);
        reinterpret_cast<::fidl::WireServer<::test_protocollayoutssamelibrary::MainProtocol>*>(interface)->TwoWayAnon(
            decoded.value().pointer(),
            completer
        );
        return ::fidl::Status::Ok();
      },
    },
    { ::test_protocollayoutssamelibrary::kMainProtocol_TwoWayAnonWithError_Ordinal,
      [](void* interface, ::fidl::EncodedMessage& msg, ::fidl::WireFormatMetadata metadata,
         internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
        ::fit::result decoded = ::fidl::StandaloneInplaceDecode<::test_protocollayoutssamelibrary::wire::MainProtocolTwoWayAnonWithErrorRequest>(
            std::move(msg), metadata);
        if (unlikely(!decoded.is_ok())) {
          return decoded.error_value();
        }
        ::fidl::internal::WireCompleter<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonWithError>::Sync completer(txn);
        reinterpret_cast<::fidl::WireServer<::test_protocollayoutssamelibrary::MainProtocol>*>(interface)->TwoWayAnonWithError(
            decoded.value().pointer(),
            completer
        );
        return ::fidl::Status::Ok();
      },
    },
};

const ::fidl::internal::MethodEntry* fidl::internal::WireServerDispatcher<::test_protocollayoutssamelibrary::MainProtocol>::entries_end_ =
    &entries_[12];

::fidl::DispatchResult fidl::internal::WireServerDispatcher<::test_protocollayoutssamelibrary::MainProtocol>::TryDispatch(
    ::fidl::WireServer<::test_protocollayoutssamelibrary::MainProtocol>* impl, ::fidl::IncomingHeaderAndMessage& msg,
    internal::MessageStorageViewBase* storage_view, ::fidl::Transaction* txn) {
  return ::fidl::internal::TryDispatch(
    impl, msg, storage_view, txn, entries_, entries_end_);
}



void fidl::internal::WireServerDispatcher<::test_protocollayoutssamelibrary::MainProtocol>::Dispatch(::fidl::WireServer<::test_protocollayoutssamelibrary::MainProtocol>* 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::WireServer<::test_protocollayoutssamelibrary::MainProtocol>::dispatch_message(
    ::fidl::IncomingHeaderAndMessage&& msg, ::fidl::Transaction* txn,
    ::fidl::internal::MessageStorageViewBase* storage_view) {
  ::fidl::internal::WireServerDispatcher<::test_protocollayoutssamelibrary::MainProtocol>::Dispatch(this, std::move(msg), storage_view, txn);
}

#endif  // __Fuchsia__



#ifdef __Fuchsia__
void
fidl::internal::WireCompleterImpl<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposed>::Reply(::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayAnonComposedResponse ComposedProtocolTwoWayAnonComposedResponse) {
  return MakeReply(ComposedProtocolTwoWayAnonComposedResponse);
}

void
fidl::internal::WireCompleterImpl<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposed>::MakeReply(::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayAnonComposedResponse ComposedProtocolTwoWayAnonComposedResponse) {
  ::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposed> _response{ ComposedProtocolTwoWayAnonComposedResponse };
  FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT
  ::fidl::internal::OwnedEncodedMessage<
      ::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposed>, ::fidl::internal::ChannelTransport> _response_message{
      ::fidl::internal::AllowUnownedInputRef{}, &_response};
  return _core()->SendReply(&_response_message.GetOutgoingMessage(),
                            ::fidl::internal::OutgoingTransportContext());
}


void
fidl::internal::WireBufferCompleterImpl<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposed>::Reply(::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayAnonComposedResponse ComposedProtocolTwoWayAnonComposedResponse) {
  return MakeReply(ComposedProtocolTwoWayAnonComposedResponse);
}

void
fidl::internal::WireBufferCompleterImpl<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposed>::MakeReply(::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayAnonComposedResponse ComposedProtocolTwoWayAnonComposedResponse) {
  ::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposed> _response{ ComposedProtocolTwoWayAnonComposedResponse };
  constexpr uint32_t _buffer_size = ::fidl::ServerReplyBufferSizeInChannel<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposed>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    ::fidl::OutgoingMessage _failure{_allocation.error_value()};
    return _core()->SendReply(&_failure, ::fidl::internal::OutgoingTransportContext());
  }
  ::fidl::internal::UnownedEncodedMessage<
      ::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposed>, ::fidl::internal::ChannelTransport> _response_message(
      _allocation->data, _buffer_size, &_response);
  return _core()->SendReply(&_response_message.GetOutgoingMessage(),
                            ::fidl::internal::OutgoingTransportContext());
}

#endif  // __Fuchsia__



#ifdef __Fuchsia__
void
fidl::internal::WireCompleterImpl<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposedWithError>::Reply(::fit::result<uint32_t, ::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayAnonComposedWithErrorResponse*> result) {
  if (result.is_ok()) {
    return MakeReply(::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayAnonComposedWithErrorResult::WithResponse(::fidl::ObjectView<::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayAnonComposedWithErrorResponse>::FromExternal(result.value())));
  }
  return ReplyError(std::move(result.error_value()));
}

void
fidl::internal::WireCompleterImpl<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposedWithError>::MakeReply(::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayAnonComposedWithErrorResult ComposedProtocolTwoWayAnonComposedWithErrorResult) {
  ::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposedWithError> _response{ ComposedProtocolTwoWayAnonComposedWithErrorResult };
  FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT
  ::fidl::internal::OwnedEncodedMessage<
      ::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposedWithError>, ::fidl::internal::ChannelTransport> _response_message{
      ::fidl::internal::AllowUnownedInputRef{}, &_response};
  return _core()->SendReply(&_response_message.GetOutgoingMessage(),
                            ::fidl::internal::OutgoingTransportContext());
}
  void
  fidl::internal::WireCompleterImpl<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposedWithError>::ReplySuccess(::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayAnonComposedWithErrorResponse ComposedProtocolTwoWayAnonComposedWithErrorResponse) {
    ::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayAnonComposedWithErrorResponse _response = std::move(ComposedProtocolTwoWayAnonComposedWithErrorResponse);
return MakeReply(::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayAnonComposedWithErrorResult::WithResponse(::fidl::ObjectView<::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayAnonComposedWithErrorResponse>::FromExternal(&_response)));
  }

  void
  fidl::internal::WireCompleterImpl<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposedWithError>::ReplyError(uint32_t error) {
    return MakeReply(::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayAnonComposedWithErrorResult::WithErr(std::move(error)));
  }


void
fidl::internal::WireBufferCompleterImpl<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposedWithError>::Reply(::fit::result<uint32_t, ::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayAnonComposedWithErrorResponse*> result) {
  if (result.is_ok()) {
    return MakeReply(::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayAnonComposedWithErrorResult::WithResponse(::fidl::ObjectView<::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayAnonComposedWithErrorResponse>::FromExternal(result.value())));
  }
  return ReplyError(std::move(result.error_value()));
}

void
fidl::internal::WireBufferCompleterImpl<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposedWithError>::MakeReply(::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayAnonComposedWithErrorResult ComposedProtocolTwoWayAnonComposedWithErrorResult) {
  ::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposedWithError> _response{ ComposedProtocolTwoWayAnonComposedWithErrorResult };
  constexpr uint32_t _buffer_size = ::fidl::ServerReplyBufferSizeInChannel<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposedWithError>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    ::fidl::OutgoingMessage _failure{_allocation.error_value()};
    return _core()->SendReply(&_failure, ::fidl::internal::OutgoingTransportContext());
  }
  ::fidl::internal::UnownedEncodedMessage<
      ::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposedWithError>, ::fidl::internal::ChannelTransport> _response_message(
      _allocation->data, _buffer_size, &_response);
  return _core()->SendReply(&_response_message.GetOutgoingMessage(),
                            ::fidl::internal::OutgoingTransportContext());
}
  void
  fidl::internal::WireBufferCompleterImpl<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposedWithError>::ReplySuccess(::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayAnonComposedWithErrorResponse ComposedProtocolTwoWayAnonComposedWithErrorResponse) {
    ::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayAnonComposedWithErrorResponse _response = std::move(ComposedProtocolTwoWayAnonComposedWithErrorResponse);
return MakeReply(::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayAnonComposedWithErrorResult::WithResponse(::fidl::ObjectView<::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayAnonComposedWithErrorResponse>::FromExternal(&_response)));
  }

  void
  fidl::internal::WireBufferCompleterImpl<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposedWithError>::ReplyError(uint32_t error) {
    return MakeReply(::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayAnonComposedWithErrorResult::WithErr(std::move(error)));
  }

#endif  // __Fuchsia__



#ifdef __Fuchsia__
void
fidl::internal::WireCompleterImpl<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposed>::Reply(::test_protocollayoutssamelibrary::wire::TablePayload TablePayload) {
  return MakeReply(TablePayload);
}

void
fidl::internal::WireCompleterImpl<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposed>::MakeReply(::test_protocollayoutssamelibrary::wire::TablePayload TablePayload) {
  ::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposed> _response{ TablePayload };
  FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT
  ::fidl::internal::OwnedEncodedMessage<
      ::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposed>, ::fidl::internal::ChannelTransport> _response_message{
      ::fidl::internal::AllowUnownedInputRef{}, &_response};
  return _core()->SendReply(&_response_message.GetOutgoingMessage(),
                            ::fidl::internal::OutgoingTransportContext());
}


void
fidl::internal::WireBufferCompleterImpl<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposed>::Reply(::test_protocollayoutssamelibrary::wire::TablePayload TablePayload) {
  return MakeReply(TablePayload);
}

void
fidl::internal::WireBufferCompleterImpl<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposed>::MakeReply(::test_protocollayoutssamelibrary::wire::TablePayload TablePayload) {
  ::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposed> _response{ TablePayload };
  constexpr uint32_t _buffer_size = ::fidl::ServerReplyBufferSizeInChannel<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposed>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    ::fidl::OutgoingMessage _failure{_allocation.error_value()};
    return _core()->SendReply(&_failure, ::fidl::internal::OutgoingTransportContext());
  }
  ::fidl::internal::UnownedEncodedMessage<
      ::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposed>, ::fidl::internal::ChannelTransport> _response_message(
      _allocation->data, _buffer_size, &_response);
  return _core()->SendReply(&_response_message.GetOutgoingMessage(),
                            ::fidl::internal::OutgoingTransportContext());
}

#endif  // __Fuchsia__



#ifdef __Fuchsia__
void
fidl::internal::WireCompleterImpl<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposedWithError>::Reply(::fit::result<uint32_t, ::test_protocollayoutssamelibrary::wire::UnionPayload*> result) {
  if (result.is_ok()) {
    return MakeReply(::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayNamedComposedWithErrorResult::WithResponse(::fidl::ObjectView<::test_protocollayoutssamelibrary::wire::UnionPayload>::FromExternal(result.value())));
  }
  return ReplyError(std::move(result.error_value()));
}

void
fidl::internal::WireCompleterImpl<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposedWithError>::MakeReply(::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayNamedComposedWithErrorResult ComposedProtocolTwoWayNamedComposedWithErrorResult) {
  ::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposedWithError> _response{ ComposedProtocolTwoWayNamedComposedWithErrorResult };
  FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT
  ::fidl::internal::OwnedEncodedMessage<
      ::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposedWithError>, ::fidl::internal::ChannelTransport> _response_message{
      ::fidl::internal::AllowUnownedInputRef{}, &_response};
  return _core()->SendReply(&_response_message.GetOutgoingMessage(),
                            ::fidl::internal::OutgoingTransportContext());
}
  void
  fidl::internal::WireCompleterImpl<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposedWithError>::ReplySuccess(::test_protocollayoutssamelibrary::wire::UnionPayload UnionPayload) {
    ::test_protocollayoutssamelibrary::wire::UnionPayload _response = std::move(UnionPayload);
return MakeReply(::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayNamedComposedWithErrorResult::WithResponse(::fidl::ObjectView<::test_protocollayoutssamelibrary::wire::UnionPayload>::FromExternal(&_response)));
  }

  void
  fidl::internal::WireCompleterImpl<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposedWithError>::ReplyError(uint32_t error) {
    return MakeReply(::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayNamedComposedWithErrorResult::WithErr(std::move(error)));
  }


void
fidl::internal::WireBufferCompleterImpl<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposedWithError>::Reply(::fit::result<uint32_t, ::test_protocollayoutssamelibrary::wire::UnionPayload*> result) {
  if (result.is_ok()) {
    return MakeReply(::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayNamedComposedWithErrorResult::WithResponse(::fidl::ObjectView<::test_protocollayoutssamelibrary::wire::UnionPayload>::FromExternal(result.value())));
  }
  return ReplyError(std::move(result.error_value()));
}

void
fidl::internal::WireBufferCompleterImpl<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposedWithError>::MakeReply(::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayNamedComposedWithErrorResult ComposedProtocolTwoWayNamedComposedWithErrorResult) {
  ::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposedWithError> _response{ ComposedProtocolTwoWayNamedComposedWithErrorResult };
  constexpr uint32_t _buffer_size = ::fidl::ServerReplyBufferSizeInChannel<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposedWithError>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    ::fidl::OutgoingMessage _failure{_allocation.error_value()};
    return _core()->SendReply(&_failure, ::fidl::internal::OutgoingTransportContext());
  }
  ::fidl::internal::UnownedEncodedMessage<
      ::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposedWithError>, ::fidl::internal::ChannelTransport> _response_message(
      _allocation->data, _buffer_size, &_response);
  return _core()->SendReply(&_response_message.GetOutgoingMessage(),
                            ::fidl::internal::OutgoingTransportContext());
}
  void
  fidl::internal::WireBufferCompleterImpl<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposedWithError>::ReplySuccess(::test_protocollayoutssamelibrary::wire::UnionPayload UnionPayload) {
    ::test_protocollayoutssamelibrary::wire::UnionPayload _response = std::move(UnionPayload);
return MakeReply(::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayNamedComposedWithErrorResult::WithResponse(::fidl::ObjectView<::test_protocollayoutssamelibrary::wire::UnionPayload>::FromExternal(&_response)));
  }

  void
  fidl::internal::WireBufferCompleterImpl<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposedWithError>::ReplyError(uint32_t error) {
    return MakeReply(::test_protocollayoutssamelibrary::wire::ComposedProtocolTwoWayNamedComposedWithErrorResult::WithErr(std::move(error)));
  }

#endif  // __Fuchsia__



#ifdef __Fuchsia__
void
fidl::internal::WireCompleterImpl<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocal>::Reply(::test_protocollayoutssamelibrary::wire::TablePayload TablePayload) {
  return MakeReply(TablePayload);
}

void
fidl::internal::WireCompleterImpl<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocal>::MakeReply(::test_protocollayoutssamelibrary::wire::TablePayload TablePayload) {
  ::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocal> _response{ TablePayload };
  FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT
  ::fidl::internal::OwnedEncodedMessage<
      ::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocal>, ::fidl::internal::ChannelTransport> _response_message{
      ::fidl::internal::AllowUnownedInputRef{}, &_response};
  return _core()->SendReply(&_response_message.GetOutgoingMessage(),
                            ::fidl::internal::OutgoingTransportContext());
}


void
fidl::internal::WireBufferCompleterImpl<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocal>::Reply(::test_protocollayoutssamelibrary::wire::TablePayload TablePayload) {
  return MakeReply(TablePayload);
}

void
fidl::internal::WireBufferCompleterImpl<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocal>::MakeReply(::test_protocollayoutssamelibrary::wire::TablePayload TablePayload) {
  ::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocal> _response{ TablePayload };
  constexpr uint32_t _buffer_size = ::fidl::ServerReplyBufferSizeInChannel<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocal>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    ::fidl::OutgoingMessage _failure{_allocation.error_value()};
    return _core()->SendReply(&_failure, ::fidl::internal::OutgoingTransportContext());
  }
  ::fidl::internal::UnownedEncodedMessage<
      ::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocal>, ::fidl::internal::ChannelTransport> _response_message(
      _allocation->data, _buffer_size, &_response);
  return _core()->SendReply(&_response_message.GetOutgoingMessage(),
                            ::fidl::internal::OutgoingTransportContext());
}

#endif  // __Fuchsia__



#ifdef __Fuchsia__
void
fidl::internal::WireCompleterImpl<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocalWithError>::Reply(::fit::result<uint32_t, ::test_protocollayoutssamelibrary::wire::UnionPayload*> result) {
  if (result.is_ok()) {
    return MakeReply(::test_protocollayoutssamelibrary::wire::MainProtocolTwoWayLocalWithErrorResult::WithResponse(::fidl::ObjectView<::test_protocollayoutssamelibrary::wire::UnionPayload>::FromExternal(result.value())));
  }
  return ReplyError(std::move(result.error_value()));
}

void
fidl::internal::WireCompleterImpl<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocalWithError>::MakeReply(::test_protocollayoutssamelibrary::wire::MainProtocolTwoWayLocalWithErrorResult MainProtocolTwoWayLocalWithErrorResult) {
  ::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocalWithError> _response{ MainProtocolTwoWayLocalWithErrorResult };
  FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT
  ::fidl::internal::OwnedEncodedMessage<
      ::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocalWithError>, ::fidl::internal::ChannelTransport> _response_message{
      ::fidl::internal::AllowUnownedInputRef{}, &_response};
  return _core()->SendReply(&_response_message.GetOutgoingMessage(),
                            ::fidl::internal::OutgoingTransportContext());
}
  void
  fidl::internal::WireCompleterImpl<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocalWithError>::ReplySuccess(::test_protocollayoutssamelibrary::wire::UnionPayload UnionPayload) {
    ::test_protocollayoutssamelibrary::wire::UnionPayload _response = std::move(UnionPayload);
return MakeReply(::test_protocollayoutssamelibrary::wire::MainProtocolTwoWayLocalWithErrorResult::WithResponse(::fidl::ObjectView<::test_protocollayoutssamelibrary::wire::UnionPayload>::FromExternal(&_response)));
  }

  void
  fidl::internal::WireCompleterImpl<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocalWithError>::ReplyError(uint32_t error) {
    return MakeReply(::test_protocollayoutssamelibrary::wire::MainProtocolTwoWayLocalWithErrorResult::WithErr(std::move(error)));
  }


void
fidl::internal::WireBufferCompleterImpl<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocalWithError>::Reply(::fit::result<uint32_t, ::test_protocollayoutssamelibrary::wire::UnionPayload*> result) {
  if (result.is_ok()) {
    return MakeReply(::test_protocollayoutssamelibrary::wire::MainProtocolTwoWayLocalWithErrorResult::WithResponse(::fidl::ObjectView<::test_protocollayoutssamelibrary::wire::UnionPayload>::FromExternal(result.value())));
  }
  return ReplyError(std::move(result.error_value()));
}

void
fidl::internal::WireBufferCompleterImpl<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocalWithError>::MakeReply(::test_protocollayoutssamelibrary::wire::MainProtocolTwoWayLocalWithErrorResult MainProtocolTwoWayLocalWithErrorResult) {
  ::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocalWithError> _response{ MainProtocolTwoWayLocalWithErrorResult };
  constexpr uint32_t _buffer_size = ::fidl::ServerReplyBufferSizeInChannel<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocalWithError>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    ::fidl::OutgoingMessage _failure{_allocation.error_value()};
    return _core()->SendReply(&_failure, ::fidl::internal::OutgoingTransportContext());
  }
  ::fidl::internal::UnownedEncodedMessage<
      ::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocalWithError>, ::fidl::internal::ChannelTransport> _response_message(
      _allocation->data, _buffer_size, &_response);
  return _core()->SendReply(&_response_message.GetOutgoingMessage(),
                            ::fidl::internal::OutgoingTransportContext());
}
  void
  fidl::internal::WireBufferCompleterImpl<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocalWithError>::ReplySuccess(::test_protocollayoutssamelibrary::wire::UnionPayload UnionPayload) {
    ::test_protocollayoutssamelibrary::wire::UnionPayload _response = std::move(UnionPayload);
return MakeReply(::test_protocollayoutssamelibrary::wire::MainProtocolTwoWayLocalWithErrorResult::WithResponse(::fidl::ObjectView<::test_protocollayoutssamelibrary::wire::UnionPayload>::FromExternal(&_response)));
  }

  void
  fidl::internal::WireBufferCompleterImpl<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocalWithError>::ReplyError(uint32_t error) {
    return MakeReply(::test_protocollayoutssamelibrary::wire::MainProtocolTwoWayLocalWithErrorResult::WithErr(std::move(error)));
  }

#endif  // __Fuchsia__



#ifdef __Fuchsia__
void
fidl::internal::WireCompleterImpl<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnon>::Reply(::test_protocollayoutssamelibrary::wire::MainProtocolTwoWayAnonResponse MainProtocolTwoWayAnonResponse) {
  return MakeReply(MainProtocolTwoWayAnonResponse);
}

void
fidl::internal::WireCompleterImpl<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnon>::MakeReply(::test_protocollayoutssamelibrary::wire::MainProtocolTwoWayAnonResponse MainProtocolTwoWayAnonResponse) {
  ::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnon> _response{ MainProtocolTwoWayAnonResponse };
  FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT
  ::fidl::internal::OwnedEncodedMessage<
      ::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnon>, ::fidl::internal::ChannelTransport> _response_message{
      ::fidl::internal::AllowUnownedInputRef{}, &_response};
  return _core()->SendReply(&_response_message.GetOutgoingMessage(),
                            ::fidl::internal::OutgoingTransportContext());
}


void
fidl::internal::WireBufferCompleterImpl<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnon>::Reply(::test_protocollayoutssamelibrary::wire::MainProtocolTwoWayAnonResponse MainProtocolTwoWayAnonResponse) {
  return MakeReply(MainProtocolTwoWayAnonResponse);
}

void
fidl::internal::WireBufferCompleterImpl<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnon>::MakeReply(::test_protocollayoutssamelibrary::wire::MainProtocolTwoWayAnonResponse MainProtocolTwoWayAnonResponse) {
  ::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnon> _response{ MainProtocolTwoWayAnonResponse };
  constexpr uint32_t _buffer_size = ::fidl::ServerReplyBufferSizeInChannel<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnon>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    ::fidl::OutgoingMessage _failure{_allocation.error_value()};
    return _core()->SendReply(&_failure, ::fidl::internal::OutgoingTransportContext());
  }
  ::fidl::internal::UnownedEncodedMessage<
      ::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnon>, ::fidl::internal::ChannelTransport> _response_message(
      _allocation->data, _buffer_size, &_response);
  return _core()->SendReply(&_response_message.GetOutgoingMessage(),
                            ::fidl::internal::OutgoingTransportContext());
}

#endif  // __Fuchsia__



#ifdef __Fuchsia__
void
fidl::internal::WireCompleterImpl<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonWithError>::Reply(::fit::result<uint32_t, ::test_protocollayoutssamelibrary::wire::MainProtocolTwoWayAnonWithErrorResponse*> result) {
  if (result.is_ok()) {
    return MakeReply(::test_protocollayoutssamelibrary::wire::MainProtocolTwoWayAnonWithErrorResult::WithResponse(::fidl::ObjectView<::test_protocollayoutssamelibrary::wire::MainProtocolTwoWayAnonWithErrorResponse>::FromExternal(result.value())));
  }
  return ReplyError(std::move(result.error_value()));
}

void
fidl::internal::WireCompleterImpl<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonWithError>::MakeReply(::test_protocollayoutssamelibrary::wire::MainProtocolTwoWayAnonWithErrorResult MainProtocolTwoWayAnonWithErrorResult) {
  ::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonWithError> _response{ MainProtocolTwoWayAnonWithErrorResult };
  FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT
  ::fidl::internal::OwnedEncodedMessage<
      ::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonWithError>, ::fidl::internal::ChannelTransport> _response_message{
      ::fidl::internal::AllowUnownedInputRef{}, &_response};
  return _core()->SendReply(&_response_message.GetOutgoingMessage(),
                            ::fidl::internal::OutgoingTransportContext());
}
  void
  fidl::internal::WireCompleterImpl<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonWithError>::ReplySuccess(::test_protocollayoutssamelibrary::wire::MainProtocolTwoWayAnonWithErrorResponse MainProtocolTwoWayAnonWithErrorResponse) {
    ::test_protocollayoutssamelibrary::wire::MainProtocolTwoWayAnonWithErrorResponse _response = std::move(MainProtocolTwoWayAnonWithErrorResponse);
return MakeReply(::test_protocollayoutssamelibrary::wire::MainProtocolTwoWayAnonWithErrorResult::WithResponse(::fidl::ObjectView<::test_protocollayoutssamelibrary::wire::MainProtocolTwoWayAnonWithErrorResponse>::FromExternal(&_response)));
  }

  void
  fidl::internal::WireCompleterImpl<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonWithError>::ReplyError(uint32_t error) {
    return MakeReply(::test_protocollayoutssamelibrary::wire::MainProtocolTwoWayAnonWithErrorResult::WithErr(std::move(error)));
  }


void
fidl::internal::WireBufferCompleterImpl<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonWithError>::Reply(::fit::result<uint32_t, ::test_protocollayoutssamelibrary::wire::MainProtocolTwoWayAnonWithErrorResponse*> result) {
  if (result.is_ok()) {
    return MakeReply(::test_protocollayoutssamelibrary::wire::MainProtocolTwoWayAnonWithErrorResult::WithResponse(::fidl::ObjectView<::test_protocollayoutssamelibrary::wire::MainProtocolTwoWayAnonWithErrorResponse>::FromExternal(result.value())));
  }
  return ReplyError(std::move(result.error_value()));
}

void
fidl::internal::WireBufferCompleterImpl<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonWithError>::MakeReply(::test_protocollayoutssamelibrary::wire::MainProtocolTwoWayAnonWithErrorResult MainProtocolTwoWayAnonWithErrorResult) {
  ::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonWithError> _response{ MainProtocolTwoWayAnonWithErrorResult };
  constexpr uint32_t _buffer_size = ::fidl::ServerReplyBufferSizeInChannel<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonWithError>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    ::fidl::OutgoingMessage _failure{_allocation.error_value()};
    return _core()->SendReply(&_failure, ::fidl::internal::OutgoingTransportContext());
  }
  ::fidl::internal::UnownedEncodedMessage<
      ::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonWithError>, ::fidl::internal::ChannelTransport> _response_message(
      _allocation->data, _buffer_size, &_response);
  return _core()->SendReply(&_response_message.GetOutgoingMessage(),
                            ::fidl::internal::OutgoingTransportContext());
}
  void
  fidl::internal::WireBufferCompleterImpl<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonWithError>::ReplySuccess(::test_protocollayoutssamelibrary::wire::MainProtocolTwoWayAnonWithErrorResponse MainProtocolTwoWayAnonWithErrorResponse) {
    ::test_protocollayoutssamelibrary::wire::MainProtocolTwoWayAnonWithErrorResponse _response = std::move(MainProtocolTwoWayAnonWithErrorResponse);
return MakeReply(::test_protocollayoutssamelibrary::wire::MainProtocolTwoWayAnonWithErrorResult::WithResponse(::fidl::ObjectView<::test_protocollayoutssamelibrary::wire::MainProtocolTwoWayAnonWithErrorResponse>::FromExternal(&_response)));
  }

  void
  fidl::internal::WireBufferCompleterImpl<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonWithError>::ReplyError(uint32_t error) {
    return MakeReply(::test_protocollayoutssamelibrary::wire::MainProtocolTwoWayAnonWithErrorResult::WithErr(std::move(error)));
  }

#endif  // __Fuchsia__


#ifdef __Fuchsia__
void ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::OneWayAnonComposed>::_InitHeader() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayoutssamelibrary::kMainProtocol_OneWayAnonComposed_Ordinal, ::test_protocollayoutssamelibrary::kMainProtocol_OneWayAnonComposed_DynamicFlags);
  }

#endif  // __Fuchsia__

    
    

#ifdef __Fuchsia__
void ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposed>::_InitHeader() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayoutssamelibrary::kMainProtocol_TwoWayAnonComposed_Ordinal, ::test_protocollayoutssamelibrary::kMainProtocol_TwoWayAnonComposed_DynamicFlags);
  }

#endif  // __Fuchsia__

    
    

  void ::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposed>::_InitHeader() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayoutssamelibrary::kMainProtocol_TwoWayAnonComposed_Ordinal, ::test_protocollayoutssamelibrary::kMainProtocol_TwoWayAnonComposed_DynamicFlags);
  }
    
    

#ifdef __Fuchsia__
void ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposedWithError>::_InitHeader() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayoutssamelibrary::kMainProtocol_TwoWayAnonComposedWithError_Ordinal, ::test_protocollayoutssamelibrary::kMainProtocol_TwoWayAnonComposedWithError_DynamicFlags);
  }

#endif  // __Fuchsia__

    
    

  void ::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonComposedWithError>::_InitHeader() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayoutssamelibrary::kMainProtocol_TwoWayAnonComposedWithError_Ordinal, ::test_protocollayoutssamelibrary::kMainProtocol_TwoWayAnonComposedWithError_DynamicFlags);
  }
    
    
    
    

#ifdef __Fuchsia__
void ::fidl::internal::TransactionalEvent<::test_protocollayoutssamelibrary::MainProtocol::OnAnonComposed>::_InitHeader() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayoutssamelibrary::kMainProtocol_OnAnonComposed_Ordinal, ::test_protocollayoutssamelibrary::kMainProtocol_OnAnonComposed_DynamicFlags);
  }

#endif  // __Fuchsia__

    
    

#ifdef __Fuchsia__
void ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::OneWayNamedComposed>::_InitHeader() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayoutssamelibrary::kMainProtocol_OneWayNamedComposed_Ordinal, ::test_protocollayoutssamelibrary::kMainProtocol_OneWayNamedComposed_DynamicFlags);
  }

#endif  // __Fuchsia__

    
    

#ifdef __Fuchsia__
void ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposed>::_InitHeader() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayoutssamelibrary::kMainProtocol_TwoWayNamedComposed_Ordinal, ::test_protocollayoutssamelibrary::kMainProtocol_TwoWayNamedComposed_DynamicFlags);
  }

#endif  // __Fuchsia__

    
    

  void ::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposed>::_InitHeader() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayoutssamelibrary::kMainProtocol_TwoWayNamedComposed_Ordinal, ::test_protocollayoutssamelibrary::kMainProtocol_TwoWayNamedComposed_DynamicFlags);
  }
    
    

#ifdef __Fuchsia__
void ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposedWithError>::_InitHeader() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayoutssamelibrary::kMainProtocol_TwoWayNamedComposedWithError_Ordinal, ::test_protocollayoutssamelibrary::kMainProtocol_TwoWayNamedComposedWithError_DynamicFlags);
  }

#endif  // __Fuchsia__

    
    

  void ::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayNamedComposedWithError>::_InitHeader() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayoutssamelibrary::kMainProtocol_TwoWayNamedComposedWithError_Ordinal, ::test_protocollayoutssamelibrary::kMainProtocol_TwoWayNamedComposedWithError_DynamicFlags);
  }
    
    
    
    

#ifdef __Fuchsia__
void ::fidl::internal::TransactionalEvent<::test_protocollayoutssamelibrary::MainProtocol::OnNamedComposed>::_InitHeader() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayoutssamelibrary::kMainProtocol_OnNamedComposed_Ordinal, ::test_protocollayoutssamelibrary::kMainProtocol_OnNamedComposed_DynamicFlags);
  }

#endif  // __Fuchsia__

    
    

#ifdef __Fuchsia__
void ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::OneWayLocal>::_InitHeader() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayoutssamelibrary::kMainProtocol_OneWayLocal_Ordinal, ::test_protocollayoutssamelibrary::kMainProtocol_OneWayLocal_DynamicFlags);
  }

#endif  // __Fuchsia__

    
    

#ifdef __Fuchsia__
void ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocal>::_InitHeader() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayoutssamelibrary::kMainProtocol_TwoWayLocal_Ordinal, ::test_protocollayoutssamelibrary::kMainProtocol_TwoWayLocal_DynamicFlags);
  }

#endif  // __Fuchsia__

    
    

  void ::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocal>::_InitHeader() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayoutssamelibrary::kMainProtocol_TwoWayLocal_Ordinal, ::test_protocollayoutssamelibrary::kMainProtocol_TwoWayLocal_DynamicFlags);
  }
    
    

#ifdef __Fuchsia__
void ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocalWithError>::_InitHeader() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayoutssamelibrary::kMainProtocol_TwoWayLocalWithError_Ordinal, ::test_protocollayoutssamelibrary::kMainProtocol_TwoWayLocalWithError_DynamicFlags);
  }

#endif  // __Fuchsia__

    
    

  void ::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayLocalWithError>::_InitHeader() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayoutssamelibrary::kMainProtocol_TwoWayLocalWithError_Ordinal, ::test_protocollayoutssamelibrary::kMainProtocol_TwoWayLocalWithError_DynamicFlags);
  }
    
    
    
    

#ifdef __Fuchsia__
void ::fidl::internal::TransactionalEvent<::test_protocollayoutssamelibrary::MainProtocol::OnLocal>::_InitHeader() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayoutssamelibrary::kMainProtocol_OnLocal_Ordinal, ::test_protocollayoutssamelibrary::kMainProtocol_OnLocal_DynamicFlags);
  }

#endif  // __Fuchsia__

    
    

#ifdef __Fuchsia__
void ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::OneWayAnon>::_InitHeader() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayoutssamelibrary::kMainProtocol_OneWayAnon_Ordinal, ::test_protocollayoutssamelibrary::kMainProtocol_OneWayAnon_DynamicFlags);
  }

#endif  // __Fuchsia__

    
    

#ifdef __Fuchsia__
void ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnon>::_InitHeader() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayoutssamelibrary::kMainProtocol_TwoWayAnon_Ordinal, ::test_protocollayoutssamelibrary::kMainProtocol_TwoWayAnon_DynamicFlags);
  }

#endif  // __Fuchsia__

    
    

  void ::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnon>::_InitHeader() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayoutssamelibrary::kMainProtocol_TwoWayAnon_Ordinal, ::test_protocollayoutssamelibrary::kMainProtocol_TwoWayAnon_DynamicFlags);
  }
    
    

#ifdef __Fuchsia__
void ::fidl::internal::TransactionalRequest<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonWithError>::_InitHeader() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayoutssamelibrary::kMainProtocol_TwoWayAnonWithError_Ordinal, ::test_protocollayoutssamelibrary::kMainProtocol_TwoWayAnonWithError_DynamicFlags);
  }

#endif  // __Fuchsia__

    
    

  void ::fidl::internal::TransactionalResponse<::test_protocollayoutssamelibrary::MainProtocol::TwoWayAnonWithError>::_InitHeader() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayoutssamelibrary::kMainProtocol_TwoWayAnonWithError_Ordinal, ::test_protocollayoutssamelibrary::kMainProtocol_TwoWayAnonWithError_DynamicFlags);
  }
    
    
    
    

#ifdef __Fuchsia__
void ::fidl::internal::TransactionalEvent<::test_protocollayoutssamelibrary::MainProtocol::OnAnon>::_InitHeader() {
    ::fidl::InitTxnHeader(&header, 0, ::test_protocollayoutssamelibrary::kMainProtocol_OnAnon_Ordinal, ::test_protocollayoutssamelibrary::kMainProtocol_OnAnon_DynamicFlags);
  }

#endif  // __Fuchsia__

    
    
  


#ifdef __Fuchsia__

::fidl::OneWayStatus fidl::internal::WireWeakEventSender<::test_protocollayoutssamelibrary::MainProtocol>::OnAnonComposed(::test_protocollayoutssamelibrary::wire::ComposedProtocolOnAnonComposedRequest ComposedProtocolOnAnonComposedRequest) {
  ::fidl::internal::TransactionalEvent<::test_protocollayoutssamelibrary::MainProtocol::OnAnonComposed> _response{ComposedProtocolOnAnonComposedRequest };
  FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalEvent<::test_protocollayoutssamelibrary::MainProtocol::OnAnonComposed>, ::fidl::internal::ChannelTransport> _response_message{
      ::fidl::internal::AllowUnownedInputRef{}, &_response
  };
  return _inner().SendEvent(_response_message.GetOutgoingMessage());
}

fidl::OneWayStatus fidl::internal::WireWeakBufferEventSender<::test_protocollayoutssamelibrary::MainProtocol>::OnAnonComposed(::test_protocollayoutssamelibrary::wire::ComposedProtocolOnAnonComposedRequest ComposedProtocolOnAnonComposedRequest) {
  constexpr uint32_t _buffer_size = ::fidl::EventReplyBufferSizeInChannel<::test_protocollayoutssamelibrary::MainProtocol::OnAnonComposed>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    _inner().HandleSendError(_allocation.error_value());
    return fidl::OneWayStatus{_allocation.error_value()};
  }

  ::fidl::internal::TransactionalEvent<::test_protocollayoutssamelibrary::MainProtocol::OnAnonComposed> _response{ComposedProtocolOnAnonComposedRequest };
  ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalEvent<::test_protocollayoutssamelibrary::MainProtocol::OnAnonComposed>, ::fidl::internal::ChannelTransport> _response_message(
      _allocation->data, _buffer_size, &_response);
  return _inner().SendEvent(_response_message.GetOutgoingMessage());
}

fidl::OneWayStatus fidl::internal::WireEventSender<::test_protocollayoutssamelibrary::MainProtocol>::OnAnonComposed(::test_protocollayoutssamelibrary::wire::ComposedProtocolOnAnonComposedRequest ComposedProtocolOnAnonComposedRequest) {
  ::fidl::internal::TransactionalEvent<::test_protocollayoutssamelibrary::MainProtocol::OnAnonComposed> _response{ComposedProtocolOnAnonComposedRequest };
  FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalEvent<::test_protocollayoutssamelibrary::MainProtocol::OnAnonComposed>, ::fidl::internal::ChannelTransport> _response_message{
      ::fidl::internal::AllowUnownedInputRef{}, &_response
  };
  auto& _message = _response_message.GetOutgoingMessage();
  _message.Write(_transport());
  return ::fidl::OneWayStatus{::fidl::Status{_message}};
}

fidl::OneWayStatus fidl::internal::WireBufferEventSender<::test_protocollayoutssamelibrary::MainProtocol>::OnAnonComposed(::test_protocollayoutssamelibrary::wire::ComposedProtocolOnAnonComposedRequest ComposedProtocolOnAnonComposedRequest) {
  constexpr uint32_t _buffer_size = ::fidl::EventReplyBufferSizeInChannel<::test_protocollayoutssamelibrary::MainProtocol::OnAnonComposed>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    return fidl::OneWayStatus{_allocation.error_value()};
  }

  ::fidl::internal::TransactionalEvent<::test_protocollayoutssamelibrary::MainProtocol::OnAnonComposed> _response{ComposedProtocolOnAnonComposedRequest };
  ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalEvent<::test_protocollayoutssamelibrary::MainProtocol::OnAnonComposed>, ::fidl::internal::ChannelTransport> _response_message(
        _allocation->data, _buffer_size, &_response);
  auto& _message = _response_message.GetOutgoingMessage();
  _message.Write(_transport());
  return ::fidl::OneWayStatus{::fidl::Status{_message}};
}

::fidl::OneWayStatus fidl::internal::WireWeakEventSender<::test_protocollayoutssamelibrary::MainProtocol>::OnNamedComposed(::test_protocollayoutssamelibrary::wire::UnionPayload UnionPayload) {
  ::fidl::internal::TransactionalEvent<::test_protocollayoutssamelibrary::MainProtocol::OnNamedComposed> _response{UnionPayload };
  FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalEvent<::test_protocollayoutssamelibrary::MainProtocol::OnNamedComposed>, ::fidl::internal::ChannelTransport> _response_message{
      ::fidl::internal::AllowUnownedInputRef{}, &_response
  };
  return _inner().SendEvent(_response_message.GetOutgoingMessage());
}

fidl::OneWayStatus fidl::internal::WireWeakBufferEventSender<::test_protocollayoutssamelibrary::MainProtocol>::OnNamedComposed(::test_protocollayoutssamelibrary::wire::UnionPayload UnionPayload) {
  constexpr uint32_t _buffer_size = ::fidl::EventReplyBufferSizeInChannel<::test_protocollayoutssamelibrary::MainProtocol::OnNamedComposed>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    _inner().HandleSendError(_allocation.error_value());
    return fidl::OneWayStatus{_allocation.error_value()};
  }

  ::fidl::internal::TransactionalEvent<::test_protocollayoutssamelibrary::MainProtocol::OnNamedComposed> _response{UnionPayload };
  ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalEvent<::test_protocollayoutssamelibrary::MainProtocol::OnNamedComposed>, ::fidl::internal::ChannelTransport> _response_message(
      _allocation->data, _buffer_size, &_response);
  return _inner().SendEvent(_response_message.GetOutgoingMessage());
}

fidl::OneWayStatus fidl::internal::WireEventSender<::test_protocollayoutssamelibrary::MainProtocol>::OnNamedComposed(::test_protocollayoutssamelibrary::wire::UnionPayload UnionPayload) {
  ::fidl::internal::TransactionalEvent<::test_protocollayoutssamelibrary::MainProtocol::OnNamedComposed> _response{UnionPayload };
  FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalEvent<::test_protocollayoutssamelibrary::MainProtocol::OnNamedComposed>, ::fidl::internal::ChannelTransport> _response_message{
      ::fidl::internal::AllowUnownedInputRef{}, &_response
  };
  auto& _message = _response_message.GetOutgoingMessage();
  _message.Write(_transport());
  return ::fidl::OneWayStatus{::fidl::Status{_message}};
}

fidl::OneWayStatus fidl::internal::WireBufferEventSender<::test_protocollayoutssamelibrary::MainProtocol>::OnNamedComposed(::test_protocollayoutssamelibrary::wire::UnionPayload UnionPayload) {
  constexpr uint32_t _buffer_size = ::fidl::EventReplyBufferSizeInChannel<::test_protocollayoutssamelibrary::MainProtocol::OnNamedComposed>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    return fidl::OneWayStatus{_allocation.error_value()};
  }

  ::fidl::internal::TransactionalEvent<::test_protocollayoutssamelibrary::MainProtocol::OnNamedComposed> _response{UnionPayload };
  ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalEvent<::test_protocollayoutssamelibrary::MainProtocol::OnNamedComposed>, ::fidl::internal::ChannelTransport> _response_message(
        _allocation->data, _buffer_size, &_response);
  auto& _message = _response_message.GetOutgoingMessage();
  _message.Write(_transport());
  return ::fidl::OneWayStatus{::fidl::Status{_message}};
}

::fidl::OneWayStatus fidl::internal::WireWeakEventSender<::test_protocollayoutssamelibrary::MainProtocol>::OnLocal(::test_protocollayoutssamelibrary::wire::UnionPayload UnionPayload) {
  ::fidl::internal::TransactionalEvent<::test_protocollayoutssamelibrary::MainProtocol::OnLocal> _response{UnionPayload };
  FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalEvent<::test_protocollayoutssamelibrary::MainProtocol::OnLocal>, ::fidl::internal::ChannelTransport> _response_message{
      ::fidl::internal::AllowUnownedInputRef{}, &_response
  };
  return _inner().SendEvent(_response_message.GetOutgoingMessage());
}

fidl::OneWayStatus fidl::internal::WireWeakBufferEventSender<::test_protocollayoutssamelibrary::MainProtocol>::OnLocal(::test_protocollayoutssamelibrary::wire::UnionPayload UnionPayload) {
  constexpr uint32_t _buffer_size = ::fidl::EventReplyBufferSizeInChannel<::test_protocollayoutssamelibrary::MainProtocol::OnLocal>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    _inner().HandleSendError(_allocation.error_value());
    return fidl::OneWayStatus{_allocation.error_value()};
  }

  ::fidl::internal::TransactionalEvent<::test_protocollayoutssamelibrary::MainProtocol::OnLocal> _response{UnionPayload };
  ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalEvent<::test_protocollayoutssamelibrary::MainProtocol::OnLocal>, ::fidl::internal::ChannelTransport> _response_message(
      _allocation->data, _buffer_size, &_response);
  return _inner().SendEvent(_response_message.GetOutgoingMessage());
}

fidl::OneWayStatus fidl::internal::WireEventSender<::test_protocollayoutssamelibrary::MainProtocol>::OnLocal(::test_protocollayoutssamelibrary::wire::UnionPayload UnionPayload) {
  ::fidl::internal::TransactionalEvent<::test_protocollayoutssamelibrary::MainProtocol::OnLocal> _response{UnionPayload };
  FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalEvent<::test_protocollayoutssamelibrary::MainProtocol::OnLocal>, ::fidl::internal::ChannelTransport> _response_message{
      ::fidl::internal::AllowUnownedInputRef{}, &_response
  };
  auto& _message = _response_message.GetOutgoingMessage();
  _message.Write(_transport());
  return ::fidl::OneWayStatus{::fidl::Status{_message}};
}

fidl::OneWayStatus fidl::internal::WireBufferEventSender<::test_protocollayoutssamelibrary::MainProtocol>::OnLocal(::test_protocollayoutssamelibrary::wire::UnionPayload UnionPayload) {
  constexpr uint32_t _buffer_size = ::fidl::EventReplyBufferSizeInChannel<::test_protocollayoutssamelibrary::MainProtocol::OnLocal>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    return fidl::OneWayStatus{_allocation.error_value()};
  }

  ::fidl::internal::TransactionalEvent<::test_protocollayoutssamelibrary::MainProtocol::OnLocal> _response{UnionPayload };
  ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalEvent<::test_protocollayoutssamelibrary::MainProtocol::OnLocal>, ::fidl::internal::ChannelTransport> _response_message(
        _allocation->data, _buffer_size, &_response);
  auto& _message = _response_message.GetOutgoingMessage();
  _message.Write(_transport());
  return ::fidl::OneWayStatus{::fidl::Status{_message}};
}

::fidl::OneWayStatus fidl::internal::WireWeakEventSender<::test_protocollayoutssamelibrary::MainProtocol>::OnAnon(::test_protocollayoutssamelibrary::wire::MainProtocolOnAnonRequest MainProtocolOnAnonRequest) {
  ::fidl::internal::TransactionalEvent<::test_protocollayoutssamelibrary::MainProtocol::OnAnon> _response{MainProtocolOnAnonRequest };
  FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalEvent<::test_protocollayoutssamelibrary::MainProtocol::OnAnon>, ::fidl::internal::ChannelTransport> _response_message{
      ::fidl::internal::AllowUnownedInputRef{}, &_response
  };
  return _inner().SendEvent(_response_message.GetOutgoingMessage());
}

fidl::OneWayStatus fidl::internal::WireWeakBufferEventSender<::test_protocollayoutssamelibrary::MainProtocol>::OnAnon(::test_protocollayoutssamelibrary::wire::MainProtocolOnAnonRequest MainProtocolOnAnonRequest) {
  constexpr uint32_t _buffer_size = ::fidl::EventReplyBufferSizeInChannel<::test_protocollayoutssamelibrary::MainProtocol::OnAnon>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    _inner().HandleSendError(_allocation.error_value());
    return fidl::OneWayStatus{_allocation.error_value()};
  }

  ::fidl::internal::TransactionalEvent<::test_protocollayoutssamelibrary::MainProtocol::OnAnon> _response{MainProtocolOnAnonRequest };
  ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalEvent<::test_protocollayoutssamelibrary::MainProtocol::OnAnon>, ::fidl::internal::ChannelTransport> _response_message(
      _allocation->data, _buffer_size, &_response);
  return _inner().SendEvent(_response_message.GetOutgoingMessage());
}

fidl::OneWayStatus fidl::internal::WireEventSender<::test_protocollayoutssamelibrary::MainProtocol>::OnAnon(::test_protocollayoutssamelibrary::wire::MainProtocolOnAnonRequest MainProtocolOnAnonRequest) {
  ::fidl::internal::TransactionalEvent<::test_protocollayoutssamelibrary::MainProtocol::OnAnon> _response{MainProtocolOnAnonRequest };
  FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT
  ::fidl::internal::OwnedEncodedMessage<::fidl::internal::TransactionalEvent<::test_protocollayoutssamelibrary::MainProtocol::OnAnon>, ::fidl::internal::ChannelTransport> _response_message{
      ::fidl::internal::AllowUnownedInputRef{}, &_response
  };
  auto& _message = _response_message.GetOutgoingMessage();
  _message.Write(_transport());
  return ::fidl::OneWayStatus{::fidl::Status{_message}};
}

fidl::OneWayStatus fidl::internal::WireBufferEventSender<::test_protocollayoutssamelibrary::MainProtocol>::OnAnon(::test_protocollayoutssamelibrary::wire::MainProtocolOnAnonRequest MainProtocolOnAnonRequest) {
  constexpr uint32_t _buffer_size = ::fidl::EventReplyBufferSizeInChannel<::test_protocollayoutssamelibrary::MainProtocol::OnAnon>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    return fidl::OneWayStatus{_allocation.error_value()};
  }

  ::fidl::internal::TransactionalEvent<::test_protocollayoutssamelibrary::MainProtocol::OnAnon> _response{MainProtocolOnAnonRequest };
  ::fidl::internal::UnownedEncodedMessage<::fidl::internal::TransactionalEvent<::test_protocollayoutssamelibrary::MainProtocol::OnAnon>, ::fidl::internal::ChannelTransport> _response_message(
        _allocation->data, _buffer_size, &_response);
  auto& _message = _response_message.GetOutgoingMessage();
  _message.Write(_transport());
  return ::fidl::OneWayStatus{::fidl::Status{_message}};
}


#endif  // __Fuchsia__


#pragma clang diagnostic pop