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

#include <fidl/test/protocols/llcpp/fidl.h>

#include <memory>

void ::fidl_test_protocols::wire::WithErrorSyntaxResponseAsStructResult::
    SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(WithErrorSyntaxResponseAsStructResult) ==
                sizeof(fidl_xunion_t));
  static_assert(offsetof(WithErrorSyntaxResponseAsStructResult, ordinal_) ==
                offsetof(fidl_xunion_t, tag));
  static_assert(offsetof(WithErrorSyntaxResponseAsStructResult, envelope_) ==
                offsetof(fidl_xunion_t, envelope));
}

void ::fidl_test_protocols::wire::WithErrorSyntaxErrorAsPrimitiveResult::
    SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(WithErrorSyntaxErrorAsPrimitiveResult) ==
                sizeof(fidl_xunion_t));
  static_assert(offsetof(WithErrorSyntaxErrorAsPrimitiveResult, ordinal_) ==
                offsetof(fidl_xunion_t, tag));
  static_assert(offsetof(WithErrorSyntaxErrorAsPrimitiveResult, envelope_) ==
                offsetof(fidl_xunion_t, envelope));
}

namespace fidl_test_protocols {
[[maybe_unused]] constexpr uint64_t kDiscoverableProtocol_Method_Ordinal =
    16177161678225767lu;

extern "C" const fidl_type_t
    fidl_test_protocols_DiscoverableProtocolMethodRequestTable;

extern "C" const fidl_type_t
    fidl_test_protocols_DiscoverableProtocolMethodResponseTable;
#ifdef __Fuchsia__
}  // namespace fidl_test_protocols
::fidl::WireResult<::fidl_test_protocols::DiscoverableProtocol::Method>::
    WireResult(
        ::fidl::UnownedClientEnd<::fidl_test_protocols::DiscoverableProtocol>
            _client) {
  ::fidl::OwnedEncodedMessage<
      ::fidl::WireRequest<::fidl_test_protocols::DiscoverableProtocol::Method>>
      _request(zx_txid_t(0));
  _request.GetOutgoingMessage().Write(_client);
  status_ = _request.status();
  error_ = _request.error();
}
namespace fidl_test_protocols {
#endif  // __Fuchsia__

}  // namespace fidl_test_protocols
#ifdef __Fuchsia__
::fidl::Result fidl::internal::WireClientImpl<
    ::fidl_test_protocols::DiscoverableProtocol>::Method() {
  if (auto _channel = ::fidl::internal::ClientBase::GetChannel()) {
    auto _res = ::fidl::WireResult<
        ::fidl_test_protocols::DiscoverableProtocol::Method>(
        ::fidl::UnownedClientEnd<::fidl_test_protocols::DiscoverableProtocol>(
            _channel->handle()));
    return ::fidl::Result(_res.status(), _res.error());
  }
  return ::fidl::Result(ZX_ERR_CANCELED, ::fidl::kErrorChannelUnbound);
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
std::optional<::fidl::UnbindInfo> fidl::internal::
    WireClientImpl<::fidl_test_protocols::DiscoverableProtocol>::DispatchEvent(
        fidl_incoming_msg_t* msg) {
  FidlHandleInfoCloseMany(msg->handles, msg->num_handles);
  return ::fidl::UnbindInfo{::fidl::UnbindInfo::kUnexpectedMessage,
                            ZX_ERR_NOT_SUPPORTED};
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__

::fidl::DispatchResult fidl::internal::WireServerDispatcher<
    ::fidl_test_protocols::DiscoverableProtocol>::
    TryDispatch(
        ::fidl::WireServer<::fidl_test_protocols::DiscoverableProtocol>* impl,
        fidl_incoming_msg_t* msg, ::fidl::Transaction* txn) {
  static const ::fidl::internal::MethodEntry entries[] = {
      {
          ::fidl_test_protocols::kDiscoverableProtocol_Method_Ordinal,
          ::fidl::WireRequest<
              ::fidl_test_protocols::DiscoverableProtocol::Method>::Type,
          [](void* interface, void* bytes, ::fidl::Transaction* txn) {
            ::fidl::WireServer<::fidl_test_protocols::DiscoverableProtocol>::
                MethodCompleter::Sync completer(txn);
            reinterpret_cast<::fidl::WireServer<
                ::fidl_test_protocols::DiscoverableProtocol>*>(interface)
                ->Method(
                    reinterpret_cast<::fidl::WireRequest<
                        ::fidl_test_protocols::DiscoverableProtocol::Method>*>(
                        bytes),
                    completer);
          },
      },
  };
  return ::fidl::internal::TryDispatch(
      impl, msg, txn, entries,
      entries + sizeof(entries) / sizeof(::fidl::internal::MethodEntry));
}

::fidl::DispatchResult fidl::internal::
    WireServerDispatcher<::fidl_test_protocols::DiscoverableProtocol>::Dispatch(
        ::fidl::WireServer<::fidl_test_protocols::DiscoverableProtocol>* impl,
        fidl_incoming_msg_t* msg, ::fidl::Transaction* txn) {
  ::fidl::DispatchResult dispatch_result = TryDispatch(impl, msg, txn);
  if (dispatch_result == ::fidl::DispatchResult::kNotFound) {
    FidlHandleInfoCloseMany(msg->handles, msg->num_handles);
    txn->InternalError(
        {::fidl::UnbindInfo::kUnexpectedMessage, ZX_ERR_NOT_SUPPORTED});
  }
  return dispatch_result;
}
::fidl::DispatchResult
fidl::WireServer<::fidl_test_protocols::DiscoverableProtocol>::dispatch_message(
    fidl_incoming_msg_t* msg, ::fidl::Transaction* txn) {
  return ::fidl::internal::WireServerDispatcher<
      ::fidl_test_protocols::DiscoverableProtocol>::Dispatch(this, msg, txn);
}

::fidl::DispatchResult fidl::internal::
    WireDispatcher<::fidl_test_protocols::DiscoverableProtocol>::TryDispatch(
        ::fidl::WireInterface<::fidl_test_protocols::DiscoverableProtocol>*
            impl,
        fidl_incoming_msg_t* msg, ::fidl::Transaction* txn) {
  static const ::fidl::internal::MethodEntry entries[] = {
      {
          ::fidl_test_protocols::kDiscoverableProtocol_Method_Ordinal,
          ::fidl::WireRequest<
              ::fidl_test_protocols::DiscoverableProtocol::Method>::Type,
          [](void* interface, void* bytes, ::fidl::Transaction* txn) {
            ::fidl::WireServer<::fidl_test_protocols::DiscoverableProtocol>::
                MethodCompleter::Sync completer(txn);
            reinterpret_cast<::fidl::WireInterface<
                ::fidl_test_protocols::DiscoverableProtocol>*>(interface)
                ->Method(completer);
          },
      },
  };
  return ::fidl::internal::TryDispatch(
      impl, msg, txn, entries,
      entries + sizeof(entries) / sizeof(::fidl::internal::MethodEntry));
}

::fidl::DispatchResult fidl::internal::
    WireDispatcher<::fidl_test_protocols::DiscoverableProtocol>::Dispatch(
        ::fidl::WireInterface<::fidl_test_protocols::DiscoverableProtocol>*
            impl,
        fidl_incoming_msg_t* msg, ::fidl::Transaction* txn) {
  ::fidl::DispatchResult dispatch_result = TryDispatch(impl, msg, txn);
  if (dispatch_result == ::fidl::DispatchResult::kNotFound) {
    FidlHandleInfoCloseMany(msg->handles, msg->num_handles);
    txn->InternalError(
        {::fidl::UnbindInfo::kUnexpectedMessage, ZX_ERR_NOT_SUPPORTED});
  }
  return dispatch_result;
}
::fidl::DispatchResult
fidl::WireInterface<::fidl_test_protocols::DiscoverableProtocol>::
    dispatch_message(fidl_incoming_msg_t* msg, ::fidl::Transaction* txn) {
  return ::fidl::internal::WireDispatcher<
      ::fidl_test_protocols::DiscoverableProtocol>::Dispatch(this, msg, txn);
}
#endif  // __Fuchsia__

void ::fidl::WireRequest<::fidl_test_protocols::DiscoverableProtocol::Method>::
    _InitHeader(zx_txid_t _txid) {
  fidl_init_txn_header(
      &_hdr, _txid,
      ::fidl_test_protocols::kDiscoverableProtocol_Method_Ordinal);
}

#ifdef __Fuchsia__

#endif  // __Fuchsia__

namespace fidl_test_protocols {
[[maybe_unused]] constexpr uint64_t kTransitional_Request_Ordinal =
    7121112290509197032lu;

extern "C" const fidl_type_t
    fidl_test_protocols_TransitionalRequestRequestTable;

extern "C" const fidl_type_t
    fidl_test_protocols_TransitionalRequestResponseTable;

[[maybe_unused]] constexpr uint64_t kTransitional_OneWay_Ordinal =
    1124136612964114085lu;

extern "C" const fidl_type_t fidl_test_protocols_TransitionalOneWayRequestTable;

extern "C" const fidl_type_t
    fidl_test_protocols_TransitionalOneWayResponseTable;

[[maybe_unused]] constexpr uint64_t kTransitional_Event_Ordinal =
    6033576734966581606lu;

extern "C" const fidl_type_t fidl_test_protocols_TransitionalEventRequestTable;

extern "C" const fidl_type_t fidl_test_protocols_TransitionalEventEventTable;
#ifdef __Fuchsia__
}  // namespace fidl_test_protocols
::fidl::WireResult<::fidl_test_protocols::Transitional::Request>::WireResult(
    ::fidl::UnownedClientEnd<::fidl_test_protocols::Transitional> _client,
    int64_t x) {
  ::fidl::OwnedEncodedMessage<
      ::fidl::WireRequest<::fidl_test_protocols::Transitional::Request>>
      _request(zx_txid_t(0), x);
  _request.GetOutgoingMessage()
      .Call<::fidl::WireResponse<::fidl_test_protocols::Transitional::Request>>(
          _client, bytes_.data(), bytes_.size());
  status_ = _request.status();
  error_ = _request.error();
}

::fidl::WireResult<::fidl_test_protocols::Transitional::Request>::WireResult(
    ::fidl::UnownedClientEnd<::fidl_test_protocols::Transitional> _client,
    int64_t x, zx_time_t _deadline) {
  ::fidl::OwnedEncodedMessage<
      ::fidl::WireRequest<::fidl_test_protocols::Transitional::Request>>
      _request(zx_txid_t(0), x);
  _request.GetOutgoingMessage()
      .Call<::fidl::WireResponse<::fidl_test_protocols::Transitional::Request>>(
          _client, bytes_.data(), bytes_.size(), _deadline);
  status_ = _request.status();
  error_ = _request.error();
}
namespace fidl_test_protocols {
#endif  // __Fuchsia__

#ifdef __Fuchsia__
}  // namespace fidl_test_protocols
::fidl::WireUnownedResult<::fidl_test_protocols::Transitional::Request>::
    WireUnownedResult(
        ::fidl::UnownedClientEnd<::fidl_test_protocols::Transitional> _client,
        uint8_t* _request_bytes, uint32_t _request_byte_capacity, int64_t x,
        uint8_t* _response_bytes, uint32_t _response_byte_capacity)
    : bytes_(_response_bytes) {
  ::fidl::UnownedEncodedMessage<
      ::fidl::WireRequest<::fidl_test_protocols::Transitional::Request>>
      _request(_request_bytes, _request_byte_capacity, 0, x);
  _request.GetOutgoingMessage()
      .Call<::fidl::WireResponse<::fidl_test_protocols::Transitional::Request>>(
          _client, _response_bytes, _response_byte_capacity);
  status_ = _request.status();
  error_ = _request.error();
}
namespace fidl_test_protocols {
#endif  // __Fuchsia__

#ifdef __Fuchsia__
}  // namespace fidl_test_protocols
::fidl::WireResult<::fidl_test_protocols::Transitional::OneWay>::WireResult(
    ::fidl::UnownedClientEnd<::fidl_test_protocols::Transitional> _client,
    int64_t x) {
  ::fidl::OwnedEncodedMessage<
      ::fidl::WireRequest<::fidl_test_protocols::Transitional::OneWay>>
      _request(zx_txid_t(0), x);
  _request.GetOutgoingMessage().Write(_client);
  status_ = _request.status();
  error_ = _request.error();
}
namespace fidl_test_protocols {
#endif  // __Fuchsia__

#ifdef __Fuchsia__
}  // namespace fidl_test_protocols
::fidl::WireUnownedResult<::fidl_test_protocols::Transitional::OneWay>::
    WireUnownedResult(
        ::fidl::UnownedClientEnd<::fidl_test_protocols::Transitional> _client,
        uint8_t* _request_bytes, uint32_t _request_byte_capacity, int64_t x) {
  ::fidl::UnownedEncodedMessage<
      ::fidl::WireRequest<::fidl_test_protocols::Transitional::OneWay>>
      _request(_request_bytes, _request_byte_capacity, 0, x);
  _request.GetOutgoingMessage().Write(_client);
  status_ = _request.status();
  error_ = _request.error();
}
namespace fidl_test_protocols {
#endif  // __Fuchsia__

}  // namespace fidl_test_protocols
#ifdef __Fuchsia__
::fidl::WireResult<::fidl_test_protocols::Transitional::Request>
fidl::internal::WireClientImpl<
    ::fidl_test_protocols::Transitional>::Request_Sync(int64_t x) {
  if (auto _channel = ::fidl::internal::ClientBase::GetChannel()) {
    return ::fidl::WireResult<::fidl_test_protocols::Transitional::Request>(
        ::fidl::UnownedClientEnd<::fidl_test_protocols::Transitional>(
            _channel->handle()),
        x);
  }
  return ::fidl::WireResult<::fidl_test_protocols::Transitional::Request>(
      ::fidl::Result(ZX_ERR_CANCELED, ::fidl::kErrorChannelUnbound));
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
::fidl::WireUnownedResult<::fidl_test_protocols::Transitional::Request> fidl::
    internal::WireClientImpl<::fidl_test_protocols::Transitional>::Request_Sync(
        ::fidl::BufferSpan _request_buffer, int64_t x,
        ::fidl::BufferSpan _response_buffer) {
  if (auto _channel = ::fidl::internal::ClientBase::GetChannel()) {
    return ::fidl::WireUnownedResult<
        ::fidl_test_protocols::Transitional::Request>(
        ::fidl::UnownedClientEnd<::fidl_test_protocols::Transitional>(
            _channel->handle()),
        _request_buffer.data, _request_buffer.capacity, x,
        _response_buffer.data, _response_buffer.capacity);
  }
  return ::fidl::WireUnownedResult<
      ::fidl_test_protocols::Transitional::Request>(
      ::fidl::Result(ZX_ERR_CANCELED, ::fidl::kErrorChannelUnbound));
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__

::fidl::WireResponseContext<
    ::fidl_test_protocols::Transitional::Request>::WireResponseContext()
    : ::fidl::internal::ResponseContext(
          ::fidl::WireResponse<
              ::fidl_test_protocols::Transitional::Request>::Type,
          ::fidl_test_protocols::kTransitional_Request_Ordinal) {}

void ::fidl::WireResponseContext<
    ::fidl_test_protocols::Transitional::Request>::OnReply(uint8_t* reply) {
  OnReply(reinterpret_cast<
          ::fidl::WireResponse<::fidl_test_protocols::Transitional::Request>*>(
      reply));
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
::fidl::Result
fidl::internal::WireClientImpl<::fidl_test_protocols::Transitional>::Request(
    int64_t x,
    ::fit::callback<
        void(::fidl::WireResponse<::fidl_test_protocols::Transitional::Request>*
                 response)>
        _cb) {
  class ResponseContext final
      : public ::fidl::WireResponseContext<
            ::fidl_test_protocols::Transitional::Request> {
   public:
    ResponseContext(
        ::fit::callback<void(
            ::fidl::WireResponse<::fidl_test_protocols::Transitional::Request>*
                response)>
            cb)
        : cb_(std::move(cb)) {}

    void OnReply(
        ::fidl::WireResponse<::fidl_test_protocols::Transitional::Request>*
            response) override {
      cb_(response);

      delete this;
    }

    void OnError() override { delete this; }

   private:
    ::fit::callback<void(
        ::fidl::WireResponse<::fidl_test_protocols::Transitional::Request>*
            response)>
        cb_;
  };

  auto* _context = new ResponseContext(std::move(_cb));
  ::fidl::internal::ClientBase::PrepareAsyncTxn(_context);
  ::fidl::WireRequest<::fidl_test_protocols::Transitional::Request>::
      OwnedEncodedMessage _request(_context->Txid(), x);
  return _request.GetOutgoingMessage().Write(this, _context);
}

::fidl::Result
fidl::internal::WireClientImpl<::fidl_test_protocols::Transitional>::Request(
    ::fidl::BufferSpan _request_buffer, int64_t x,
    ::fidl::WireResponseContext<::fidl_test_protocols::Transitional::Request>*
        _context) {
  ::fidl::internal::ClientBase::PrepareAsyncTxn(_context);

  ::fidl::WireRequest<::fidl_test_protocols::Transitional::Request>::
      UnownedEncodedMessage _request(
          _request_buffer.data, _request_buffer.capacity, _context->Txid(), x);
  return _request.GetOutgoingMessage().Write(this, _context);
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
::fidl::Result fidl::internal::WireClientImpl<
    ::fidl_test_protocols::Transitional>::OneWay(int64_t x) {
  if (auto _channel = ::fidl::internal::ClientBase::GetChannel()) {
    auto _res = ::fidl::WireResult<::fidl_test_protocols::Transitional::OneWay>(
        ::fidl::UnownedClientEnd<::fidl_test_protocols::Transitional>(
            _channel->handle()),
        x);
    return ::fidl::Result(_res.status(), _res.error());
  }
  return ::fidl::Result(ZX_ERR_CANCELED, ::fidl::kErrorChannelUnbound);
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
::fidl::Result
fidl::internal::WireClientImpl<::fidl_test_protocols::Transitional>::OneWay(
    ::fidl::BufferSpan _request_buffer, int64_t x) {
  if (auto _channel = ::fidl::internal::ClientBase::GetChannel()) {
    auto _res =
        ::fidl::WireUnownedResult<::fidl_test_protocols::Transitional::OneWay>(
            ::fidl::UnownedClientEnd<::fidl_test_protocols::Transitional>(
                _channel->handle()),
            _request_buffer.data, _request_buffer.capacity, x);
    return ::fidl::Result(_res.status(), _res.error());
  }
  return ::fidl::Result(ZX_ERR_CANCELED, ::fidl::kErrorChannelUnbound);
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
std::optional<::fidl::UnbindInfo> fidl::internal::WireClientImpl<
    ::fidl_test_protocols::Transitional>::DispatchEvent(fidl_incoming_msg_t*
                                                            msg) {
  if (event_handler_ != nullptr) {
    fidl_message_header_t* hdr =
        reinterpret_cast<fidl_message_header_t*>(msg->bytes);
    switch (hdr->ordinal) {
      case ::fidl_test_protocols::kTransitional_Event_Ordinal: {
        const char* error_message;
        zx_status_t status = fidl_decode_etc(
            ::fidl::WireResponse<
                ::fidl_test_protocols::Transitional::Event>::Type,
            msg->bytes, msg->num_bytes, msg->handles, msg->num_handles,
            &error_message);
        if (status != ZX_OK) {
          return ::fidl::UnbindInfo{::fidl::UnbindInfo::kDecodeError, status};
        }
        event_handler_->Event(
            reinterpret_cast<::fidl::WireResponse<
                ::fidl_test_protocols::Transitional::Event>*>(msg->bytes));
        return std::nullopt;
      }
      default:
        break;
    }
  }
  FidlHandleInfoCloseMany(msg->handles, msg->num_handles);
  return ::fidl::UnbindInfo{::fidl::UnbindInfo::kUnexpectedMessage,
                            ZX_ERR_NOT_SUPPORTED};
}
#endif  // __Fuchsia__

::fidl::Result
fidl::WireSyncEventHandler<::fidl_test_protocols::Transitional>::HandleOneEvent(
    ::fidl::UnownedClientEnd<::fidl_test_protocols::Transitional> client_end) {
  zx_status_t status = client_end.channel()->wait_one(
      ZX_CHANNEL_READABLE | ZX_CHANNEL_PEER_CLOSED, ::zx::time::infinite(),
      nullptr);
  if (status != ZX_OK) {
    return ::fidl::Result(status, ::fidl::kErrorWaitOneFailed);
  }
  constexpr uint32_t kHandleAllocSize = ([]() constexpr {
    uint32_t x = 0;
    if (::fidl::WireResponse<
            ::fidl_test_protocols::Transitional::Event>::MaxNumHandles >= x) {
      x = ::fidl::WireResponse<
          ::fidl_test_protocols::Transitional::Event>::MaxNumHandles;
    }
    if (x > ZX_CHANNEL_MAX_MSG_HANDLES) {
      x = ZX_CHANNEL_MAX_MSG_HANDLES;
    }
    return x;
  })();
  ::fidl::internal::InlineMessageBuffer<24> read_storage;
  uint8_t* read_bytes = read_storage.data();
  zx_handle_info_t read_handles[kHandleAllocSize];
  uint32_t actual_bytes;
  uint32_t actual_handles;
  status = client_end.channel()->read_etc(
      ZX_CHANNEL_READ_MAY_DISCARD, read_bytes, read_handles,
      read_storage.size(), kHandleAllocSize, &actual_bytes, &actual_handles);
  if (status == ZX_ERR_BUFFER_TOO_SMALL) {
    // Message size is unexpectedly larger than calculated.
    // This can only be due to a newer version of the protocol defining a new
    // event, whose size exceeds the maximum of known events in the current
    // protocol.
    return ::fidl::Result(Unknown(), nullptr);
  }
  if (status != ZX_OK) {
    return ::fidl::Result(status, ::fidl::kErrorReadFailed);
  }
  if (actual_bytes < sizeof(fidl_message_header_t)) {
    FidlHandleInfoCloseMany(read_handles, actual_handles);
    return ::fidl::Result(ZX_ERR_INVALID_ARGS, ::fidl::kErrorInvalidHeader);
  }
  fidl_message_header_t* hdr =
      reinterpret_cast<fidl_message_header_t*>(read_bytes);
  status = fidl_validate_txn_header(hdr);
  if (status != ZX_OK) {
    FidlHandleInfoCloseMany(read_handles, actual_handles);
    return ::fidl::Result(status, ::fidl::kErrorInvalidHeader);
  }
  switch (hdr->ordinal) {
    case ::fidl_test_protocols::kTransitional_Event_Ordinal: {
      const char* error_message;
      zx_status_t status =
          fidl_decode_etc(::fidl::WireResponse<
                              ::fidl_test_protocols::Transitional::Event>::Type,
                          read_bytes, actual_bytes, read_handles,
                          actual_handles, &error_message);
      if (status != ZX_OK) {
        return ::fidl::Result(status, error_message);
      }
      Event(reinterpret_cast<
            ::fidl::WireResponse<::fidl_test_protocols::Transitional::Event>*>(
          read_bytes));
      return ::fidl::Result(ZX_OK, nullptr);
    }
    default: {
      FidlHandleInfoCloseMany(read_handles, actual_handles);
      return ::fidl::Result(Unknown(), nullptr);
    }
  }
}

#ifdef __Fuchsia__

::fidl::DispatchResult fidl::internal::
    WireServerDispatcher<::fidl_test_protocols::Transitional>::TryDispatch(
        ::fidl::WireServer<::fidl_test_protocols::Transitional>* impl,
        fidl_incoming_msg_t* msg, ::fidl::Transaction* txn) {
  static const ::fidl::internal::MethodEntry entries[] = {
      {
          ::fidl_test_protocols::kTransitional_Request_Ordinal,
          ::fidl::WireRequest<
              ::fidl_test_protocols::Transitional::Request>::Type,
          [](void* interface, void* bytes, ::fidl::Transaction* txn) {
            ::fidl::WireServer<::fidl_test_protocols::Transitional>::
                RequestCompleter::Sync completer(txn);
            reinterpret_cast<
                ::fidl::WireServer<::fidl_test_protocols::Transitional>*>(
                interface)
                ->Request(
                    reinterpret_cast<::fidl::WireRequest<
                        ::fidl_test_protocols::Transitional::Request>*>(bytes),
                    completer);
          },
      },
      {
          ::fidl_test_protocols::kTransitional_OneWay_Ordinal,
          ::fidl::WireRequest<
              ::fidl_test_protocols::Transitional::OneWay>::Type,
          [](void* interface, void* bytes, ::fidl::Transaction* txn) {
            ::fidl::WireServer<::fidl_test_protocols::Transitional>::
                OneWayCompleter::Sync completer(txn);
            reinterpret_cast<
                ::fidl::WireServer<::fidl_test_protocols::Transitional>*>(
                interface)
                ->OneWay(
                    reinterpret_cast<::fidl::WireRequest<
                        ::fidl_test_protocols::Transitional::OneWay>*>(bytes),
                    completer);
          },
      },
  };
  return ::fidl::internal::TryDispatch(
      impl, msg, txn, entries,
      entries + sizeof(entries) / sizeof(::fidl::internal::MethodEntry));
}

::fidl::DispatchResult fidl::internal::
    WireServerDispatcher<::fidl_test_protocols::Transitional>::Dispatch(
        ::fidl::WireServer<::fidl_test_protocols::Transitional>* impl,
        fidl_incoming_msg_t* msg, ::fidl::Transaction* txn) {
  ::fidl::DispatchResult dispatch_result = TryDispatch(impl, msg, txn);
  if (dispatch_result == ::fidl::DispatchResult::kNotFound) {
    FidlHandleInfoCloseMany(msg->handles, msg->num_handles);
    txn->InternalError(
        {::fidl::UnbindInfo::kUnexpectedMessage, ZX_ERR_NOT_SUPPORTED});
  }
  return dispatch_result;
}
::fidl::DispatchResult
fidl::WireServer<::fidl_test_protocols::Transitional>::dispatch_message(
    fidl_incoming_msg_t* msg, ::fidl::Transaction* txn) {
  return ::fidl::internal::WireServerDispatcher<
      ::fidl_test_protocols::Transitional>::Dispatch(this, msg, txn);
}

::fidl::DispatchResult fidl::internal::
    WireDispatcher<::fidl_test_protocols::Transitional>::TryDispatch(
        ::fidl::WireInterface<::fidl_test_protocols::Transitional>* impl,
        fidl_incoming_msg_t* msg, ::fidl::Transaction* txn) {
  static const ::fidl::internal::MethodEntry entries[] = {
      {
          ::fidl_test_protocols::kTransitional_Request_Ordinal,
          ::fidl::WireRequest<
              ::fidl_test_protocols::Transitional::Request>::Type,
          [](void* interface, void* bytes, ::fidl::Transaction* txn) {
            auto message = reinterpret_cast<::fidl::WireRequest<
                ::fidl_test_protocols::Transitional::Request>*>(bytes);
            ::fidl::WireServer<::fidl_test_protocols::Transitional>::
                RequestCompleter::Sync completer(txn);
            reinterpret_cast<
                ::fidl::WireInterface<::fidl_test_protocols::Transitional>*>(
                interface)
                ->Request(std::move(message->x), completer);
          },
      },
      {
          ::fidl_test_protocols::kTransitional_OneWay_Ordinal,
          ::fidl::WireRequest<
              ::fidl_test_protocols::Transitional::OneWay>::Type,
          [](void* interface, void* bytes, ::fidl::Transaction* txn) {
            auto message = reinterpret_cast<::fidl::WireRequest<
                ::fidl_test_protocols::Transitional::OneWay>*>(bytes);
            ::fidl::WireServer<::fidl_test_protocols::Transitional>::
                OneWayCompleter::Sync completer(txn);
            reinterpret_cast<
                ::fidl::WireInterface<::fidl_test_protocols::Transitional>*>(
                interface)
                ->OneWay(std::move(message->x), completer);
          },
      },
  };
  return ::fidl::internal::TryDispatch(
      impl, msg, txn, entries,
      entries + sizeof(entries) / sizeof(::fidl::internal::MethodEntry));
}

::fidl::DispatchResult
fidl::internal::WireDispatcher<::fidl_test_protocols::Transitional>::Dispatch(
    ::fidl::WireInterface<::fidl_test_protocols::Transitional>* impl,
    fidl_incoming_msg_t* msg, ::fidl::Transaction* txn) {
  ::fidl::DispatchResult dispatch_result = TryDispatch(impl, msg, txn);
  if (dispatch_result == ::fidl::DispatchResult::kNotFound) {
    FidlHandleInfoCloseMany(msg->handles, msg->num_handles);
    txn->InternalError(
        {::fidl::UnbindInfo::kUnexpectedMessage, ZX_ERR_NOT_SUPPORTED});
  }
  return dispatch_result;
}
::fidl::DispatchResult
fidl::WireInterface<::fidl_test_protocols::Transitional>::dispatch_message(
    fidl_incoming_msg_t* msg, ::fidl::Transaction* txn) {
  return ::fidl::internal::WireDispatcher<
      ::fidl_test_protocols::Transitional>::Dispatch(this, msg, txn);
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
::fidl::Result fidl::WireServer<::fidl_test_protocols::Transitional>::
    RequestCompleterBase::Reply(int64_t y) {
  ::fidl::OwnedEncodedMessage<
      ::fidl::WireResponse<::fidl_test_protocols::Transitional::Request>>
      _response{y};
  return ::fidl::WireServer<::fidl_test_protocols::Transitional>::
      RequestCompleterBase::SendReply(&_response.GetOutgoingMessage());
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
::fidl::Result fidl::WireServer<::fidl_test_protocols::Transitional>::
    RequestCompleterBase::Reply(::fidl::BufferSpan _backing_buffer, int64_t y) {
  ::fidl::WireResponse<::fidl_test_protocols::Transitional::Request>::
      UnownedEncodedMessage _response(_backing_buffer.data,
                                      _backing_buffer.capacity, y);
  return CompleterBase::SendReply(&_response.GetOutgoingMessage());
}
#endif  // __Fuchsia__

void ::fidl::WireRequest<::fidl_test_protocols::Transitional::Request>::
    _InitHeader(zx_txid_t _txid) {
  fidl_init_txn_header(&_hdr, _txid,
                       ::fidl_test_protocols::kTransitional_Request_Ordinal);
}

void ::fidl::WireResponse<
    ::fidl_test_protocols::Transitional::Request>::_InitHeader() {
  fidl_init_txn_header(&_hdr, 0,
                       ::fidl_test_protocols::kTransitional_Request_Ordinal);
}

void ::fidl::WireRequest<
    ::fidl_test_protocols::Transitional::OneWay>::_InitHeader(zx_txid_t _txid) {
  fidl_init_txn_header(&_hdr, _txid,
                       ::fidl_test_protocols::kTransitional_OneWay_Ordinal);
}

void ::fidl::WireResponse<
    ::fidl_test_protocols::Transitional::Event>::_InitHeader() {
  fidl_init_txn_header(&_hdr, 0,
                       ::fidl_test_protocols::kTransitional_Event_Ordinal);
}

#ifdef __Fuchsia__

zx_status_t fidl::WireEventSender<::fidl_test_protocols::Transitional>::Event(
    int64_t x) const {
  ::fidl::OwnedEncodedMessage<
      ::fidl::WireResponse<::fidl_test_protocols::Transitional::Event>>
      _response{x};
  _response.Write(server_end_);
  return _response.status();
}

zx_status_t fidl::WireEventSender<::fidl_test_protocols::Transitional>::Event(
    ::fidl::BufferSpan _buffer, int64_t x) const {
  ::fidl::UnownedEncodedMessage<
      ::fidl::WireResponse<::fidl_test_protocols::Transitional::Event>>
      _response(_buffer.data, _buffer.capacity, x);
  _response.Write(server_end_);
  return _response.status();
}

#endif  // __Fuchsia__

namespace fidl_test_protocols {
[[maybe_unused]] constexpr uint64_t kChannelProtocol_MethodA_Ordinal =
    565531679656837166lu;

extern "C" const fidl_type_t
    fidl_test_protocols_ChannelProtocolMethodARequestTable;

extern "C" const fidl_type_t
    fidl_test_protocols_ChannelProtocolMethodAResponseTable;

[[maybe_unused]] constexpr uint64_t kChannelProtocol_EventA_Ordinal =
    5963604044179602938lu;

extern "C" const fidl_type_t
    fidl_test_protocols_ChannelProtocolEventARequestTable;

extern "C" const fidl_type_t
    fidl_test_protocols_ChannelProtocolEventAEventTable;

[[maybe_unused]] constexpr uint64_t kChannelProtocol_MethodB_Ordinal =
    6746905632127147242lu;

extern "C" const fidl_type_t
    fidl_test_protocols_ChannelProtocolMethodBRequestTable;

extern "C" const fidl_type_t
    fidl_test_protocols_ChannelProtocolMethodBResponseTable;

[[maybe_unused]] constexpr uint64_t kChannelProtocol_TakeHandle_Ordinal =
    875219241480379432lu;

extern "C" const fidl_type_t
    fidl_test_protocols_ChannelProtocolTakeHandleRequestTable;

extern "C" const fidl_type_t
    fidl_test_protocols_ChannelProtocolTakeHandleResponseTable;

[[maybe_unused]] constexpr uint64_t kChannelProtocol_MutateSocket_Ordinal =
    9065806117349865322lu;

extern "C" const fidl_type_t
    fidl_test_protocols_ChannelProtocolMutateSocketRequestTable;

extern "C" const fidl_type_t
    fidl_test_protocols_ChannelProtocolMutateSocketResponseTable;
#ifdef __Fuchsia__
}  // namespace fidl_test_protocols
::fidl::WireResult<::fidl_test_protocols::ChannelProtocol::MethodA>::WireResult(
    ::fidl::UnownedClientEnd<::fidl_test_protocols::ChannelProtocol> _client,
    int64_t a, int64_t b) {
  ::fidl::OwnedEncodedMessage<
      ::fidl::WireRequest<::fidl_test_protocols::ChannelProtocol::MethodA>>
      _request(zx_txid_t(0), a, b);
  _request.GetOutgoingMessage().Write(_client);
  status_ = _request.status();
  error_ = _request.error();
}
namespace fidl_test_protocols {
#endif  // __Fuchsia__

#ifdef __Fuchsia__
}  // namespace fidl_test_protocols
::fidl::WireUnownedResult<::fidl_test_protocols::ChannelProtocol::MethodA>::
    WireUnownedResult(
        ::fidl::UnownedClientEnd<::fidl_test_protocols::ChannelProtocol>
            _client,
        uint8_t* _request_bytes, uint32_t _request_byte_capacity, int64_t a,
        int64_t b) {
  ::fidl::UnownedEncodedMessage<
      ::fidl::WireRequest<::fidl_test_protocols::ChannelProtocol::MethodA>>
      _request(_request_bytes, _request_byte_capacity, 0, a, b);
  _request.GetOutgoingMessage().Write(_client);
  status_ = _request.status();
  error_ = _request.error();
}
namespace fidl_test_protocols {
#endif  // __Fuchsia__

#ifdef __Fuchsia__
}  // namespace fidl_test_protocols
::fidl::WireResult<::fidl_test_protocols::ChannelProtocol::MethodB>::WireResult(
    ::fidl::UnownedClientEnd<::fidl_test_protocols::ChannelProtocol> _client,
    int64_t a, int64_t b) {
  ::fidl::OwnedEncodedMessage<
      ::fidl::WireRequest<::fidl_test_protocols::ChannelProtocol::MethodB>>
      _request(zx_txid_t(0), a, b);
  _request.GetOutgoingMessage()
      .Call<::fidl::WireResponse<
          ::fidl_test_protocols::ChannelProtocol::MethodB>>(
          _client, bytes_.data(), bytes_.size());
  status_ = _request.status();
  error_ = _request.error();
}

::fidl::WireResult<::fidl_test_protocols::ChannelProtocol::MethodB>::WireResult(
    ::fidl::UnownedClientEnd<::fidl_test_protocols::ChannelProtocol> _client,
    int64_t a, int64_t b, zx_time_t _deadline) {
  ::fidl::OwnedEncodedMessage<
      ::fidl::WireRequest<::fidl_test_protocols::ChannelProtocol::MethodB>>
      _request(zx_txid_t(0), a, b);
  _request.GetOutgoingMessage()
      .Call<::fidl::WireResponse<
          ::fidl_test_protocols::ChannelProtocol::MethodB>>(
          _client, bytes_.data(), bytes_.size(), _deadline);
  status_ = _request.status();
  error_ = _request.error();
}
namespace fidl_test_protocols {
#endif  // __Fuchsia__

#ifdef __Fuchsia__
}  // namespace fidl_test_protocols
::fidl::WireUnownedResult<::fidl_test_protocols::ChannelProtocol::MethodB>::
    WireUnownedResult(
        ::fidl::UnownedClientEnd<::fidl_test_protocols::ChannelProtocol>
            _client,
        uint8_t* _request_bytes, uint32_t _request_byte_capacity, int64_t a,
        int64_t b, uint8_t* _response_bytes, uint32_t _response_byte_capacity)
    : bytes_(_response_bytes) {
  ::fidl::UnownedEncodedMessage<
      ::fidl::WireRequest<::fidl_test_protocols::ChannelProtocol::MethodB>>
      _request(_request_bytes, _request_byte_capacity, 0, a, b);
  _request.GetOutgoingMessage()
      .Call<::fidl::WireResponse<
          ::fidl_test_protocols::ChannelProtocol::MethodB>>(
          _client, _response_bytes, _response_byte_capacity);
  status_ = _request.status();
  error_ = _request.error();
}
namespace fidl_test_protocols {
#endif  // __Fuchsia__

#ifdef __Fuchsia__
}  // namespace fidl_test_protocols
::fidl::WireResult<::fidl_test_protocols::ChannelProtocol::TakeHandle>::
    WireResult(::fidl::UnownedClientEnd<::fidl_test_protocols::ChannelProtocol>
                   _client,
               ::zx::handle&& h) {
  ::fidl::OwnedEncodedMessage<
      ::fidl::WireRequest<::fidl_test_protocols::ChannelProtocol::TakeHandle>>
      _request(zx_txid_t(0), std::move(h));
  _request.GetOutgoingMessage()
      .Call<::fidl::WireResponse<
          ::fidl_test_protocols::ChannelProtocol::TakeHandle>>(
          _client, bytes_.data(), bytes_.size());
  status_ = _request.status();
  error_ = _request.error();
}

::fidl::WireResult<::fidl_test_protocols::ChannelProtocol::TakeHandle>::
    WireResult(::fidl::UnownedClientEnd<::fidl_test_protocols::ChannelProtocol>
                   _client,
               ::zx::handle&& h, zx_time_t _deadline) {
  ::fidl::OwnedEncodedMessage<
      ::fidl::WireRequest<::fidl_test_protocols::ChannelProtocol::TakeHandle>>
      _request(zx_txid_t(0), std::move(h));
  _request.GetOutgoingMessage()
      .Call<::fidl::WireResponse<
          ::fidl_test_protocols::ChannelProtocol::TakeHandle>>(
          _client, bytes_.data(), bytes_.size(), _deadline);
  status_ = _request.status();
  error_ = _request.error();
}
namespace fidl_test_protocols {
#endif  // __Fuchsia__

#ifdef __Fuchsia__
}  // namespace fidl_test_protocols
::fidl::WireUnownedResult<::fidl_test_protocols::ChannelProtocol::TakeHandle>::
    WireUnownedResult(
        ::fidl::UnownedClientEnd<::fidl_test_protocols::ChannelProtocol>
            _client,
        uint8_t* _request_bytes, uint32_t _request_byte_capacity,
        ::zx::handle&& h, uint8_t* _response_bytes,
        uint32_t _response_byte_capacity)
    : bytes_(_response_bytes) {
  ::fidl::UnownedEncodedMessage<
      ::fidl::WireRequest<::fidl_test_protocols::ChannelProtocol::TakeHandle>>
      _request(_request_bytes, _request_byte_capacity, 0, std::move(h));
  _request.GetOutgoingMessage()
      .Call<::fidl::WireResponse<
          ::fidl_test_protocols::ChannelProtocol::TakeHandle>>(
          _client, _response_bytes, _response_byte_capacity);
  status_ = _request.status();
  error_ = _request.error();
}
namespace fidl_test_protocols {
#endif  // __Fuchsia__

#ifdef __Fuchsia__
}  // namespace fidl_test_protocols
::fidl::WireResult<::fidl_test_protocols::ChannelProtocol::MutateSocket>::
    WireResult(::fidl::UnownedClientEnd<::fidl_test_protocols::ChannelProtocol>
                   _client,
               ::zx::socket&& a) {
  ::fidl::OwnedEncodedMessage<
      ::fidl::WireRequest<::fidl_test_protocols::ChannelProtocol::MutateSocket>>
      _request(zx_txid_t(0), std::move(a));
  _request.GetOutgoingMessage()
      .Call<::fidl::WireResponse<
          ::fidl_test_protocols::ChannelProtocol::MutateSocket>>(
          _client, bytes_.data(), bytes_.size());
  status_ = _request.status();
  error_ = _request.error();
}

::fidl::WireResult<::fidl_test_protocols::ChannelProtocol::MutateSocket>::
    WireResult(::fidl::UnownedClientEnd<::fidl_test_protocols::ChannelProtocol>
                   _client,
               ::zx::socket&& a, zx_time_t _deadline) {
  ::fidl::OwnedEncodedMessage<
      ::fidl::WireRequest<::fidl_test_protocols::ChannelProtocol::MutateSocket>>
      _request(zx_txid_t(0), std::move(a));
  _request.GetOutgoingMessage()
      .Call<::fidl::WireResponse<
          ::fidl_test_protocols::ChannelProtocol::MutateSocket>>(
          _client, bytes_.data(), bytes_.size(), _deadline);
  status_ = _request.status();
  error_ = _request.error();
}
namespace fidl_test_protocols {
#endif  // __Fuchsia__

#ifdef __Fuchsia__
}  // namespace fidl_test_protocols
::fidl::WireUnownedResult<
    ::fidl_test_protocols::ChannelProtocol::MutateSocket>::
    WireUnownedResult(
        ::fidl::UnownedClientEnd<::fidl_test_protocols::ChannelProtocol>
            _client,
        uint8_t* _request_bytes, uint32_t _request_byte_capacity,
        ::zx::socket&& a, uint8_t* _response_bytes,
        uint32_t _response_byte_capacity)
    : bytes_(_response_bytes) {
  ::fidl::UnownedEncodedMessage<
      ::fidl::WireRequest<::fidl_test_protocols::ChannelProtocol::MutateSocket>>
      _request(_request_bytes, _request_byte_capacity, 0, std::move(a));
  _request.GetOutgoingMessage()
      .Call<::fidl::WireResponse<
          ::fidl_test_protocols::ChannelProtocol::MutateSocket>>(
          _client, _response_bytes, _response_byte_capacity);
  status_ = _request.status();
  error_ = _request.error();
}
namespace fidl_test_protocols {
#endif  // __Fuchsia__

}  // namespace fidl_test_protocols
#ifdef __Fuchsia__
::fidl::Result fidl::internal::WireClientImpl<
    ::fidl_test_protocols::ChannelProtocol>::MethodA(int64_t a, int64_t b) {
  if (auto _channel = ::fidl::internal::ClientBase::GetChannel()) {
    auto _res =
        ::fidl::WireResult<::fidl_test_protocols::ChannelProtocol::MethodA>(
            ::fidl::UnownedClientEnd<::fidl_test_protocols::ChannelProtocol>(
                _channel->handle()),
            a, b);
    return ::fidl::Result(_res.status(), _res.error());
  }
  return ::fidl::Result(ZX_ERR_CANCELED, ::fidl::kErrorChannelUnbound);
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
::fidl::Result
fidl::internal::WireClientImpl<::fidl_test_protocols::ChannelProtocol>::MethodA(
    ::fidl::BufferSpan _request_buffer, int64_t a, int64_t b) {
  if (auto _channel = ::fidl::internal::ClientBase::GetChannel()) {
    auto _res = ::fidl::WireUnownedResult<
        ::fidl_test_protocols::ChannelProtocol::MethodA>(
        ::fidl::UnownedClientEnd<::fidl_test_protocols::ChannelProtocol>(
            _channel->handle()),
        _request_buffer.data, _request_buffer.capacity, a, b);
    return ::fidl::Result(_res.status(), _res.error());
  }
  return ::fidl::Result(ZX_ERR_CANCELED, ::fidl::kErrorChannelUnbound);
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
::fidl::WireResult<::fidl_test_protocols::ChannelProtocol::MethodB>
fidl::internal::WireClientImpl<
    ::fidl_test_protocols::ChannelProtocol>::MethodB_Sync(int64_t a,
                                                          int64_t b) {
  if (auto _channel = ::fidl::internal::ClientBase::GetChannel()) {
    return ::fidl::WireResult<::fidl_test_protocols::ChannelProtocol::MethodB>(
        ::fidl::UnownedClientEnd<::fidl_test_protocols::ChannelProtocol>(
            _channel->handle()),
        a, b);
  }
  return ::fidl::WireResult<::fidl_test_protocols::ChannelProtocol::MethodB>(
      ::fidl::Result(ZX_ERR_CANCELED, ::fidl::kErrorChannelUnbound));
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
::fidl::WireUnownedResult<::fidl_test_protocols::ChannelProtocol::MethodB>
fidl::internal::WireClientImpl<::fidl_test_protocols::ChannelProtocol>::
    MethodB_Sync(::fidl::BufferSpan _request_buffer, int64_t a, int64_t b,
                 ::fidl::BufferSpan _response_buffer) {
  if (auto _channel = ::fidl::internal::ClientBase::GetChannel()) {
    return ::fidl::WireUnownedResult<
        ::fidl_test_protocols::ChannelProtocol::MethodB>(
        ::fidl::UnownedClientEnd<::fidl_test_protocols::ChannelProtocol>(
            _channel->handle()),
        _request_buffer.data, _request_buffer.capacity, a, b,
        _response_buffer.data, _response_buffer.capacity);
  }
  return ::fidl::WireUnownedResult<
      ::fidl_test_protocols::ChannelProtocol::MethodB>(
      ::fidl::Result(ZX_ERR_CANCELED, ::fidl::kErrorChannelUnbound));
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__

::fidl::WireResponseContext<
    ::fidl_test_protocols::ChannelProtocol::MethodB>::WireResponseContext()
    : ::fidl::internal::ResponseContext(
          ::fidl::WireResponse<
              ::fidl_test_protocols::ChannelProtocol::MethodB>::Type,
          ::fidl_test_protocols::kChannelProtocol_MethodB_Ordinal) {}

void ::fidl::WireResponseContext<
    ::fidl_test_protocols::ChannelProtocol::MethodB>::OnReply(uint8_t* reply) {
  OnReply(reinterpret_cast<::fidl::WireResponse<
              ::fidl_test_protocols::ChannelProtocol::MethodB>*>(reply));
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
::fidl::Result
fidl::internal::WireClientImpl<::fidl_test_protocols::ChannelProtocol>::MethodB(
    int64_t a, int64_t b,
    ::fit::callback<void(
        ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::MethodB>*
            response)>
        _cb) {
  class ResponseContext final
      : public ::fidl::WireResponseContext<
            ::fidl_test_protocols::ChannelProtocol::MethodB> {
   public:
    ResponseContext(
        ::fit::callback<
            void(::fidl::WireResponse<
                 ::fidl_test_protocols::ChannelProtocol::MethodB>* response)>
            cb)
        : cb_(std::move(cb)) {}

    void OnReply(
        ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::MethodB>*
            response) override {
      cb_(response);

      delete this;
    }

    void OnError() override { delete this; }

   private:
    ::fit::callback<void(
        ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::MethodB>*
            response)>
        cb_;
  };

  auto* _context = new ResponseContext(std::move(_cb));
  ::fidl::internal::ClientBase::PrepareAsyncTxn(_context);
  ::fidl::WireRequest<::fidl_test_protocols::ChannelProtocol::MethodB>::
      OwnedEncodedMessage _request(_context->Txid(), a, b);
  return _request.GetOutgoingMessage().Write(this, _context);
}

::fidl::Result
fidl::internal::WireClientImpl<::fidl_test_protocols::ChannelProtocol>::MethodB(
    ::fidl::BufferSpan _request_buffer, int64_t a, int64_t b,
    ::fidl::WireResponseContext<
        ::fidl_test_protocols::ChannelProtocol::MethodB>* _context) {
  ::fidl::internal::ClientBase::PrepareAsyncTxn(_context);

  ::fidl::WireRequest<::fidl_test_protocols::ChannelProtocol::MethodB>::
      UnownedEncodedMessage _request(_request_buffer.data,
                                     _request_buffer.capacity, _context->Txid(),
                                     a, b);
  return _request.GetOutgoingMessage().Write(this, _context);
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
::fidl::WireResult<::fidl_test_protocols::ChannelProtocol::TakeHandle>
fidl::internal::WireClientImpl<
    ::fidl_test_protocols::ChannelProtocol>::TakeHandle_Sync(::zx::handle&& h) {
  if (auto _channel = ::fidl::internal::ClientBase::GetChannel()) {
    return ::fidl::WireResult<
        ::fidl_test_protocols::ChannelProtocol::TakeHandle>(
        ::fidl::UnownedClientEnd<::fidl_test_protocols::ChannelProtocol>(
            _channel->handle()),
        std::move(h));
  }
  return ::fidl::WireResult<::fidl_test_protocols::ChannelProtocol::TakeHandle>(
      ::fidl::Result(ZX_ERR_CANCELED, ::fidl::kErrorChannelUnbound));
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
::fidl::WireUnownedResult<::fidl_test_protocols::ChannelProtocol::TakeHandle>
fidl::internal::WireClientImpl<::fidl_test_protocols::ChannelProtocol>::
    TakeHandle_Sync(::fidl::BufferSpan _request_buffer, ::zx::handle&& h,
                    ::fidl::BufferSpan _response_buffer) {
  if (auto _channel = ::fidl::internal::ClientBase::GetChannel()) {
    return ::fidl::WireUnownedResult<
        ::fidl_test_protocols::ChannelProtocol::TakeHandle>(
        ::fidl::UnownedClientEnd<::fidl_test_protocols::ChannelProtocol>(
            _channel->handle()),
        _request_buffer.data, _request_buffer.capacity, std::move(h),
        _response_buffer.data, _response_buffer.capacity);
  }
  return ::fidl::WireUnownedResult<
      ::fidl_test_protocols::ChannelProtocol::TakeHandle>(
      ::fidl::Result(ZX_ERR_CANCELED, ::fidl::kErrorChannelUnbound));
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__

::fidl::WireResponseContext<
    ::fidl_test_protocols::ChannelProtocol::TakeHandle>::WireResponseContext()
    : ::fidl::internal::ResponseContext(
          ::fidl::WireResponse<
              ::fidl_test_protocols::ChannelProtocol::TakeHandle>::Type,
          ::fidl_test_protocols::kChannelProtocol_TakeHandle_Ordinal) {}

void ::fidl::WireResponseContext<
    ::fidl_test_protocols::ChannelProtocol::TakeHandle>::OnReply(uint8_t*
                                                                     reply) {
  OnReply(reinterpret_cast<::fidl::WireResponse<
              ::fidl_test_protocols::ChannelProtocol::TakeHandle>*>(reply));
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
::fidl::Result fidl::internal::
    WireClientImpl<::fidl_test_protocols::ChannelProtocol>::TakeHandle(
        ::zx::handle&& h,
        ::fit::callback<
            void(::fidl::WireResponse<
                 ::fidl_test_protocols::ChannelProtocol::TakeHandle>* response)>
            _cb) {
  class ResponseContext final
      : public ::fidl::WireResponseContext<
            ::fidl_test_protocols::ChannelProtocol::TakeHandle> {
   public:
    ResponseContext(
        ::fit::callback<
            void(::fidl::WireResponse<
                 ::fidl_test_protocols::ChannelProtocol::TakeHandle>* response)>
            cb)
        : cb_(std::move(cb)) {}

    void OnReply(::fidl::WireResponse<
                 ::fidl_test_protocols::ChannelProtocol::TakeHandle>* response)
        override {
      cb_(response);

      delete this;
    }

    void OnError() override { delete this; }

   private:
    ::fit::callback<void(
        ::fidl::WireResponse<
            ::fidl_test_protocols::ChannelProtocol::TakeHandle>* response)>
        cb_;
  };

  auto* _context = new ResponseContext(std::move(_cb));
  ::fidl::internal::ClientBase::PrepareAsyncTxn(_context);
  ::fidl::WireRequest<::fidl_test_protocols::ChannelProtocol::TakeHandle>::
      OwnedEncodedMessage _request(_context->Txid(), std::move(h));
  return _request.GetOutgoingMessage().Write(this, _context);
}

::fidl::Result fidl::internal::
    WireClientImpl<::fidl_test_protocols::ChannelProtocol>::TakeHandle(
        ::fidl::BufferSpan _request_buffer, ::zx::handle&& h,
        ::fidl::WireResponseContext<
            ::fidl_test_protocols::ChannelProtocol::TakeHandle>* _context) {
  ::fidl::internal::ClientBase::PrepareAsyncTxn(_context);

  ::fidl::WireRequest<::fidl_test_protocols::ChannelProtocol::TakeHandle>::
      UnownedEncodedMessage _request(_request_buffer.data,
                                     _request_buffer.capacity, _context->Txid(),
                                     std::move(h));
  return _request.GetOutgoingMessage().Write(this, _context);
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
::fidl::WireResult<::fidl_test_protocols::ChannelProtocol::MutateSocket>
fidl::internal::WireClientImpl<::fidl_test_protocols::ChannelProtocol>::
    MutateSocket_Sync(::zx::socket&& a) {
  if (auto _channel = ::fidl::internal::ClientBase::GetChannel()) {
    return ::fidl::WireResult<
        ::fidl_test_protocols::ChannelProtocol::MutateSocket>(
        ::fidl::UnownedClientEnd<::fidl_test_protocols::ChannelProtocol>(
            _channel->handle()),
        std::move(a));
  }
  return ::fidl::WireResult<
      ::fidl_test_protocols::ChannelProtocol::MutateSocket>(
      ::fidl::Result(ZX_ERR_CANCELED, ::fidl::kErrorChannelUnbound));
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
::fidl::WireUnownedResult<::fidl_test_protocols::ChannelProtocol::MutateSocket>
fidl::internal::WireClientImpl<::fidl_test_protocols::ChannelProtocol>::
    MutateSocket_Sync(::fidl::BufferSpan _request_buffer, ::zx::socket&& a,
                      ::fidl::BufferSpan _response_buffer) {
  if (auto _channel = ::fidl::internal::ClientBase::GetChannel()) {
    return ::fidl::WireUnownedResult<
        ::fidl_test_protocols::ChannelProtocol::MutateSocket>(
        ::fidl::UnownedClientEnd<::fidl_test_protocols::ChannelProtocol>(
            _channel->handle()),
        _request_buffer.data, _request_buffer.capacity, std::move(a),
        _response_buffer.data, _response_buffer.capacity);
  }
  return ::fidl::WireUnownedResult<
      ::fidl_test_protocols::ChannelProtocol::MutateSocket>(
      ::fidl::Result(ZX_ERR_CANCELED, ::fidl::kErrorChannelUnbound));
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__

::fidl::WireResponseContext<
    ::fidl_test_protocols::ChannelProtocol::MutateSocket>::WireResponseContext()
    : ::fidl::internal::ResponseContext(
          ::fidl::WireResponse<
              ::fidl_test_protocols::ChannelProtocol::MutateSocket>::Type,
          ::fidl_test_protocols::kChannelProtocol_MutateSocket_Ordinal) {}

void ::fidl::WireResponseContext<
    ::fidl_test_protocols::ChannelProtocol::MutateSocket>::OnReply(uint8_t*
                                                                       reply) {
  OnReply(reinterpret_cast<::fidl::WireResponse<
              ::fidl_test_protocols::ChannelProtocol::MutateSocket>*>(reply));
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
::fidl::Result fidl::internal::
    WireClientImpl<::fidl_test_protocols::ChannelProtocol>::MutateSocket(
        ::zx::socket&& a,
        ::fit::callback<
            void(::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::
                                          MutateSocket>* response)>
            _cb) {
  class ResponseContext final
      : public ::fidl::WireResponseContext<
            ::fidl_test_protocols::ChannelProtocol::MutateSocket> {
   public:
    ResponseContext(::fit::callback<
                    void(::fidl::WireResponse<
                         ::fidl_test_protocols::ChannelProtocol::MutateSocket>*
                             response)>
                        cb)
        : cb_(std::move(cb)) {}

    void OnReply(::fidl::WireResponse<
                 ::fidl_test_protocols::ChannelProtocol::MutateSocket>*
                     response) override {
      cb_(response);

      response->_CloseHandles();

      delete this;
    }

    void OnError() override { delete this; }

   private:
    ::fit::callback<void(
        ::fidl::WireResponse<
            ::fidl_test_protocols::ChannelProtocol::MutateSocket>* response)>
        cb_;
  };

  auto* _context = new ResponseContext(std::move(_cb));
  ::fidl::internal::ClientBase::PrepareAsyncTxn(_context);
  ::fidl::WireRequest<::fidl_test_protocols::ChannelProtocol::MutateSocket>::
      OwnedEncodedMessage _request(_context->Txid(), std::move(a));
  return _request.GetOutgoingMessage().Write(this, _context);
}

::fidl::Result fidl::internal::
    WireClientImpl<::fidl_test_protocols::ChannelProtocol>::MutateSocket(
        ::fidl::BufferSpan _request_buffer, ::zx::socket&& a,
        ::fidl::WireResponseContext<
            ::fidl_test_protocols::ChannelProtocol::MutateSocket>* _context) {
  ::fidl::internal::ClientBase::PrepareAsyncTxn(_context);

  ::fidl::WireRequest<::fidl_test_protocols::ChannelProtocol::MutateSocket>::
      UnownedEncodedMessage _request(_request_buffer.data,
                                     _request_buffer.capacity, _context->Txid(),
                                     std::move(a));
  return _request.GetOutgoingMessage().Write(this, _context);
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
std::optional<::fidl::UnbindInfo> fidl::internal::WireClientImpl<
    ::fidl_test_protocols::ChannelProtocol>::DispatchEvent(fidl_incoming_msg_t*
                                                               msg) {
  if (event_handler_ != nullptr) {
    fidl_message_header_t* hdr =
        reinterpret_cast<fidl_message_header_t*>(msg->bytes);
    switch (hdr->ordinal) {
      case ::fidl_test_protocols::kChannelProtocol_EventA_Ordinal: {
        const char* error_message;
        zx_status_t status = fidl_decode_etc(
            ::fidl::WireResponse<
                ::fidl_test_protocols::ChannelProtocol::EventA>::Type,
            msg->bytes, msg->num_bytes, msg->handles, msg->num_handles,
            &error_message);
        if (status != ZX_OK) {
          return ::fidl::UnbindInfo{::fidl::UnbindInfo::kDecodeError, status};
        }
        event_handler_->EventA(
            reinterpret_cast<::fidl::WireResponse<
                ::fidl_test_protocols::ChannelProtocol::EventA>*>(msg->bytes));
        return std::nullopt;
      }
      default:
        break;
    }
  }
  FidlHandleInfoCloseMany(msg->handles, msg->num_handles);
  return ::fidl::UnbindInfo{::fidl::UnbindInfo::kUnexpectedMessage,
                            ZX_ERR_NOT_SUPPORTED};
}
#endif  // __Fuchsia__

::fidl::Result
fidl::WireSyncEventHandler<::fidl_test_protocols::ChannelProtocol>::
    HandleOneEvent(
        ::fidl::UnownedClientEnd<::fidl_test_protocols::ChannelProtocol>
            client_end) {
  zx_status_t status = client_end.channel()->wait_one(
      ZX_CHANNEL_READABLE | ZX_CHANNEL_PEER_CLOSED, ::zx::time::infinite(),
      nullptr);
  if (status != ZX_OK) {
    return ::fidl::Result(status, ::fidl::kErrorWaitOneFailed);
  }
  constexpr uint32_t kHandleAllocSize = ([]() constexpr {
    uint32_t x = 0;
    if (::fidl::WireResponse<
            ::fidl_test_protocols::ChannelProtocol::EventA>::MaxNumHandles >=
        x) {
      x = ::fidl::WireResponse<
          ::fidl_test_protocols::ChannelProtocol::EventA>::MaxNumHandles;
    }
    if (x > ZX_CHANNEL_MAX_MSG_HANDLES) {
      x = ZX_CHANNEL_MAX_MSG_HANDLES;
    }
    return x;
  })();
  ::fidl::internal::InlineMessageBuffer<32> read_storage;
  uint8_t* read_bytes = read_storage.data();
  zx_handle_info_t read_handles[kHandleAllocSize];
  uint32_t actual_bytes;
  uint32_t actual_handles;
  status = client_end.channel()->read_etc(
      ZX_CHANNEL_READ_MAY_DISCARD, read_bytes, read_handles,
      read_storage.size(), kHandleAllocSize, &actual_bytes, &actual_handles);
  if (status == ZX_ERR_BUFFER_TOO_SMALL) {
    // Message size is unexpectedly larger than calculated.
    // This can only be due to a newer version of the protocol defining a new
    // event, whose size exceeds the maximum of known events in the current
    // protocol.
    return ::fidl::Result(Unknown(), nullptr);
  }
  if (status != ZX_OK) {
    return ::fidl::Result(status, ::fidl::kErrorReadFailed);
  }
  if (actual_bytes < sizeof(fidl_message_header_t)) {
    FidlHandleInfoCloseMany(read_handles, actual_handles);
    return ::fidl::Result(ZX_ERR_INVALID_ARGS, ::fidl::kErrorInvalidHeader);
  }
  fidl_message_header_t* hdr =
      reinterpret_cast<fidl_message_header_t*>(read_bytes);
  status = fidl_validate_txn_header(hdr);
  if (status != ZX_OK) {
    FidlHandleInfoCloseMany(read_handles, actual_handles);
    return ::fidl::Result(status, ::fidl::kErrorInvalidHeader);
  }
  switch (hdr->ordinal) {
    case ::fidl_test_protocols::kChannelProtocol_EventA_Ordinal: {
      const char* error_message;
      zx_status_t status = fidl_decode_etc(
          ::fidl::WireResponse<
              ::fidl_test_protocols::ChannelProtocol::EventA>::Type,
          read_bytes, actual_bytes, read_handles, actual_handles,
          &error_message);
      if (status != ZX_OK) {
        return ::fidl::Result(status, error_message);
      }
      EventA(reinterpret_cast<::fidl::WireResponse<
                 ::fidl_test_protocols::ChannelProtocol::EventA>*>(read_bytes));
      return ::fidl::Result(ZX_OK, nullptr);
    }
    default: {
      FidlHandleInfoCloseMany(read_handles, actual_handles);
      return ::fidl::Result(Unknown(), nullptr);
    }
  }
}

#ifdef __Fuchsia__

::fidl::DispatchResult fidl::internal::
    WireServerDispatcher<::fidl_test_protocols::ChannelProtocol>::TryDispatch(
        ::fidl::WireServer<::fidl_test_protocols::ChannelProtocol>* impl,
        fidl_incoming_msg_t* msg, ::fidl::Transaction* txn) {
  static const ::fidl::internal::MethodEntry entries[] = {
      {
          ::fidl_test_protocols::kChannelProtocol_MethodA_Ordinal,
          ::fidl::WireRequest<
              ::fidl_test_protocols::ChannelProtocol::MethodA>::Type,
          [](void* interface, void* bytes, ::fidl::Transaction* txn) {
            ::fidl::WireServer<::fidl_test_protocols::ChannelProtocol>::
                MethodACompleter::Sync completer(txn);
            reinterpret_cast<
                ::fidl::WireServer<::fidl_test_protocols::ChannelProtocol>*>(
                interface)
                ->MethodA(
                    reinterpret_cast<::fidl::WireRequest<
                        ::fidl_test_protocols::ChannelProtocol::MethodA>*>(
                        bytes),
                    completer);
          },
      },
      {
          ::fidl_test_protocols::kChannelProtocol_MethodB_Ordinal,
          ::fidl::WireRequest<
              ::fidl_test_protocols::ChannelProtocol::MethodB>::Type,
          [](void* interface, void* bytes, ::fidl::Transaction* txn) {
            ::fidl::WireServer<::fidl_test_protocols::ChannelProtocol>::
                MethodBCompleter::Sync completer(txn);
            reinterpret_cast<
                ::fidl::WireServer<::fidl_test_protocols::ChannelProtocol>*>(
                interface)
                ->MethodB(
                    reinterpret_cast<::fidl::WireRequest<
                        ::fidl_test_protocols::ChannelProtocol::MethodB>*>(
                        bytes),
                    completer);
          },
      },
      {
          ::fidl_test_protocols::kChannelProtocol_TakeHandle_Ordinal,
          ::fidl::WireRequest<
              ::fidl_test_protocols::ChannelProtocol::TakeHandle>::Type,
          [](void* interface, void* bytes, ::fidl::Transaction* txn) {
            ::fidl::WireServer<::fidl_test_protocols::ChannelProtocol>::
                TakeHandleCompleter::Sync completer(txn);
            reinterpret_cast<
                ::fidl::WireServer<::fidl_test_protocols::ChannelProtocol>*>(
                interface)
                ->TakeHandle(
                    reinterpret_cast<::fidl::WireRequest<
                        ::fidl_test_protocols::ChannelProtocol::TakeHandle>*>(
                        bytes),
                    completer);
          },
      },
      {
          ::fidl_test_protocols::kChannelProtocol_MutateSocket_Ordinal,
          ::fidl::WireRequest<
              ::fidl_test_protocols::ChannelProtocol::MutateSocket>::Type,
          [](void* interface, void* bytes, ::fidl::Transaction* txn) {
            ::fidl::WireServer<::fidl_test_protocols::ChannelProtocol>::
                MutateSocketCompleter::Sync completer(txn);
            reinterpret_cast<
                ::fidl::WireServer<::fidl_test_protocols::ChannelProtocol>*>(
                interface)
                ->MutateSocket(
                    reinterpret_cast<::fidl::WireRequest<
                        ::fidl_test_protocols::ChannelProtocol::MutateSocket>*>(
                        bytes),
                    completer);
          },
      },
  };
  return ::fidl::internal::TryDispatch(
      impl, msg, txn, entries,
      entries + sizeof(entries) / sizeof(::fidl::internal::MethodEntry));
}

::fidl::DispatchResult fidl::internal::
    WireServerDispatcher<::fidl_test_protocols::ChannelProtocol>::Dispatch(
        ::fidl::WireServer<::fidl_test_protocols::ChannelProtocol>* impl,
        fidl_incoming_msg_t* msg, ::fidl::Transaction* txn) {
  ::fidl::DispatchResult dispatch_result = TryDispatch(impl, msg, txn);
  if (dispatch_result == ::fidl::DispatchResult::kNotFound) {
    FidlHandleInfoCloseMany(msg->handles, msg->num_handles);
    txn->InternalError(
        {::fidl::UnbindInfo::kUnexpectedMessage, ZX_ERR_NOT_SUPPORTED});
  }
  return dispatch_result;
}
::fidl::DispatchResult
fidl::WireServer<::fidl_test_protocols::ChannelProtocol>::dispatch_message(
    fidl_incoming_msg_t* msg, ::fidl::Transaction* txn) {
  return ::fidl::internal::WireServerDispatcher<
      ::fidl_test_protocols::ChannelProtocol>::Dispatch(this, msg, txn);
}

::fidl::DispatchResult fidl::internal::
    WireDispatcher<::fidl_test_protocols::ChannelProtocol>::TryDispatch(
        ::fidl::WireInterface<::fidl_test_protocols::ChannelProtocol>* impl,
        fidl_incoming_msg_t* msg, ::fidl::Transaction* txn) {
  static const ::fidl::internal::MethodEntry entries[] = {
      {
          ::fidl_test_protocols::kChannelProtocol_MethodA_Ordinal,
          ::fidl::WireRequest<
              ::fidl_test_protocols::ChannelProtocol::MethodA>::Type,
          [](void* interface, void* bytes, ::fidl::Transaction* txn) {
            auto message = reinterpret_cast<::fidl::WireRequest<
                ::fidl_test_protocols::ChannelProtocol::MethodA>*>(bytes);
            ::fidl::WireServer<::fidl_test_protocols::ChannelProtocol>::
                MethodACompleter::Sync completer(txn);
            reinterpret_cast<
                ::fidl::WireInterface<::fidl_test_protocols::ChannelProtocol>*>(
                interface)
                ->MethodA(std::move(message->a), std::move(message->b),
                          completer);
          },
      },
      {
          ::fidl_test_protocols::kChannelProtocol_MethodB_Ordinal,
          ::fidl::WireRequest<
              ::fidl_test_protocols::ChannelProtocol::MethodB>::Type,
          [](void* interface, void* bytes, ::fidl::Transaction* txn) {
            auto message = reinterpret_cast<::fidl::WireRequest<
                ::fidl_test_protocols::ChannelProtocol::MethodB>*>(bytes);
            ::fidl::WireServer<::fidl_test_protocols::ChannelProtocol>::
                MethodBCompleter::Sync completer(txn);
            reinterpret_cast<
                ::fidl::WireInterface<::fidl_test_protocols::ChannelProtocol>*>(
                interface)
                ->MethodB(std::move(message->a), std::move(message->b),
                          completer);
          },
      },
      {
          ::fidl_test_protocols::kChannelProtocol_TakeHandle_Ordinal,
          ::fidl::WireRequest<
              ::fidl_test_protocols::ChannelProtocol::TakeHandle>::Type,
          [](void* interface, void* bytes, ::fidl::Transaction* txn) {
            auto message = reinterpret_cast<::fidl::WireRequest<
                ::fidl_test_protocols::ChannelProtocol::TakeHandle>*>(bytes);
            ::fidl::WireServer<::fidl_test_protocols::ChannelProtocol>::
                TakeHandleCompleter::Sync completer(txn);
            reinterpret_cast<
                ::fidl::WireInterface<::fidl_test_protocols::ChannelProtocol>*>(
                interface)
                ->TakeHandle(std::move(message->h), completer);
          },
      },
      {
          ::fidl_test_protocols::kChannelProtocol_MutateSocket_Ordinal,
          ::fidl::WireRequest<
              ::fidl_test_protocols::ChannelProtocol::MutateSocket>::Type,
          [](void* interface, void* bytes, ::fidl::Transaction* txn) {
            auto message = reinterpret_cast<::fidl::WireRequest<
                ::fidl_test_protocols::ChannelProtocol::MutateSocket>*>(bytes);
            ::fidl::WireServer<::fidl_test_protocols::ChannelProtocol>::
                MutateSocketCompleter::Sync completer(txn);
            reinterpret_cast<
                ::fidl::WireInterface<::fidl_test_protocols::ChannelProtocol>*>(
                interface)
                ->MutateSocket(std::move(message->a), completer);
          },
      },
  };
  return ::fidl::internal::TryDispatch(
      impl, msg, txn, entries,
      entries + sizeof(entries) / sizeof(::fidl::internal::MethodEntry));
}

::fidl::DispatchResult fidl::internal::
    WireDispatcher<::fidl_test_protocols::ChannelProtocol>::Dispatch(
        ::fidl::WireInterface<::fidl_test_protocols::ChannelProtocol>* impl,
        fidl_incoming_msg_t* msg, ::fidl::Transaction* txn) {
  ::fidl::DispatchResult dispatch_result = TryDispatch(impl, msg, txn);
  if (dispatch_result == ::fidl::DispatchResult::kNotFound) {
    FidlHandleInfoCloseMany(msg->handles, msg->num_handles);
    txn->InternalError(
        {::fidl::UnbindInfo::kUnexpectedMessage, ZX_ERR_NOT_SUPPORTED});
  }
  return dispatch_result;
}
::fidl::DispatchResult
fidl::WireInterface<::fidl_test_protocols::ChannelProtocol>::dispatch_message(
    fidl_incoming_msg_t* msg, ::fidl::Transaction* txn) {
  return ::fidl::internal::WireDispatcher<
      ::fidl_test_protocols::ChannelProtocol>::Dispatch(this, msg, txn);
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
::fidl::Result fidl::WireServer<::fidl_test_protocols::ChannelProtocol>::
    MethodBCompleterBase::Reply(int64_t result) {
  ::fidl::OwnedEncodedMessage<
      ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::MethodB>>
      _response{result};
  return ::fidl::WireServer<::fidl_test_protocols::ChannelProtocol>::
      MethodBCompleterBase::SendReply(&_response.GetOutgoingMessage());
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
::fidl::Result fidl::WireServer<::fidl_test_protocols::ChannelProtocol>::
    MethodBCompleterBase::Reply(::fidl::BufferSpan _backing_buffer,
                                int64_t result) {
  ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::MethodB>::
      UnownedEncodedMessage _response(_backing_buffer.data,
                                      _backing_buffer.capacity, result);
  return CompleterBase::SendReply(&_response.GetOutgoingMessage());
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
::fidl::Result fidl::WireServer<
    ::fidl_test_protocols::ChannelProtocol>::TakeHandleCompleterBase::Reply() {
  ::fidl::OwnedEncodedMessage<
      ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::TakeHandle>>
      _response{};
  return ::fidl::WireServer<::fidl_test_protocols::ChannelProtocol>::
      TakeHandleCompleterBase::SendReply(&_response.GetOutgoingMessage());
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
::fidl::Result fidl::WireServer<::fidl_test_protocols::ChannelProtocol>::
    MutateSocketCompleterBase::Reply(::zx::socket&& b) {
  ::fidl::OwnedEncodedMessage<::fidl::WireResponse<
      ::fidl_test_protocols::ChannelProtocol::MutateSocket>>
      _response{std::move(b)};
  return ::fidl::WireServer<::fidl_test_protocols::ChannelProtocol>::
      MutateSocketCompleterBase::SendReply(&_response.GetOutgoingMessage());
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
::fidl::Result fidl::WireServer<::fidl_test_protocols::ChannelProtocol>::
    MutateSocketCompleterBase::Reply(::fidl::BufferSpan _backing_buffer,
                                     ::zx::socket&& b) {
  ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::MutateSocket>::
      UnownedEncodedMessage _response(_backing_buffer.data,
                                      _backing_buffer.capacity, std::move(b));
  return CompleterBase::SendReply(&_response.GetOutgoingMessage());
}
#endif  // __Fuchsia__

void ::fidl::WireRequest<::fidl_test_protocols::ChannelProtocol::MethodA>::
    _InitHeader(zx_txid_t _txid) {
  fidl_init_txn_header(&_hdr, _txid,
                       ::fidl_test_protocols::kChannelProtocol_MethodA_Ordinal);
}

void ::fidl::WireResponse<
    ::fidl_test_protocols::ChannelProtocol::EventA>::_InitHeader() {
  fidl_init_txn_header(&_hdr, 0,
                       ::fidl_test_protocols::kChannelProtocol_EventA_Ordinal);
}

void ::fidl::WireRequest<::fidl_test_protocols::ChannelProtocol::MethodB>::
    _InitHeader(zx_txid_t _txid) {
  fidl_init_txn_header(&_hdr, _txid,
                       ::fidl_test_protocols::kChannelProtocol_MethodB_Ordinal);
}

void ::fidl::WireResponse<
    ::fidl_test_protocols::ChannelProtocol::MethodB>::_InitHeader() {
  fidl_init_txn_header(&_hdr, 0,
                       ::fidl_test_protocols::kChannelProtocol_MethodB_Ordinal);
}

void ::fidl::WireRequest<::fidl_test_protocols::ChannelProtocol::TakeHandle>::
    _InitHeader(zx_txid_t _txid) {
  fidl_init_txn_header(
      &_hdr, _txid, ::fidl_test_protocols::kChannelProtocol_TakeHandle_Ordinal);
}

void ::fidl::WireRequest<
    ::fidl_test_protocols::ChannelProtocol::TakeHandle>::_CloseHandles() {
  h.reset();
}

void ::fidl::WireResponse<
    ::fidl_test_protocols::ChannelProtocol::TakeHandle>::_InitHeader() {
  fidl_init_txn_header(
      &_hdr, 0, ::fidl_test_protocols::kChannelProtocol_TakeHandle_Ordinal);
}

void ::fidl::WireRequest<::fidl_test_protocols::ChannelProtocol::MutateSocket>::
    _InitHeader(zx_txid_t _txid) {
  fidl_init_txn_header(
      &_hdr, _txid,
      ::fidl_test_protocols::kChannelProtocol_MutateSocket_Ordinal);
}

void ::fidl::WireRequest<
    ::fidl_test_protocols::ChannelProtocol::MutateSocket>::_CloseHandles() {
  a.reset();
}

void ::fidl::WireResponse<
    ::fidl_test_protocols::ChannelProtocol::MutateSocket>::_InitHeader() {
  fidl_init_txn_header(
      &_hdr, 0, ::fidl_test_protocols::kChannelProtocol_MutateSocket_Ordinal);
}

void ::fidl::WireResponse<
    ::fidl_test_protocols::ChannelProtocol::MutateSocket>::_CloseHandles() {
  b.reset();
}

#ifdef __Fuchsia__

zx_status_t
fidl::WireEventSender<::fidl_test_protocols::ChannelProtocol>::EventA(
    int64_t a, int64_t b) const {
  ::fidl::OwnedEncodedMessage<
      ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::EventA>>
      _response{a, b};
  _response.Write(server_end_);
  return _response.status();
}

zx_status_t
fidl::WireEventSender<::fidl_test_protocols::ChannelProtocol>::EventA(
    ::fidl::BufferSpan _buffer, int64_t a, int64_t b) const {
  ::fidl::UnownedEncodedMessage<
      ::fidl::WireResponse<::fidl_test_protocols::ChannelProtocol::EventA>>
      _response(_buffer.data, _buffer.capacity, a, b);
  _response.Write(server_end_);
  return _response.status();
}

#endif  // __Fuchsia__

namespace fidl_test_protocols {
[[maybe_unused]] constexpr uint64_t
    kWithAndWithoutRequestResponse_NoRequestNoResponse_Ordinal =
        7699066378708085668lu;

extern "C" const fidl_type_t
    fidl_test_protocols_WithAndWithoutRequestResponseNoRequestNoResponseRequestTable;

extern "C" const fidl_type_t
    fidl_test_protocols_WithAndWithoutRequestResponseNoRequestNoResponseResponseTable;

[[maybe_unused]] constexpr uint64_t
    kWithAndWithoutRequestResponse_NoRequestEmptyResponse_Ordinal =
        4641225961522096302lu;

extern "C" const fidl_type_t
    fidl_test_protocols_WithAndWithoutRequestResponseNoRequestEmptyResponseRequestTable;

extern "C" const fidl_type_t
    fidl_test_protocols_WithAndWithoutRequestResponseNoRequestEmptyResponseResponseTable;

[[maybe_unused]] constexpr uint64_t
    kWithAndWithoutRequestResponse_NoRequestWithResponse_Ordinal =
        4935493674668456948lu;

extern "C" const fidl_type_t
    fidl_test_protocols_WithAndWithoutRequestResponseNoRequestWithResponseRequestTable;

extern "C" const fidl_type_t
    fidl_test_protocols_WithAndWithoutRequestResponseNoRequestWithResponseResponseTable;

[[maybe_unused]] constexpr uint64_t
    kWithAndWithoutRequestResponse_WithRequestNoResponse_Ordinal =
        8985942600963248509lu;

extern "C" const fidl_type_t
    fidl_test_protocols_WithAndWithoutRequestResponseWithRequestNoResponseRequestTable;

extern "C" const fidl_type_t
    fidl_test_protocols_WithAndWithoutRequestResponseWithRequestNoResponseResponseTable;

[[maybe_unused]] constexpr uint64_t
    kWithAndWithoutRequestResponse_WithRequestEmptyResponse_Ordinal =
        7344052883704365182lu;

extern "C" const fidl_type_t
    fidl_test_protocols_WithAndWithoutRequestResponseWithRequestEmptyResponseRequestTable;

extern "C" const fidl_type_t
    fidl_test_protocols_WithAndWithoutRequestResponseWithRequestEmptyResponseResponseTable;

[[maybe_unused]] constexpr uint64_t
    kWithAndWithoutRequestResponse_WithRequestWithResponse_Ordinal =
        2103802322332450033lu;

extern "C" const fidl_type_t
    fidl_test_protocols_WithAndWithoutRequestResponseWithRequestWithResponseRequestTable;

extern "C" const fidl_type_t
    fidl_test_protocols_WithAndWithoutRequestResponseWithRequestWithResponseResponseTable;

[[maybe_unused]] constexpr uint64_t
    kWithAndWithoutRequestResponse_OnEmptyResponse_Ordinal =
        1323081535741489193lu;

extern "C" const fidl_type_t
    fidl_test_protocols_WithAndWithoutRequestResponseOnEmptyResponseRequestTable;

extern "C" const fidl_type_t
    fidl_test_protocols_WithAndWithoutRequestResponseOnEmptyResponseEventTable;

[[maybe_unused]] constexpr uint64_t
    kWithAndWithoutRequestResponse_OnWithResponse_Ordinal =
        1691906546593908418lu;

extern "C" const fidl_type_t
    fidl_test_protocols_WithAndWithoutRequestResponseOnWithResponseRequestTable;

extern "C" const fidl_type_t
    fidl_test_protocols_WithAndWithoutRequestResponseOnWithResponseEventTable;
#ifdef __Fuchsia__
}  // namespace fidl_test_protocols
::fidl::WireResult<
    ::fidl_test_protocols::WithAndWithoutRequestResponse::NoRequestNoResponse>::
    WireResult(::fidl::UnownedClientEnd<
               ::fidl_test_protocols::WithAndWithoutRequestResponse>
                   _client) {
  ::fidl::OwnedEncodedMessage<
      ::fidl::WireRequest<::fidl_test_protocols::WithAndWithoutRequestResponse::
                              NoRequestNoResponse>>
      _request(zx_txid_t(0));
  _request.GetOutgoingMessage().Write(_client);
  status_ = _request.status();
  error_ = _request.error();
}
namespace fidl_test_protocols {
#endif  // __Fuchsia__

#ifdef __Fuchsia__
}  // namespace fidl_test_protocols
::fidl::WireResult<::fidl_test_protocols::WithAndWithoutRequestResponse::
                       NoRequestEmptyResponse>::
    WireResult(::fidl::UnownedClientEnd<
               ::fidl_test_protocols::WithAndWithoutRequestResponse>
                   _client) {
  ::fidl::OwnedEncodedMessage<
      ::fidl::WireRequest<::fidl_test_protocols::WithAndWithoutRequestResponse::
                              NoRequestEmptyResponse>>
      _request(zx_txid_t(0));
  _request.GetOutgoingMessage()
      .Call<::fidl::WireResponse<
          ::fidl_test_protocols::WithAndWithoutRequestResponse::
              NoRequestEmptyResponse>>(_client, bytes_.data(), bytes_.size());
  status_ = _request.status();
  error_ = _request.error();
}

::fidl::WireResult<::fidl_test_protocols::WithAndWithoutRequestResponse::
                       NoRequestEmptyResponse>::
    WireResult(::fidl::UnownedClientEnd<
                   ::fidl_test_protocols::WithAndWithoutRequestResponse>
                   _client,
               zx_time_t _deadline) {
  ::fidl::OwnedEncodedMessage<
      ::fidl::WireRequest<::fidl_test_protocols::WithAndWithoutRequestResponse::
                              NoRequestEmptyResponse>>
      _request(zx_txid_t(0));
  _request.GetOutgoingMessage()
      .Call<::fidl::WireResponse<
          ::fidl_test_protocols::WithAndWithoutRequestResponse::
              NoRequestEmptyResponse>>(_client, bytes_.data(), bytes_.size(),
                                       _deadline);
  status_ = _request.status();
  error_ = _request.error();
}
namespace fidl_test_protocols {
#endif  // __Fuchsia__

#ifdef __Fuchsia__
}  // namespace fidl_test_protocols
::fidl::WireResult<::fidl_test_protocols::WithAndWithoutRequestResponse::
                       NoRequestWithResponse>::
    WireResult(::fidl::UnownedClientEnd<
               ::fidl_test_protocols::WithAndWithoutRequestResponse>
                   _client) {
  ::fidl::OwnedEncodedMessage<
      ::fidl::WireRequest<::fidl_test_protocols::WithAndWithoutRequestResponse::
                              NoRequestWithResponse>>
      _request(zx_txid_t(0));
  _request.GetOutgoingMessage()
      .Call<::fidl::WireResponse<
          ::fidl_test_protocols::WithAndWithoutRequestResponse::
              NoRequestWithResponse>>(_client, bytes_.data(), bytes_.size());
  status_ = _request.status();
  error_ = _request.error();
}

::fidl::WireResult<::fidl_test_protocols::WithAndWithoutRequestResponse::
                       NoRequestWithResponse>::
    WireResult(::fidl::UnownedClientEnd<
                   ::fidl_test_protocols::WithAndWithoutRequestResponse>
                   _client,
               zx_time_t _deadline) {
  ::fidl::OwnedEncodedMessage<
      ::fidl::WireRequest<::fidl_test_protocols::WithAndWithoutRequestResponse::
                              NoRequestWithResponse>>
      _request(zx_txid_t(0));
  _request.GetOutgoingMessage()
      .Call<::fidl::WireResponse<
          ::fidl_test_protocols::WithAndWithoutRequestResponse::
              NoRequestWithResponse>>(_client, bytes_.data(), bytes_.size(),
                                      _deadline);
  status_ = _request.status();
  error_ = _request.error();
}
namespace fidl_test_protocols {
#endif  // __Fuchsia__

#ifdef __Fuchsia__
}  // namespace fidl_test_protocols
::fidl::WireUnownedResult<::fidl_test_protocols::WithAndWithoutRequestResponse::
                              NoRequestWithResponse>::
    WireUnownedResult(::fidl::UnownedClientEnd<
                          ::fidl_test_protocols::WithAndWithoutRequestResponse>
                          _client,
                      uint8_t* _response_bytes,
                      uint32_t _response_byte_capacity)
    : bytes_(_response_bytes) {
  ::fidl::OwnedEncodedMessage<
      ::fidl::WireRequest<::fidl_test_protocols::WithAndWithoutRequestResponse::
                              NoRequestWithResponse>>
      _request(zx_txid_t(0));
  _request.GetOutgoingMessage()
      .Call<::fidl::WireResponse<
          ::fidl_test_protocols::WithAndWithoutRequestResponse::
              NoRequestWithResponse>>(_client, _response_bytes,
                                      _response_byte_capacity);
  status_ = _request.status();
  error_ = _request.error();
}
namespace fidl_test_protocols {
#endif  // __Fuchsia__

#ifdef __Fuchsia__
}  // namespace fidl_test_protocols
::fidl::WireResult<::fidl_test_protocols::WithAndWithoutRequestResponse::
                       WithRequestNoResponse>::
    WireResult(::fidl::UnownedClientEnd<
                   ::fidl_test_protocols::WithAndWithoutRequestResponse>
                   _client,
               ::fidl::StringView arg) {
  ::fidl::OwnedEncodedMessage<
      ::fidl::WireRequest<::fidl_test_protocols::WithAndWithoutRequestResponse::
                              WithRequestNoResponse>>
      _request(zx_txid_t(0), arg);
  _request.GetOutgoingMessage().Write(_client);
  status_ = _request.status();
  error_ = _request.error();
}
namespace fidl_test_protocols {
#endif  // __Fuchsia__

#ifdef __Fuchsia__
}  // namespace fidl_test_protocols
::fidl::WireUnownedResult<::fidl_test_protocols::WithAndWithoutRequestResponse::
                              WithRequestNoResponse>::
    WireUnownedResult(::fidl::UnownedClientEnd<
                          ::fidl_test_protocols::WithAndWithoutRequestResponse>
                          _client,
                      uint8_t* _request_bytes, uint32_t _request_byte_capacity,
                      ::fidl::StringView arg) {
  ::fidl::UnownedEncodedMessage<
      ::fidl::WireRequest<::fidl_test_protocols::WithAndWithoutRequestResponse::
                              WithRequestNoResponse>>
      _request(_request_bytes, _request_byte_capacity, 0, arg);
  _request.GetOutgoingMessage().Write(_client);
  status_ = _request.status();
  error_ = _request.error();
}
namespace fidl_test_protocols {
#endif  // __Fuchsia__

#ifdef __Fuchsia__
}  // namespace fidl_test_protocols
::fidl::WireResult<::fidl_test_protocols::WithAndWithoutRequestResponse::
                       WithRequestEmptyResponse>::
    WireResult(::fidl::UnownedClientEnd<
                   ::fidl_test_protocols::WithAndWithoutRequestResponse>
                   _client,
               ::fidl::StringView arg) {
  ::fidl::OwnedEncodedMessage<
      ::fidl::WireRequest<::fidl_test_protocols::WithAndWithoutRequestResponse::
                              WithRequestEmptyResponse>>
      _request(zx_txid_t(0), arg);
  _request.GetOutgoingMessage()
      .Call<::fidl::WireResponse<
          ::fidl_test_protocols::WithAndWithoutRequestResponse::
              WithRequestEmptyResponse>>(_client, bytes_.data(), bytes_.size());
  status_ = _request.status();
  error_ = _request.error();
}

::fidl::WireResult<::fidl_test_protocols::WithAndWithoutRequestResponse::
                       WithRequestEmptyResponse>::
    WireResult(::fidl::UnownedClientEnd<
                   ::fidl_test_protocols::WithAndWithoutRequestResponse>
                   _client,
               ::fidl::StringView arg, zx_time_t _deadline) {
  ::fidl::OwnedEncodedMessage<
      ::fidl::WireRequest<::fidl_test_protocols::WithAndWithoutRequestResponse::
                              WithRequestEmptyResponse>>
      _request(zx_txid_t(0), arg);
  _request.GetOutgoingMessage()
      .Call<::fidl::WireResponse<
          ::fidl_test_protocols::WithAndWithoutRequestResponse::
              WithRequestEmptyResponse>>(_client, bytes_.data(), bytes_.size(),
                                         _deadline);
  status_ = _request.status();
  error_ = _request.error();
}
namespace fidl_test_protocols {
#endif  // __Fuchsia__

#ifdef __Fuchsia__
}  // namespace fidl_test_protocols
::fidl::WireUnownedResult<::fidl_test_protocols::WithAndWithoutRequestResponse::
                              WithRequestEmptyResponse>::
    WireUnownedResult(::fidl::UnownedClientEnd<
                          ::fidl_test_protocols::WithAndWithoutRequestResponse>
                          _client,
                      uint8_t* _request_bytes, uint32_t _request_byte_capacity,
                      ::fidl::StringView arg, uint8_t* _response_bytes,
                      uint32_t _response_byte_capacity)
    : bytes_(_response_bytes) {
  ::fidl::UnownedEncodedMessage<
      ::fidl::WireRequest<::fidl_test_protocols::WithAndWithoutRequestResponse::
                              WithRequestEmptyResponse>>
      _request(_request_bytes, _request_byte_capacity, 0, arg);
  _request.GetOutgoingMessage()
      .Call<::fidl::WireResponse<
          ::fidl_test_protocols::WithAndWithoutRequestResponse::
              WithRequestEmptyResponse>>(_client, _response_bytes,
                                         _response_byte_capacity);
  status_ = _request.status();
  error_ = _request.error();
}
namespace fidl_test_protocols {
#endif  // __Fuchsia__

#ifdef __Fuchsia__
}  // namespace fidl_test_protocols
::fidl::WireResult<::fidl_test_protocols::WithAndWithoutRequestResponse::
                       WithRequestWithResponse>::
    WireResult(::fidl::UnownedClientEnd<
                   ::fidl_test_protocols::WithAndWithoutRequestResponse>
                   _client,
               ::fidl::StringView arg) {
  ::fidl::OwnedEncodedMessage<
      ::fidl::WireRequest<::fidl_test_protocols::WithAndWithoutRequestResponse::
                              WithRequestWithResponse>>
      _request(zx_txid_t(0), arg);
  _request.GetOutgoingMessage()
      .Call<::fidl::WireResponse<
          ::fidl_test_protocols::WithAndWithoutRequestResponse::
              WithRequestWithResponse>>(_client, bytes_.data(), bytes_.size());
  status_ = _request.status();
  error_ = _request.error();
}

::fidl::WireResult<::fidl_test_protocols::WithAndWithoutRequestResponse::
                       WithRequestWithResponse>::
    WireResult(::fidl::UnownedClientEnd<
                   ::fidl_test_protocols::WithAndWithoutRequestResponse>
                   _client,
               ::fidl::StringView arg, zx_time_t _deadline) {
  ::fidl::OwnedEncodedMessage<
      ::fidl::WireRequest<::fidl_test_protocols::WithAndWithoutRequestResponse::
                              WithRequestWithResponse>>
      _request(zx_txid_t(0), arg);
  _request.GetOutgoingMessage()
      .Call<::fidl::WireResponse<
          ::fidl_test_protocols::WithAndWithoutRequestResponse::
              WithRequestWithResponse>>(_client, bytes_.data(), bytes_.size(),
                                        _deadline);
  status_ = _request.status();
  error_ = _request.error();
}
namespace fidl_test_protocols {
#endif  // __Fuchsia__

#ifdef __Fuchsia__
}  // namespace fidl_test_protocols
::fidl::WireUnownedResult<::fidl_test_protocols::WithAndWithoutRequestResponse::
                              WithRequestWithResponse>::
    WireUnownedResult(::fidl::UnownedClientEnd<
                          ::fidl_test_protocols::WithAndWithoutRequestResponse>
                          _client,
                      uint8_t* _request_bytes, uint32_t _request_byte_capacity,
                      ::fidl::StringView arg, uint8_t* _response_bytes,
                      uint32_t _response_byte_capacity)
    : bytes_(_response_bytes) {
  ::fidl::UnownedEncodedMessage<
      ::fidl::WireRequest<::fidl_test_protocols::WithAndWithoutRequestResponse::
                              WithRequestWithResponse>>
      _request(_request_bytes, _request_byte_capacity, 0, arg);
  _request.GetOutgoingMessage()
      .Call<::fidl::WireResponse<
          ::fidl_test_protocols::WithAndWithoutRequestResponse::
              WithRequestWithResponse>>(_client, _response_bytes,
                                        _response_byte_capacity);
  status_ = _request.status();
  error_ = _request.error();
}
namespace fidl_test_protocols {
#endif  // __Fuchsia__

}  // namespace fidl_test_protocols
#ifdef __Fuchsia__
::fidl::Result fidl::internal::WireClientImpl<
    ::fidl_test_protocols::WithAndWithoutRequestResponse>::
    NoRequestNoResponse() {
  if (auto _channel = ::fidl::internal::ClientBase::GetChannel()) {
    auto _res = ::fidl::WireResult<
        ::fidl_test_protocols::WithAndWithoutRequestResponse::
            NoRequestNoResponse>(
        ::fidl::UnownedClientEnd<
            ::fidl_test_protocols::WithAndWithoutRequestResponse>(
            _channel->handle()));
    return ::fidl::Result(_res.status(), _res.error());
  }
  return ::fidl::Result(ZX_ERR_CANCELED, ::fidl::kErrorChannelUnbound);
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
::fidl::WireResult<::fidl_test_protocols::WithAndWithoutRequestResponse::
                       NoRequestEmptyResponse>
fidl::internal::WireClientImpl<
    ::fidl_test_protocols::WithAndWithoutRequestResponse>::
    NoRequestEmptyResponse_Sync() {
  if (auto _channel = ::fidl::internal::ClientBase::GetChannel()) {
    return ::fidl::WireResult<
        ::fidl_test_protocols::WithAndWithoutRequestResponse::
            NoRequestEmptyResponse>(
        ::fidl::UnownedClientEnd<
            ::fidl_test_protocols::WithAndWithoutRequestResponse>(
            _channel->handle()));
  }
  return ::fidl::WireResult<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::
          NoRequestEmptyResponse>(
      ::fidl::Result(ZX_ERR_CANCELED, ::fidl::kErrorChannelUnbound));
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__

::fidl::WireResponseContext<
    ::fidl_test_protocols::WithAndWithoutRequestResponse::
        NoRequestEmptyResponse>::WireResponseContext()
    : ::fidl::internal::ResponseContext(
          ::fidl::WireResponse<
              ::fidl_test_protocols::WithAndWithoutRequestResponse::
                  NoRequestEmptyResponse>::Type,
          ::fidl_test_protocols::
              kWithAndWithoutRequestResponse_NoRequestEmptyResponse_Ordinal) {}

void ::fidl::WireResponseContext<
    ::fidl_test_protocols::WithAndWithoutRequestResponse::
        NoRequestEmptyResponse>::OnReply(uint8_t* reply) {
  OnReply(reinterpret_cast<::fidl::WireResponse<
              ::fidl_test_protocols::WithAndWithoutRequestResponse::
                  NoRequestEmptyResponse>*>(reply));
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
::fidl::Result fidl::internal::WireClientImpl<
    ::fidl_test_protocols::WithAndWithoutRequestResponse>::
    NoRequestEmptyResponse(
        ::fit::callback<
            void(::fidl::WireResponse<
                 ::fidl_test_protocols::WithAndWithoutRequestResponse::
                     NoRequestEmptyResponse>* response)>
            _cb) {
  class ResponseContext final
      : public ::fidl::WireResponseContext<
            ::fidl_test_protocols::WithAndWithoutRequestResponse::
                NoRequestEmptyResponse> {
   public:
    ResponseContext(::fit::callback<
                    void(::fidl::WireResponse<
                         ::fidl_test_protocols::WithAndWithoutRequestResponse::
                             NoRequestEmptyResponse>* response)>
                        cb)
        : cb_(std::move(cb)) {}

    void OnReply(::fidl::WireResponse<
                 ::fidl_test_protocols::WithAndWithoutRequestResponse::
                     NoRequestEmptyResponse>* response) override {
      cb_(response);

      delete this;
    }

    void OnError() override { delete this; }

   private:
    ::fit::callback<void(::fidl::WireResponse<
                         ::fidl_test_protocols::WithAndWithoutRequestResponse::
                             NoRequestEmptyResponse>* response)>
        cb_;
  };

  auto* _context = new ResponseContext(std::move(_cb));
  ::fidl::internal::ClientBase::PrepareAsyncTxn(_context);
  ::fidl::WireRequest<::fidl_test_protocols::WithAndWithoutRequestResponse::
                          NoRequestEmptyResponse>::OwnedEncodedMessage
      _request(_context->Txid());
  return _request.GetOutgoingMessage().Write(this, _context);
}

::fidl::Result fidl::internal::WireClientImpl<
    ::fidl_test_protocols::WithAndWithoutRequestResponse>::
    NoRequestEmptyResponse(
        ::fidl::WireResponseContext<
            ::fidl_test_protocols::WithAndWithoutRequestResponse::
                NoRequestEmptyResponse>* _context) {
  ::fidl::internal::ClientBase::PrepareAsyncTxn(_context);

  ::fidl::WireRequest<::fidl_test_protocols::WithAndWithoutRequestResponse::
                          NoRequestEmptyResponse>::OwnedEncodedMessage
      _request(_context->Txid());
  return _request.GetOutgoingMessage().Write(this, _context);
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
::fidl::WireResult<
    ::fidl_test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse>
fidl::internal::WireClientImpl<
    ::fidl_test_protocols::WithAndWithoutRequestResponse>::
    NoRequestWithResponse_Sync() {
  if (auto _channel = ::fidl::internal::ClientBase::GetChannel()) {
    return ::fidl::WireResult<
        ::fidl_test_protocols::WithAndWithoutRequestResponse::
            NoRequestWithResponse>(
        ::fidl::UnownedClientEnd<
            ::fidl_test_protocols::WithAndWithoutRequestResponse>(
            _channel->handle()));
  }
  return ::fidl::WireResult<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::
          NoRequestWithResponse>(
      ::fidl::Result(ZX_ERR_CANCELED, ::fidl::kErrorChannelUnbound));
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
::fidl::WireUnownedResult<
    ::fidl_test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse>
fidl::internal::WireClientImpl<
    ::fidl_test_protocols::WithAndWithoutRequestResponse>::
    NoRequestWithResponse_Sync(::fidl::BufferSpan _response_buffer) {
  if (auto _channel = ::fidl::internal::ClientBase::GetChannel()) {
    return ::fidl::WireUnownedResult<
        ::fidl_test_protocols::WithAndWithoutRequestResponse::
            NoRequestWithResponse>(
        ::fidl::UnownedClientEnd<
            ::fidl_test_protocols::WithAndWithoutRequestResponse>(
            _channel->handle()),
        _response_buffer.data, _response_buffer.capacity);
  }
  return ::fidl::WireUnownedResult<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::
          NoRequestWithResponse>(
      ::fidl::Result(ZX_ERR_CANCELED, ::fidl::kErrorChannelUnbound));
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__

::fidl::WireResponseContext<
    ::fidl_test_protocols::WithAndWithoutRequestResponse::
        NoRequestWithResponse>::WireResponseContext()
    : ::fidl::internal::ResponseContext(
          ::fidl::WireResponse<
              ::fidl_test_protocols::WithAndWithoutRequestResponse::
                  NoRequestWithResponse>::Type,
          ::fidl_test_protocols::
              kWithAndWithoutRequestResponse_NoRequestWithResponse_Ordinal) {}

void ::fidl::WireResponseContext<
    ::fidl_test_protocols::WithAndWithoutRequestResponse::
        NoRequestWithResponse>::OnReply(uint8_t* reply) {
  OnReply(reinterpret_cast<::fidl::WireResponse<
              ::fidl_test_protocols::WithAndWithoutRequestResponse::
                  NoRequestWithResponse>*>(reply));
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
::fidl::Result fidl::internal::WireClientImpl<
    ::fidl_test_protocols::WithAndWithoutRequestResponse>::
    NoRequestWithResponse(
        ::fit::callback<
            void(::fidl::WireResponse<
                 ::fidl_test_protocols::WithAndWithoutRequestResponse::
                     NoRequestWithResponse>* response)>
            _cb) {
  class ResponseContext final
      : public ::fidl::WireResponseContext<
            ::fidl_test_protocols::WithAndWithoutRequestResponse::
                NoRequestWithResponse> {
   public:
    ResponseContext(::fit::callback<
                    void(::fidl::WireResponse<
                         ::fidl_test_protocols::WithAndWithoutRequestResponse::
                             NoRequestWithResponse>* response)>
                        cb)
        : cb_(std::move(cb)) {}

    void OnReply(::fidl::WireResponse<
                 ::fidl_test_protocols::WithAndWithoutRequestResponse::
                     NoRequestWithResponse>* response) override {
      cb_(response);

      delete this;
    }

    void OnError() override { delete this; }

   private:
    ::fit::callback<void(::fidl::WireResponse<
                         ::fidl_test_protocols::WithAndWithoutRequestResponse::
                             NoRequestWithResponse>* response)>
        cb_;
  };

  auto* _context = new ResponseContext(std::move(_cb));
  ::fidl::internal::ClientBase::PrepareAsyncTxn(_context);
  ::fidl::WireRequest<::fidl_test_protocols::WithAndWithoutRequestResponse::
                          NoRequestWithResponse>::OwnedEncodedMessage
      _request(_context->Txid());
  return _request.GetOutgoingMessage().Write(this, _context);
}

::fidl::Result fidl::internal::WireClientImpl<
    ::fidl_test_protocols::WithAndWithoutRequestResponse>::
    NoRequestWithResponse(::fidl::WireResponseContext<
                          ::fidl_test_protocols::WithAndWithoutRequestResponse::
                              NoRequestWithResponse>* _context) {
  ::fidl::internal::ClientBase::PrepareAsyncTxn(_context);

  ::fidl::WireRequest<::fidl_test_protocols::WithAndWithoutRequestResponse::
                          NoRequestWithResponse>::OwnedEncodedMessage
      _request(_context->Txid());
  return _request.GetOutgoingMessage().Write(this, _context);
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
::fidl::Result fidl::internal::WireClientImpl<
    ::fidl_test_protocols::WithAndWithoutRequestResponse>::
    WithRequestNoResponse(::fidl::StringView arg) {
  if (auto _channel = ::fidl::internal::ClientBase::GetChannel()) {
    auto _res = ::fidl::WireResult<
        ::fidl_test_protocols::WithAndWithoutRequestResponse::
            WithRequestNoResponse>(
        ::fidl::UnownedClientEnd<
            ::fidl_test_protocols::WithAndWithoutRequestResponse>(
            _channel->handle()),
        arg);
    return ::fidl::Result(_res.status(), _res.error());
  }
  return ::fidl::Result(ZX_ERR_CANCELED, ::fidl::kErrorChannelUnbound);
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
::fidl::Result fidl::internal::WireClientImpl<
    ::fidl_test_protocols::WithAndWithoutRequestResponse>::
    WithRequestNoResponse(::fidl::BufferSpan _request_buffer,
                          ::fidl::StringView arg) {
  if (auto _channel = ::fidl::internal::ClientBase::GetChannel()) {
    auto _res = ::fidl::WireUnownedResult<
        ::fidl_test_protocols::WithAndWithoutRequestResponse::
            WithRequestNoResponse>(
        ::fidl::UnownedClientEnd<
            ::fidl_test_protocols::WithAndWithoutRequestResponse>(
            _channel->handle()),
        _request_buffer.data, _request_buffer.capacity, arg);
    return ::fidl::Result(_res.status(), _res.error());
  }
  return ::fidl::Result(ZX_ERR_CANCELED, ::fidl::kErrorChannelUnbound);
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
::fidl::WireResult<::fidl_test_protocols::WithAndWithoutRequestResponse::
                       WithRequestEmptyResponse>
fidl::internal::WireClientImpl<
    ::fidl_test_protocols::WithAndWithoutRequestResponse>::
    WithRequestEmptyResponse_Sync(::fidl::StringView arg) {
  if (auto _channel = ::fidl::internal::ClientBase::GetChannel()) {
    return ::fidl::WireResult<
        ::fidl_test_protocols::WithAndWithoutRequestResponse::
            WithRequestEmptyResponse>(
        ::fidl::UnownedClientEnd<
            ::fidl_test_protocols::WithAndWithoutRequestResponse>(
            _channel->handle()),
        arg);
  }
  return ::fidl::WireResult<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::
          WithRequestEmptyResponse>(
      ::fidl::Result(ZX_ERR_CANCELED, ::fidl::kErrorChannelUnbound));
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
::fidl::WireUnownedResult<::fidl_test_protocols::WithAndWithoutRequestResponse::
                              WithRequestEmptyResponse>
fidl::internal::WireClientImpl<
    ::fidl_test_protocols::WithAndWithoutRequestResponse>::
    WithRequestEmptyResponse_Sync(::fidl::BufferSpan _request_buffer,
                                  ::fidl::StringView arg,
                                  ::fidl::BufferSpan _response_buffer) {
  if (auto _channel = ::fidl::internal::ClientBase::GetChannel()) {
    return ::fidl::WireUnownedResult<
        ::fidl_test_protocols::WithAndWithoutRequestResponse::
            WithRequestEmptyResponse>(
        ::fidl::UnownedClientEnd<
            ::fidl_test_protocols::WithAndWithoutRequestResponse>(
            _channel->handle()),
        _request_buffer.data, _request_buffer.capacity, arg,
        _response_buffer.data, _response_buffer.capacity);
  }
  return ::fidl::WireUnownedResult<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::
          WithRequestEmptyResponse>(
      ::fidl::Result(ZX_ERR_CANCELED, ::fidl::kErrorChannelUnbound));
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__

::fidl::WireResponseContext<
    ::fidl_test_protocols::WithAndWithoutRequestResponse::
        WithRequestEmptyResponse>::WireResponseContext()
    : ::fidl::internal::ResponseContext(
          ::fidl::WireResponse<
              ::fidl_test_protocols::WithAndWithoutRequestResponse::
                  WithRequestEmptyResponse>::Type,
          ::fidl_test_protocols::
              kWithAndWithoutRequestResponse_WithRequestEmptyResponse_Ordinal) {
}

void ::fidl::WireResponseContext<
    ::fidl_test_protocols::WithAndWithoutRequestResponse::
        WithRequestEmptyResponse>::OnReply(uint8_t* reply) {
  OnReply(reinterpret_cast<::fidl::WireResponse<
              ::fidl_test_protocols::WithAndWithoutRequestResponse::
                  WithRequestEmptyResponse>*>(reply));
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
::fidl::Result fidl::internal::WireClientImpl<
    ::fidl_test_protocols::WithAndWithoutRequestResponse>::
    WithRequestEmptyResponse(
        ::fidl::StringView arg,
        ::fit::callback<
            void(::fidl::WireResponse<
                 ::fidl_test_protocols::WithAndWithoutRequestResponse::
                     WithRequestEmptyResponse>* response)>
            _cb) {
  class ResponseContext final
      : public ::fidl::WireResponseContext<
            ::fidl_test_protocols::WithAndWithoutRequestResponse::
                WithRequestEmptyResponse> {
   public:
    ResponseContext(::fit::callback<
                    void(::fidl::WireResponse<
                         ::fidl_test_protocols::WithAndWithoutRequestResponse::
                             WithRequestEmptyResponse>* response)>
                        cb)
        : cb_(std::move(cb)) {}

    void OnReply(::fidl::WireResponse<
                 ::fidl_test_protocols::WithAndWithoutRequestResponse::
                     WithRequestEmptyResponse>* response) override {
      cb_(response);

      delete this;
    }

    void OnError() override { delete this; }

   private:
    ::fit::callback<void(::fidl::WireResponse<
                         ::fidl_test_protocols::WithAndWithoutRequestResponse::
                             WithRequestEmptyResponse>* response)>
        cb_;
  };

  auto* _context = new ResponseContext(std::move(_cb));
  ::fidl::internal::ClientBase::PrepareAsyncTxn(_context);
  ::fidl::WireRequest<::fidl_test_protocols::WithAndWithoutRequestResponse::
                          WithRequestEmptyResponse>::OwnedEncodedMessage
      _request(_context->Txid(), arg);
  return _request.GetOutgoingMessage().Write(this, _context);
}

::fidl::Result fidl::internal::WireClientImpl<
    ::fidl_test_protocols::WithAndWithoutRequestResponse>::
    WithRequestEmptyResponse(
        ::fidl::BufferSpan _request_buffer, ::fidl::StringView arg,
        ::fidl::WireResponseContext<
            ::fidl_test_protocols::WithAndWithoutRequestResponse::
                WithRequestEmptyResponse>* _context) {
  ::fidl::internal::ClientBase::PrepareAsyncTxn(_context);

  ::fidl::WireRequest<::fidl_test_protocols::WithAndWithoutRequestResponse::
                          WithRequestEmptyResponse>::UnownedEncodedMessage
      _request(_request_buffer.data, _request_buffer.capacity, _context->Txid(),
               arg);
  return _request.GetOutgoingMessage().Write(this, _context);
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
::fidl::WireResult<::fidl_test_protocols::WithAndWithoutRequestResponse::
                       WithRequestWithResponse>
fidl::internal::WireClientImpl<
    ::fidl_test_protocols::WithAndWithoutRequestResponse>::
    WithRequestWithResponse_Sync(::fidl::StringView arg) {
  if (auto _channel = ::fidl::internal::ClientBase::GetChannel()) {
    return ::fidl::WireResult<
        ::fidl_test_protocols::WithAndWithoutRequestResponse::
            WithRequestWithResponse>(
        ::fidl::UnownedClientEnd<
            ::fidl_test_protocols::WithAndWithoutRequestResponse>(
            _channel->handle()),
        arg);
  }
  return ::fidl::WireResult<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::
          WithRequestWithResponse>(
      ::fidl::Result(ZX_ERR_CANCELED, ::fidl::kErrorChannelUnbound));
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
::fidl::WireUnownedResult<::fidl_test_protocols::WithAndWithoutRequestResponse::
                              WithRequestWithResponse>
fidl::internal::WireClientImpl<
    ::fidl_test_protocols::WithAndWithoutRequestResponse>::
    WithRequestWithResponse_Sync(::fidl::BufferSpan _request_buffer,
                                 ::fidl::StringView arg,
                                 ::fidl::BufferSpan _response_buffer) {
  if (auto _channel = ::fidl::internal::ClientBase::GetChannel()) {
    return ::fidl::WireUnownedResult<
        ::fidl_test_protocols::WithAndWithoutRequestResponse::
            WithRequestWithResponse>(
        ::fidl::UnownedClientEnd<
            ::fidl_test_protocols::WithAndWithoutRequestResponse>(
            _channel->handle()),
        _request_buffer.data, _request_buffer.capacity, arg,
        _response_buffer.data, _response_buffer.capacity);
  }
  return ::fidl::WireUnownedResult<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::
          WithRequestWithResponse>(
      ::fidl::Result(ZX_ERR_CANCELED, ::fidl::kErrorChannelUnbound));
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__

::fidl::WireResponseContext<
    ::fidl_test_protocols::WithAndWithoutRequestResponse::
        WithRequestWithResponse>::WireResponseContext()
    : ::fidl::internal::ResponseContext(
          ::fidl::WireResponse<
              ::fidl_test_protocols::WithAndWithoutRequestResponse::
                  WithRequestWithResponse>::Type,
          ::fidl_test_protocols::
              kWithAndWithoutRequestResponse_WithRequestWithResponse_Ordinal) {}

void ::fidl::WireResponseContext<
    ::fidl_test_protocols::WithAndWithoutRequestResponse::
        WithRequestWithResponse>::OnReply(uint8_t* reply) {
  OnReply(reinterpret_cast<::fidl::WireResponse<
              ::fidl_test_protocols::WithAndWithoutRequestResponse::
                  WithRequestWithResponse>*>(reply));
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
::fidl::Result fidl::internal::WireClientImpl<
    ::fidl_test_protocols::WithAndWithoutRequestResponse>::
    WithRequestWithResponse(
        ::fidl::StringView arg,
        ::fit::callback<
            void(::fidl::WireResponse<
                 ::fidl_test_protocols::WithAndWithoutRequestResponse::
                     WithRequestWithResponse>* response)>
            _cb) {
  class ResponseContext final
      : public ::fidl::WireResponseContext<
            ::fidl_test_protocols::WithAndWithoutRequestResponse::
                WithRequestWithResponse> {
   public:
    ResponseContext(::fit::callback<
                    void(::fidl::WireResponse<
                         ::fidl_test_protocols::WithAndWithoutRequestResponse::
                             WithRequestWithResponse>* response)>
                        cb)
        : cb_(std::move(cb)) {}

    void OnReply(::fidl::WireResponse<
                 ::fidl_test_protocols::WithAndWithoutRequestResponse::
                     WithRequestWithResponse>* response) override {
      cb_(response);

      delete this;
    }

    void OnError() override { delete this; }

   private:
    ::fit::callback<void(::fidl::WireResponse<
                         ::fidl_test_protocols::WithAndWithoutRequestResponse::
                             WithRequestWithResponse>* response)>
        cb_;
  };

  auto* _context = new ResponseContext(std::move(_cb));
  ::fidl::internal::ClientBase::PrepareAsyncTxn(_context);
  ::fidl::WireRequest<::fidl_test_protocols::WithAndWithoutRequestResponse::
                          WithRequestWithResponse>::OwnedEncodedMessage
      _request(_context->Txid(), arg);
  return _request.GetOutgoingMessage().Write(this, _context);
}

::fidl::Result fidl::internal::WireClientImpl<
    ::fidl_test_protocols::WithAndWithoutRequestResponse>::
    WithRequestWithResponse(
        ::fidl::BufferSpan _request_buffer, ::fidl::StringView arg,
        ::fidl::WireResponseContext<
            ::fidl_test_protocols::WithAndWithoutRequestResponse::
                WithRequestWithResponse>* _context) {
  ::fidl::internal::ClientBase::PrepareAsyncTxn(_context);

  ::fidl::WireRequest<::fidl_test_protocols::WithAndWithoutRequestResponse::
                          WithRequestWithResponse>::UnownedEncodedMessage
      _request(_request_buffer.data, _request_buffer.capacity, _context->Txid(),
               arg);
  return _request.GetOutgoingMessage().Write(this, _context);
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
std::optional<::fidl::UnbindInfo> fidl::internal::WireClientImpl<
    ::fidl_test_protocols::WithAndWithoutRequestResponse>::
    DispatchEvent(fidl_incoming_msg_t* msg) {
  if (event_handler_ != nullptr) {
    fidl_message_header_t* hdr =
        reinterpret_cast<fidl_message_header_t*>(msg->bytes);
    switch (hdr->ordinal) {
      case ::fidl_test_protocols::
          kWithAndWithoutRequestResponse_OnEmptyResponse_Ordinal: {
        const char* error_message;
        zx_status_t status = fidl_decode_etc(
            ::fidl::WireResponse<
                ::fidl_test_protocols::WithAndWithoutRequestResponse::
                    OnEmptyResponse>::Type,
            msg->bytes, msg->num_bytes, msg->handles, msg->num_handles,
            &error_message);
        if (status != ZX_OK) {
          return ::fidl::UnbindInfo{::fidl::UnbindInfo::kDecodeError, status};
        }
        event_handler_->OnEmptyResponse(
            reinterpret_cast<::fidl::WireResponse<
                ::fidl_test_protocols::WithAndWithoutRequestResponse::
                    OnEmptyResponse>*>(msg->bytes));
        return std::nullopt;
      }
      case ::fidl_test_protocols::
          kWithAndWithoutRequestResponse_OnWithResponse_Ordinal: {
        const char* error_message;
        zx_status_t status = fidl_decode_etc(
            ::fidl::WireResponse<
                ::fidl_test_protocols::WithAndWithoutRequestResponse::
                    OnWithResponse>::Type,
            msg->bytes, msg->num_bytes, msg->handles, msg->num_handles,
            &error_message);
        if (status != ZX_OK) {
          return ::fidl::UnbindInfo{::fidl::UnbindInfo::kDecodeError, status};
        }
        event_handler_->OnWithResponse(
            reinterpret_cast<::fidl::WireResponse<
                ::fidl_test_protocols::WithAndWithoutRequestResponse::
                    OnWithResponse>*>(msg->bytes));
        return std::nullopt;
      }
      default:
        break;
    }
  }
  FidlHandleInfoCloseMany(msg->handles, msg->num_handles);
  return ::fidl::UnbindInfo{::fidl::UnbindInfo::kUnexpectedMessage,
                            ZX_ERR_NOT_SUPPORTED};
}
#endif  // __Fuchsia__

::fidl::Result fidl::WireSyncEventHandler<
    ::fidl_test_protocols::WithAndWithoutRequestResponse>::
    HandleOneEvent(::fidl::UnownedClientEnd<
                   ::fidl_test_protocols::WithAndWithoutRequestResponse>
                       client_end) {
  zx_status_t status = client_end.channel()->wait_one(
      ZX_CHANNEL_READABLE | ZX_CHANNEL_PEER_CLOSED, ::zx::time::infinite(),
      nullptr);
  if (status != ZX_OK) {
    return ::fidl::Result(status, ::fidl::kErrorWaitOneFailed);
  }
  constexpr uint32_t kHandleAllocSize = ([]() constexpr {
    uint32_t x = 0;
    if (::fidl::WireResponse<
            ::fidl_test_protocols::WithAndWithoutRequestResponse::
                OnEmptyResponse>::MaxNumHandles >= x) {
      x = ::fidl::WireResponse<
          ::fidl_test_protocols::WithAndWithoutRequestResponse::
              OnEmptyResponse>::MaxNumHandles;
    }
    if (::fidl::WireResponse<
            ::fidl_test_protocols::WithAndWithoutRequestResponse::
                OnWithResponse>::MaxNumHandles >= x) {
      x = ::fidl::WireResponse<
          ::fidl_test_protocols::WithAndWithoutRequestResponse::
              OnWithResponse>::MaxNumHandles;
    }
    if (x > ZX_CHANNEL_MAX_MSG_HANDLES) {
      x = ZX_CHANNEL_MAX_MSG_HANDLES;
    }
    return x;
  })();
  ::fidl::internal::BoxedMessageBuffer<ZX_CHANNEL_MAX_MSG_BYTES> read_storage;
  uint8_t* read_bytes = read_storage.data();
  zx_handle_info_t read_handles[kHandleAllocSize];
  uint32_t actual_bytes;
  uint32_t actual_handles;
  status = client_end.channel()->read_etc(
      ZX_CHANNEL_READ_MAY_DISCARD, read_bytes, read_handles,
      read_storage.size(), kHandleAllocSize, &actual_bytes, &actual_handles);
  if (status == ZX_ERR_BUFFER_TOO_SMALL) {
    // Message size is unexpectedly larger than calculated.
    // This can only be due to a newer version of the protocol defining a new
    // event, whose size exceeds the maximum of known events in the current
    // protocol.
    return ::fidl::Result(Unknown(), nullptr);
  }
  if (status != ZX_OK) {
    return ::fidl::Result(status, ::fidl::kErrorReadFailed);
  }
  if (actual_bytes < sizeof(fidl_message_header_t)) {
    FidlHandleInfoCloseMany(read_handles, actual_handles);
    return ::fidl::Result(ZX_ERR_INVALID_ARGS, ::fidl::kErrorInvalidHeader);
  }
  fidl_message_header_t* hdr =
      reinterpret_cast<fidl_message_header_t*>(read_bytes);
  status = fidl_validate_txn_header(hdr);
  if (status != ZX_OK) {
    FidlHandleInfoCloseMany(read_handles, actual_handles);
    return ::fidl::Result(status, ::fidl::kErrorInvalidHeader);
  }
  switch (hdr->ordinal) {
    case ::fidl_test_protocols::
        kWithAndWithoutRequestResponse_OnEmptyResponse_Ordinal: {
      const char* error_message;
      zx_status_t status = fidl_decode_etc(
          ::fidl::WireResponse<
              ::fidl_test_protocols::WithAndWithoutRequestResponse::
                  OnEmptyResponse>::Type,
          read_bytes, actual_bytes, read_handles, actual_handles,
          &error_message);
      if (status != ZX_OK) {
        return ::fidl::Result(status, error_message);
      }
      OnEmptyResponse(reinterpret_cast<::fidl::WireResponse<
                          ::fidl_test_protocols::WithAndWithoutRequestResponse::
                              OnEmptyResponse>*>(read_bytes));
      return ::fidl::Result(ZX_OK, nullptr);
    }
    case ::fidl_test_protocols::
        kWithAndWithoutRequestResponse_OnWithResponse_Ordinal: {
      const char* error_message;
      zx_status_t status = fidl_decode_etc(
          ::fidl::WireResponse<
              ::fidl_test_protocols::WithAndWithoutRequestResponse::
                  OnWithResponse>::Type,
          read_bytes, actual_bytes, read_handles, actual_handles,
          &error_message);
      if (status != ZX_OK) {
        return ::fidl::Result(status, error_message);
      }
      OnWithResponse(reinterpret_cast<::fidl::WireResponse<
                         ::fidl_test_protocols::WithAndWithoutRequestResponse::
                             OnWithResponse>*>(read_bytes));
      return ::fidl::Result(ZX_OK, nullptr);
    }
    default: {
      FidlHandleInfoCloseMany(read_handles, actual_handles);
      return ::fidl::Result(Unknown(), nullptr);
    }
  }
}

#ifdef __Fuchsia__

::fidl::DispatchResult fidl::internal::WireServerDispatcher<
    ::fidl_test_protocols::WithAndWithoutRequestResponse>::
    TryDispatch(::fidl::WireServer<
                    ::fidl_test_protocols::WithAndWithoutRequestResponse>* impl,
                fidl_incoming_msg_t* msg, ::fidl::Transaction* txn) {
  static const ::fidl::internal::MethodEntry entries[] = {
      {
          ::fidl_test_protocols::
              kWithAndWithoutRequestResponse_NoRequestNoResponse_Ordinal,
          ::fidl::WireRequest<
              ::fidl_test_protocols::WithAndWithoutRequestResponse::
                  NoRequestNoResponse>::Type,
          [](void* interface, void* bytes, ::fidl::Transaction* txn) {
            ::fidl::WireServer<
                ::fidl_test_protocols::WithAndWithoutRequestResponse>::
                NoRequestNoResponseCompleter::Sync completer(txn);
            reinterpret_cast<::fidl::WireServer<
                ::fidl_test_protocols::WithAndWithoutRequestResponse>*>(
                interface)
                ->NoRequestNoResponse(
                    reinterpret_cast<::fidl::WireRequest<
                        ::fidl_test_protocols::WithAndWithoutRequestResponse::
                            NoRequestNoResponse>*>(bytes),
                    completer);
          },
      },
      {
          ::fidl_test_protocols::
              kWithAndWithoutRequestResponse_NoRequestEmptyResponse_Ordinal,
          ::fidl::WireRequest<
              ::fidl_test_protocols::WithAndWithoutRequestResponse::
                  NoRequestEmptyResponse>::Type,
          [](void* interface, void* bytes, ::fidl::Transaction* txn) {
            ::fidl::WireServer<
                ::fidl_test_protocols::WithAndWithoutRequestResponse>::
                NoRequestEmptyResponseCompleter::Sync completer(txn);
            reinterpret_cast<::fidl::WireServer<
                ::fidl_test_protocols::WithAndWithoutRequestResponse>*>(
                interface)
                ->NoRequestEmptyResponse(
                    reinterpret_cast<::fidl::WireRequest<
                        ::fidl_test_protocols::WithAndWithoutRequestResponse::
                            NoRequestEmptyResponse>*>(bytes),
                    completer);
          },
      },
      {
          ::fidl_test_protocols::
              kWithAndWithoutRequestResponse_NoRequestWithResponse_Ordinal,
          ::fidl::WireRequest<
              ::fidl_test_protocols::WithAndWithoutRequestResponse::
                  NoRequestWithResponse>::Type,
          [](void* interface, void* bytes, ::fidl::Transaction* txn) {
            ::fidl::WireServer<
                ::fidl_test_protocols::WithAndWithoutRequestResponse>::
                NoRequestWithResponseCompleter::Sync completer(txn);
            reinterpret_cast<::fidl::WireServer<
                ::fidl_test_protocols::WithAndWithoutRequestResponse>*>(
                interface)
                ->NoRequestWithResponse(
                    reinterpret_cast<::fidl::WireRequest<
                        ::fidl_test_protocols::WithAndWithoutRequestResponse::
                            NoRequestWithResponse>*>(bytes),
                    completer);
          },
      },
      {
          ::fidl_test_protocols::
              kWithAndWithoutRequestResponse_WithRequestNoResponse_Ordinal,
          ::fidl::WireRequest<
              ::fidl_test_protocols::WithAndWithoutRequestResponse::
                  WithRequestNoResponse>::Type,
          [](void* interface, void* bytes, ::fidl::Transaction* txn) {
            ::fidl::WireServer<
                ::fidl_test_protocols::WithAndWithoutRequestResponse>::
                WithRequestNoResponseCompleter::Sync completer(txn);
            reinterpret_cast<::fidl::WireServer<
                ::fidl_test_protocols::WithAndWithoutRequestResponse>*>(
                interface)
                ->WithRequestNoResponse(
                    reinterpret_cast<::fidl::WireRequest<
                        ::fidl_test_protocols::WithAndWithoutRequestResponse::
                            WithRequestNoResponse>*>(bytes),
                    completer);
          },
      },
      {
          ::fidl_test_protocols::
              kWithAndWithoutRequestResponse_WithRequestEmptyResponse_Ordinal,
          ::fidl::WireRequest<
              ::fidl_test_protocols::WithAndWithoutRequestResponse::
                  WithRequestEmptyResponse>::Type,
          [](void* interface, void* bytes, ::fidl::Transaction* txn) {
            ::fidl::WireServer<
                ::fidl_test_protocols::WithAndWithoutRequestResponse>::
                WithRequestEmptyResponseCompleter::Sync completer(txn);
            reinterpret_cast<::fidl::WireServer<
                ::fidl_test_protocols::WithAndWithoutRequestResponse>*>(
                interface)
                ->WithRequestEmptyResponse(
                    reinterpret_cast<::fidl::WireRequest<
                        ::fidl_test_protocols::WithAndWithoutRequestResponse::
                            WithRequestEmptyResponse>*>(bytes),
                    completer);
          },
      },
      {
          ::fidl_test_protocols::
              kWithAndWithoutRequestResponse_WithRequestWithResponse_Ordinal,
          ::fidl::WireRequest<
              ::fidl_test_protocols::WithAndWithoutRequestResponse::
                  WithRequestWithResponse>::Type,
          [](void* interface, void* bytes, ::fidl::Transaction* txn) {
            ::fidl::WireServer<
                ::fidl_test_protocols::WithAndWithoutRequestResponse>::
                WithRequestWithResponseCompleter::Sync completer(txn);
            reinterpret_cast<::fidl::WireServer<
                ::fidl_test_protocols::WithAndWithoutRequestResponse>*>(
                interface)
                ->WithRequestWithResponse(
                    reinterpret_cast<::fidl::WireRequest<
                        ::fidl_test_protocols::WithAndWithoutRequestResponse::
                            WithRequestWithResponse>*>(bytes),
                    completer);
          },
      },
  };
  return ::fidl::internal::TryDispatch(
      impl, msg, txn, entries,
      entries + sizeof(entries) / sizeof(::fidl::internal::MethodEntry));
}

::fidl::DispatchResult fidl::internal::WireServerDispatcher<
    ::fidl_test_protocols::WithAndWithoutRequestResponse>::
    Dispatch(::fidl::WireServer<
                 ::fidl_test_protocols::WithAndWithoutRequestResponse>* impl,
             fidl_incoming_msg_t* msg, ::fidl::Transaction* txn) {
  ::fidl::DispatchResult dispatch_result = TryDispatch(impl, msg, txn);
  if (dispatch_result == ::fidl::DispatchResult::kNotFound) {
    FidlHandleInfoCloseMany(msg->handles, msg->num_handles);
    txn->InternalError(
        {::fidl::UnbindInfo::kUnexpectedMessage, ZX_ERR_NOT_SUPPORTED});
  }
  return dispatch_result;
}
::fidl::DispatchResult
fidl::WireServer<::fidl_test_protocols::WithAndWithoutRequestResponse>::
    dispatch_message(fidl_incoming_msg_t* msg, ::fidl::Transaction* txn) {
  return ::fidl::internal::WireServerDispatcher<
      ::fidl_test_protocols::WithAndWithoutRequestResponse>::Dispatch(this, msg,
                                                                      txn);
}

::fidl::DispatchResult fidl::internal::WireDispatcher<
    ::fidl_test_protocols::WithAndWithoutRequestResponse>::
    TryDispatch(::fidl::WireInterface<
                    ::fidl_test_protocols::WithAndWithoutRequestResponse>* impl,
                fidl_incoming_msg_t* msg, ::fidl::Transaction* txn) {
  static const ::fidl::internal::MethodEntry entries[] = {
      {
          ::fidl_test_protocols::
              kWithAndWithoutRequestResponse_NoRequestNoResponse_Ordinal,
          ::fidl::WireRequest<
              ::fidl_test_protocols::WithAndWithoutRequestResponse::
                  NoRequestNoResponse>::Type,
          [](void* interface, void* bytes, ::fidl::Transaction* txn) {
            ::fidl::WireServer<
                ::fidl_test_protocols::WithAndWithoutRequestResponse>::
                NoRequestNoResponseCompleter::Sync completer(txn);
            reinterpret_cast<::fidl::WireInterface<
                ::fidl_test_protocols::WithAndWithoutRequestResponse>*>(
                interface)
                ->NoRequestNoResponse(completer);
          },
      },
      {
          ::fidl_test_protocols::
              kWithAndWithoutRequestResponse_NoRequestEmptyResponse_Ordinal,
          ::fidl::WireRequest<
              ::fidl_test_protocols::WithAndWithoutRequestResponse::
                  NoRequestEmptyResponse>::Type,
          [](void* interface, void* bytes, ::fidl::Transaction* txn) {
            ::fidl::WireServer<
                ::fidl_test_protocols::WithAndWithoutRequestResponse>::
                NoRequestEmptyResponseCompleter::Sync completer(txn);
            reinterpret_cast<::fidl::WireInterface<
                ::fidl_test_protocols::WithAndWithoutRequestResponse>*>(
                interface)
                ->NoRequestEmptyResponse(completer);
          },
      },
      {
          ::fidl_test_protocols::
              kWithAndWithoutRequestResponse_NoRequestWithResponse_Ordinal,
          ::fidl::WireRequest<
              ::fidl_test_protocols::WithAndWithoutRequestResponse::
                  NoRequestWithResponse>::Type,
          [](void* interface, void* bytes, ::fidl::Transaction* txn) {
            ::fidl::WireServer<
                ::fidl_test_protocols::WithAndWithoutRequestResponse>::
                NoRequestWithResponseCompleter::Sync completer(txn);
            reinterpret_cast<::fidl::WireInterface<
                ::fidl_test_protocols::WithAndWithoutRequestResponse>*>(
                interface)
                ->NoRequestWithResponse(completer);
          },
      },
      {
          ::fidl_test_protocols::
              kWithAndWithoutRequestResponse_WithRequestNoResponse_Ordinal,
          ::fidl::WireRequest<
              ::fidl_test_protocols::WithAndWithoutRequestResponse::
                  WithRequestNoResponse>::Type,
          [](void* interface, void* bytes, ::fidl::Transaction* txn) {
            auto message = reinterpret_cast<::fidl::WireRequest<
                ::fidl_test_protocols::WithAndWithoutRequestResponse::
                    WithRequestNoResponse>*>(bytes);
            ::fidl::WireServer<
                ::fidl_test_protocols::WithAndWithoutRequestResponse>::
                WithRequestNoResponseCompleter::Sync completer(txn);
            reinterpret_cast<::fidl::WireInterface<
                ::fidl_test_protocols::WithAndWithoutRequestResponse>*>(
                interface)
                ->WithRequestNoResponse(std::move(message->arg), completer);
          },
      },
      {
          ::fidl_test_protocols::
              kWithAndWithoutRequestResponse_WithRequestEmptyResponse_Ordinal,
          ::fidl::WireRequest<
              ::fidl_test_protocols::WithAndWithoutRequestResponse::
                  WithRequestEmptyResponse>::Type,
          [](void* interface, void* bytes, ::fidl::Transaction* txn) {
            auto message = reinterpret_cast<::fidl::WireRequest<
                ::fidl_test_protocols::WithAndWithoutRequestResponse::
                    WithRequestEmptyResponse>*>(bytes);
            ::fidl::WireServer<
                ::fidl_test_protocols::WithAndWithoutRequestResponse>::
                WithRequestEmptyResponseCompleter::Sync completer(txn);
            reinterpret_cast<::fidl::WireInterface<
                ::fidl_test_protocols::WithAndWithoutRequestResponse>*>(
                interface)
                ->WithRequestEmptyResponse(std::move(message->arg), completer);
          },
      },
      {
          ::fidl_test_protocols::
              kWithAndWithoutRequestResponse_WithRequestWithResponse_Ordinal,
          ::fidl::WireRequest<
              ::fidl_test_protocols::WithAndWithoutRequestResponse::
                  WithRequestWithResponse>::Type,
          [](void* interface, void* bytes, ::fidl::Transaction* txn) {
            auto message = reinterpret_cast<::fidl::WireRequest<
                ::fidl_test_protocols::WithAndWithoutRequestResponse::
                    WithRequestWithResponse>*>(bytes);
            ::fidl::WireServer<
                ::fidl_test_protocols::WithAndWithoutRequestResponse>::
                WithRequestWithResponseCompleter::Sync completer(txn);
            reinterpret_cast<::fidl::WireInterface<
                ::fidl_test_protocols::WithAndWithoutRequestResponse>*>(
                interface)
                ->WithRequestWithResponse(std::move(message->arg), completer);
          },
      },
  };
  return ::fidl::internal::TryDispatch(
      impl, msg, txn, entries,
      entries + sizeof(entries) / sizeof(::fidl::internal::MethodEntry));
}

::fidl::DispatchResult fidl::internal::WireDispatcher<
    ::fidl_test_protocols::WithAndWithoutRequestResponse>::
    Dispatch(::fidl::WireInterface<
                 ::fidl_test_protocols::WithAndWithoutRequestResponse>* impl,
             fidl_incoming_msg_t* msg, ::fidl::Transaction* txn) {
  ::fidl::DispatchResult dispatch_result = TryDispatch(impl, msg, txn);
  if (dispatch_result == ::fidl::DispatchResult::kNotFound) {
    FidlHandleInfoCloseMany(msg->handles, msg->num_handles);
    txn->InternalError(
        {::fidl::UnbindInfo::kUnexpectedMessage, ZX_ERR_NOT_SUPPORTED});
  }
  return dispatch_result;
}
::fidl::DispatchResult
fidl::WireInterface<::fidl_test_protocols::WithAndWithoutRequestResponse>::
    dispatch_message(fidl_incoming_msg_t* msg, ::fidl::Transaction* txn) {
  return ::fidl::internal::WireDispatcher<
      ::fidl_test_protocols::WithAndWithoutRequestResponse>::Dispatch(this, msg,
                                                                      txn);
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
::fidl::Result
fidl::WireServer<::fidl_test_protocols::WithAndWithoutRequestResponse>::
    NoRequestEmptyResponseCompleterBase::Reply() {
  ::fidl::OwnedEncodedMessage<::fidl::WireResponse<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::
          NoRequestEmptyResponse>>
      _response{};
  return ::fidl::WireServer<
      ::fidl_test_protocols::WithAndWithoutRequestResponse>::
      NoRequestEmptyResponseCompleterBase::SendReply(
          &_response.GetOutgoingMessage());
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
::fidl::Result
fidl::WireServer<::fidl_test_protocols::WithAndWithoutRequestResponse>::
    NoRequestWithResponseCompleterBase::Reply(::fidl::StringView ret) {
  ::fidl::OwnedEncodedMessage<::fidl::WireResponse<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::
          NoRequestWithResponse>>
      _response{ret};
  return ::fidl::WireServer<
      ::fidl_test_protocols::WithAndWithoutRequestResponse>::
      NoRequestWithResponseCompleterBase::SendReply(
          &_response.GetOutgoingMessage());
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
::fidl::Result
fidl::WireServer<::fidl_test_protocols::WithAndWithoutRequestResponse>::
    NoRequestWithResponseCompleterBase::Reply(
        ::fidl::BufferSpan _backing_buffer, ::fidl::StringView ret) {
  ::fidl::WireResponse<::fidl_test_protocols::WithAndWithoutRequestResponse::
                           NoRequestWithResponse>::UnownedEncodedMessage
      _response(_backing_buffer.data, _backing_buffer.capacity, ret);
  return CompleterBase::SendReply(&_response.GetOutgoingMessage());
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
::fidl::Result
fidl::WireServer<::fidl_test_protocols::WithAndWithoutRequestResponse>::
    WithRequestEmptyResponseCompleterBase::Reply() {
  ::fidl::OwnedEncodedMessage<::fidl::WireResponse<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::
          WithRequestEmptyResponse>>
      _response{};
  return ::fidl::WireServer<
      ::fidl_test_protocols::WithAndWithoutRequestResponse>::
      WithRequestEmptyResponseCompleterBase::SendReply(
          &_response.GetOutgoingMessage());
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
::fidl::Result
fidl::WireServer<::fidl_test_protocols::WithAndWithoutRequestResponse>::
    WithRequestWithResponseCompleterBase::Reply(::fidl::StringView ret) {
  ::fidl::OwnedEncodedMessage<::fidl::WireResponse<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::
          WithRequestWithResponse>>
      _response{ret};
  return ::fidl::WireServer<
      ::fidl_test_protocols::WithAndWithoutRequestResponse>::
      WithRequestWithResponseCompleterBase::SendReply(
          &_response.GetOutgoingMessage());
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
::fidl::Result
fidl::WireServer<::fidl_test_protocols::WithAndWithoutRequestResponse>::
    WithRequestWithResponseCompleterBase::Reply(
        ::fidl::BufferSpan _backing_buffer, ::fidl::StringView ret) {
  ::fidl::WireResponse<::fidl_test_protocols::WithAndWithoutRequestResponse::
                           WithRequestWithResponse>::UnownedEncodedMessage
      _response(_backing_buffer.data, _backing_buffer.capacity, ret);
  return CompleterBase::SendReply(&_response.GetOutgoingMessage());
}
#endif  // __Fuchsia__

void ::fidl::WireRequest<
    ::fidl_test_protocols::WithAndWithoutRequestResponse::NoRequestNoResponse>::
    _InitHeader(zx_txid_t _txid) {
  fidl_init_txn_header(
      &_hdr, _txid,
      ::fidl_test_protocols::
          kWithAndWithoutRequestResponse_NoRequestNoResponse_Ordinal);
}

void ::fidl::WireRequest<::fidl_test_protocols::WithAndWithoutRequestResponse::
                             NoRequestEmptyResponse>::_InitHeader(zx_txid_t
                                                                      _txid) {
  fidl_init_txn_header(
      &_hdr, _txid,
      ::fidl_test_protocols::
          kWithAndWithoutRequestResponse_NoRequestEmptyResponse_Ordinal);
}

void ::fidl::WireResponse<::fidl_test_protocols::WithAndWithoutRequestResponse::
                              NoRequestEmptyResponse>::_InitHeader() {
  fidl_init_txn_header(
      &_hdr, 0,
      ::fidl_test_protocols::
          kWithAndWithoutRequestResponse_NoRequestEmptyResponse_Ordinal);
}

void ::fidl::WireRequest<::fidl_test_protocols::WithAndWithoutRequestResponse::
                             NoRequestWithResponse>::_InitHeader(zx_txid_t
                                                                     _txid) {
  fidl_init_txn_header(
      &_hdr, _txid,
      ::fidl_test_protocols::
          kWithAndWithoutRequestResponse_NoRequestWithResponse_Ordinal);
}

void ::fidl::WireResponse<::fidl_test_protocols::WithAndWithoutRequestResponse::
                              NoRequestWithResponse>::_InitHeader() {
  fidl_init_txn_header(
      &_hdr, 0,
      ::fidl_test_protocols::
          kWithAndWithoutRequestResponse_NoRequestWithResponse_Ordinal);
}

void ::fidl::WireRequest<::fidl_test_protocols::WithAndWithoutRequestResponse::
                             WithRequestNoResponse>::_InitHeader(zx_txid_t
                                                                     _txid) {
  fidl_init_txn_header(
      &_hdr, _txid,
      ::fidl_test_protocols::
          kWithAndWithoutRequestResponse_WithRequestNoResponse_Ordinal);
}

void ::fidl::WireRequest<::fidl_test_protocols::WithAndWithoutRequestResponse::
                             WithRequestEmptyResponse>::_InitHeader(zx_txid_t
                                                                        _txid) {
  fidl_init_txn_header(
      &_hdr, _txid,
      ::fidl_test_protocols::
          kWithAndWithoutRequestResponse_WithRequestEmptyResponse_Ordinal);
}

void ::fidl::WireResponse<::fidl_test_protocols::WithAndWithoutRequestResponse::
                              WithRequestEmptyResponse>::_InitHeader() {
  fidl_init_txn_header(
      &_hdr, 0,
      ::fidl_test_protocols::
          kWithAndWithoutRequestResponse_WithRequestEmptyResponse_Ordinal);
}

void ::fidl::WireRequest<::fidl_test_protocols::WithAndWithoutRequestResponse::
                             WithRequestWithResponse>::_InitHeader(zx_txid_t
                                                                       _txid) {
  fidl_init_txn_header(
      &_hdr, _txid,
      ::fidl_test_protocols::
          kWithAndWithoutRequestResponse_WithRequestWithResponse_Ordinal);
}

void ::fidl::WireResponse<::fidl_test_protocols::WithAndWithoutRequestResponse::
                              WithRequestWithResponse>::_InitHeader() {
  fidl_init_txn_header(
      &_hdr, 0,
      ::fidl_test_protocols::
          kWithAndWithoutRequestResponse_WithRequestWithResponse_Ordinal);
}

void ::fidl::WireResponse<::fidl_test_protocols::WithAndWithoutRequestResponse::
                              OnEmptyResponse>::_InitHeader() {
  fidl_init_txn_header(
      &_hdr, 0,
      ::fidl_test_protocols::
          kWithAndWithoutRequestResponse_OnEmptyResponse_Ordinal);
}

void ::fidl::WireResponse<::fidl_test_protocols::WithAndWithoutRequestResponse::
                              OnWithResponse>::_InitHeader() {
  fidl_init_txn_header(
      &_hdr, 0,
      ::fidl_test_protocols::
          kWithAndWithoutRequestResponse_OnWithResponse_Ordinal);
}

#ifdef __Fuchsia__

zx_status_t fidl::WireEventSender<
    ::fidl_test_protocols::WithAndWithoutRequestResponse>::OnEmptyResponse()
    const {
  ::fidl::OwnedEncodedMessage<::fidl::WireResponse<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::OnEmptyResponse>>
      _response{};
  _response.Write(server_end_);
  return _response.status();
}

zx_status_t
fidl::WireEventSender<::fidl_test_protocols::WithAndWithoutRequestResponse>::
    OnWithResponse(::fidl::StringView ret) const {
  ::fidl::OwnedEncodedMessage<::fidl::WireResponse<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::OnWithResponse>>
      _response{ret};
  _response.Write(server_end_);
  return _response.status();
}

zx_status_t
fidl::WireEventSender<::fidl_test_protocols::WithAndWithoutRequestResponse>::
    OnWithResponse(::fidl::BufferSpan _buffer, ::fidl::StringView ret) const {
  ::fidl::UnownedEncodedMessage<::fidl::WireResponse<
      ::fidl_test_protocols::WithAndWithoutRequestResponse::OnWithResponse>>
      _response(_buffer.data, _buffer.capacity, ret);
  _response.Write(server_end_);
  return _response.status();
}

#endif  // __Fuchsia__

void ::fidl_test_protocols::wire::WithErrorSyntaxErrorAsEnumResult::
    SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(WithErrorSyntaxErrorAsEnumResult) ==
                sizeof(fidl_xunion_t));
  static_assert(offsetof(WithErrorSyntaxErrorAsEnumResult, ordinal_) ==
                offsetof(fidl_xunion_t, tag));
  static_assert(offsetof(WithErrorSyntaxErrorAsEnumResult, envelope_) ==
                offsetof(fidl_xunion_t, envelope));
}

namespace fidl_test_protocols {
[[maybe_unused]] constexpr uint64_t kWithErrorSyntax_ResponseAsStruct_Ordinal =
    4000554951765344912lu;

extern "C" const fidl_type_t
    fidl_test_protocols_WithErrorSyntaxResponseAsStructRequestTable;

extern "C" const fidl_type_t
    fidl_test_protocols_WithErrorSyntaxResponseAsStructResponseTable;

[[maybe_unused]] constexpr uint64_t kWithErrorSyntax_ErrorAsPrimitive_Ordinal =
    3421672554503271630lu;

extern "C" const fidl_type_t
    fidl_test_protocols_WithErrorSyntaxErrorAsPrimitiveRequestTable;

extern "C" const fidl_type_t
    fidl_test_protocols_WithErrorSyntaxErrorAsPrimitiveResponseTable;

[[maybe_unused]] constexpr uint64_t kWithErrorSyntax_ErrorAsEnum_Ordinal =
    627496610701472780lu;

extern "C" const fidl_type_t
    fidl_test_protocols_WithErrorSyntaxErrorAsEnumRequestTable;

extern "C" const fidl_type_t
    fidl_test_protocols_WithErrorSyntaxErrorAsEnumResponseTable;
#ifdef __Fuchsia__
}  // namespace fidl_test_protocols
::fidl::WireResult<::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>::
    WireResult(::fidl::UnownedClientEnd<::fidl_test_protocols::WithErrorSyntax>
                   _client) {
  ::fidl::OwnedEncodedMessage<::fidl::WireRequest<
      ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>>
      _request(zx_txid_t(0));
  _request.GetOutgoingMessage()
      .Call<::fidl::WireResponse<
          ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>>(
          _client, bytes_.data(), bytes_.size());
  status_ = _request.status();
  error_ = _request.error();
}

::fidl::WireResult<::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>::
    WireResult(::fidl::UnownedClientEnd<::fidl_test_protocols::WithErrorSyntax>
                   _client,
               zx_time_t _deadline) {
  ::fidl::OwnedEncodedMessage<::fidl::WireRequest<
      ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>>
      _request(zx_txid_t(0));
  _request.GetOutgoingMessage()
      .Call<::fidl::WireResponse<
          ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>>(
          _client, bytes_.data(), bytes_.size(), _deadline);
  status_ = _request.status();
  error_ = _request.error();
}
namespace fidl_test_protocols {
#endif  // __Fuchsia__

#ifdef __Fuchsia__
}  // namespace fidl_test_protocols
::fidl::WireUnownedResult<
    ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>::
    WireUnownedResult(
        ::fidl::UnownedClientEnd<::fidl_test_protocols::WithErrorSyntax>
            _client,
        uint8_t* _response_bytes, uint32_t _response_byte_capacity)
    : bytes_(_response_bytes) {
  ::fidl::OwnedEncodedMessage<::fidl::WireRequest<
      ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>>
      _request(zx_txid_t(0));
  _request.GetOutgoingMessage()
      .Call<::fidl::WireResponse<
          ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>>(
          _client, _response_bytes, _response_byte_capacity);
  status_ = _request.status();
  error_ = _request.error();
}
namespace fidl_test_protocols {
#endif  // __Fuchsia__

#ifdef __Fuchsia__
}  // namespace fidl_test_protocols
::fidl::WireResult<::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>::
    WireResult(::fidl::UnownedClientEnd<::fidl_test_protocols::WithErrorSyntax>
                   _client) {
  ::fidl::OwnedEncodedMessage<::fidl::WireRequest<
      ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>>
      _request(zx_txid_t(0));
  _request.GetOutgoingMessage()
      .Call<::fidl::WireResponse<
          ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>>(
          _client, bytes_.data(), bytes_.size());
  status_ = _request.status();
  error_ = _request.error();
}

::fidl::WireResult<::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>::
    WireResult(::fidl::UnownedClientEnd<::fidl_test_protocols::WithErrorSyntax>
                   _client,
               zx_time_t _deadline) {
  ::fidl::OwnedEncodedMessage<::fidl::WireRequest<
      ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>>
      _request(zx_txid_t(0));
  _request.GetOutgoingMessage()
      .Call<::fidl::WireResponse<
          ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>>(
          _client, bytes_.data(), bytes_.size(), _deadline);
  status_ = _request.status();
  error_ = _request.error();
}
namespace fidl_test_protocols {
#endif  // __Fuchsia__

#ifdef __Fuchsia__
}  // namespace fidl_test_protocols
::fidl::WireUnownedResult<
    ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>::
    WireUnownedResult(
        ::fidl::UnownedClientEnd<::fidl_test_protocols::WithErrorSyntax>
            _client,
        uint8_t* _response_bytes, uint32_t _response_byte_capacity)
    : bytes_(_response_bytes) {
  ::fidl::OwnedEncodedMessage<::fidl::WireRequest<
      ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>>
      _request(zx_txid_t(0));
  _request.GetOutgoingMessage()
      .Call<::fidl::WireResponse<
          ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>>(
          _client, _response_bytes, _response_byte_capacity);
  status_ = _request.status();
  error_ = _request.error();
}
namespace fidl_test_protocols {
#endif  // __Fuchsia__

#ifdef __Fuchsia__
}  // namespace fidl_test_protocols
::fidl::WireResult<::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>::
    WireResult(::fidl::UnownedClientEnd<::fidl_test_protocols::WithErrorSyntax>
                   _client) {
  ::fidl::OwnedEncodedMessage<
      ::fidl::WireRequest<::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>>
      _request(zx_txid_t(0));
  _request.GetOutgoingMessage()
      .Call<::fidl::WireResponse<
          ::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>>(
          _client, bytes_.data(), bytes_.size());
  status_ = _request.status();
  error_ = _request.error();
}

::fidl::WireResult<::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>::
    WireResult(::fidl::UnownedClientEnd<::fidl_test_protocols::WithErrorSyntax>
                   _client,
               zx_time_t _deadline) {
  ::fidl::OwnedEncodedMessage<
      ::fidl::WireRequest<::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>>
      _request(zx_txid_t(0));
  _request.GetOutgoingMessage()
      .Call<::fidl::WireResponse<
          ::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>>(
          _client, bytes_.data(), bytes_.size(), _deadline);
  status_ = _request.status();
  error_ = _request.error();
}
namespace fidl_test_protocols {
#endif  // __Fuchsia__

#ifdef __Fuchsia__
}  // namespace fidl_test_protocols
::fidl::WireUnownedResult<::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>::
    WireUnownedResult(
        ::fidl::UnownedClientEnd<::fidl_test_protocols::WithErrorSyntax>
            _client,
        uint8_t* _response_bytes, uint32_t _response_byte_capacity)
    : bytes_(_response_bytes) {
  ::fidl::OwnedEncodedMessage<
      ::fidl::WireRequest<::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>>
      _request(zx_txid_t(0));
  _request.GetOutgoingMessage()
      .Call<::fidl::WireResponse<
          ::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>>(
          _client, _response_bytes, _response_byte_capacity);
  status_ = _request.status();
  error_ = _request.error();
}
namespace fidl_test_protocols {
#endif  // __Fuchsia__

}  // namespace fidl_test_protocols
#ifdef __Fuchsia__
::fidl::WireResult<::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>
fidl::internal::WireClientImpl<
    ::fidl_test_protocols::WithErrorSyntax>::ResponseAsStruct_Sync() {
  if (auto _channel = ::fidl::internal::ClientBase::GetChannel()) {
    return ::fidl::WireResult<
        ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>(
        ::fidl::UnownedClientEnd<::fidl_test_protocols::WithErrorSyntax>(
            _channel->handle()));
  }
  return ::fidl::WireResult<
      ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>(
      ::fidl::Result(ZX_ERR_CANCELED, ::fidl::kErrorChannelUnbound));
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
::fidl::WireUnownedResult<
    ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>
fidl::internal::WireClientImpl<::fidl_test_protocols::WithErrorSyntax>::
    ResponseAsStruct_Sync(::fidl::BufferSpan _response_buffer) {
  if (auto _channel = ::fidl::internal::ClientBase::GetChannel()) {
    return ::fidl::WireUnownedResult<
        ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>(
        ::fidl::UnownedClientEnd<::fidl_test_protocols::WithErrorSyntax>(
            _channel->handle()),
        _response_buffer.data, _response_buffer.capacity);
  }
  return ::fidl::WireUnownedResult<
      ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>(
      ::fidl::Result(ZX_ERR_CANCELED, ::fidl::kErrorChannelUnbound));
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__

::fidl::WireResponseContext<::fidl_test_protocols::WithErrorSyntax::
                                ResponseAsStruct>::WireResponseContext()
    : ::fidl::internal::ResponseContext(
          ::fidl::WireResponse<
              ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>::Type,
          ::fidl_test_protocols::kWithErrorSyntax_ResponseAsStruct_Ordinal) {}

void ::fidl::WireResponseContext<
    ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>::
    OnReply(uint8_t* reply) {
  OnReply(
      reinterpret_cast<::fidl::WireResponse<
          ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>*>(reply));
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
::fidl::Result fidl::internal::
    WireClientImpl<::fidl_test_protocols::WithErrorSyntax>::ResponseAsStruct(
        ::fit::callback<
            void(::fidl::WireResponse<::fidl_test_protocols::WithErrorSyntax::
                                          ResponseAsStruct>* response)>
            _cb) {
  class ResponseContext final
      : public ::fidl::WireResponseContext<
            ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct> {
   public:
    ResponseContext(
        ::fit::callback<
            void(::fidl::WireResponse<::fidl_test_protocols::WithErrorSyntax::
                                          ResponseAsStruct>* response)>
            cb)
        : cb_(std::move(cb)) {}

    void OnReply(::fidl::WireResponse<
                 ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>*
                     response) override {
      cb_(response);

      delete this;
    }

    void OnError() override { delete this; }

   private:
    ::fit::callback<void(
        ::fidl::WireResponse<::fidl_test_protocols::WithErrorSyntax::
                                 ResponseAsStruct>* response)>
        cb_;
  };

  auto* _context = new ResponseContext(std::move(_cb));
  ::fidl::internal::ClientBase::PrepareAsyncTxn(_context);
  ::fidl::WireRequest<
      ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>::
      OwnedEncodedMessage _request(_context->Txid());
  return _request.GetOutgoingMessage().Write(this, _context);
}

::fidl::Result fidl::internal::
    WireClientImpl<::fidl_test_protocols::WithErrorSyntax>::ResponseAsStruct(
        ::fidl::WireResponseContext<
            ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>*
            _context) {
  ::fidl::internal::ClientBase::PrepareAsyncTxn(_context);

  ::fidl::WireRequest<
      ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>::
      OwnedEncodedMessage _request(_context->Txid());
  return _request.GetOutgoingMessage().Write(this, _context);
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
::fidl::WireResult<::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>
fidl::internal::WireClientImpl<
    ::fidl_test_protocols::WithErrorSyntax>::ErrorAsPrimitive_Sync() {
  if (auto _channel = ::fidl::internal::ClientBase::GetChannel()) {
    return ::fidl::WireResult<
        ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>(
        ::fidl::UnownedClientEnd<::fidl_test_protocols::WithErrorSyntax>(
            _channel->handle()));
  }
  return ::fidl::WireResult<
      ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>(
      ::fidl::Result(ZX_ERR_CANCELED, ::fidl::kErrorChannelUnbound));
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
::fidl::WireUnownedResult<
    ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>
fidl::internal::WireClientImpl<::fidl_test_protocols::WithErrorSyntax>::
    ErrorAsPrimitive_Sync(::fidl::BufferSpan _response_buffer) {
  if (auto _channel = ::fidl::internal::ClientBase::GetChannel()) {
    return ::fidl::WireUnownedResult<
        ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>(
        ::fidl::UnownedClientEnd<::fidl_test_protocols::WithErrorSyntax>(
            _channel->handle()),
        _response_buffer.data, _response_buffer.capacity);
  }
  return ::fidl::WireUnownedResult<
      ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>(
      ::fidl::Result(ZX_ERR_CANCELED, ::fidl::kErrorChannelUnbound));
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__

::fidl::WireResponseContext<::fidl_test_protocols::WithErrorSyntax::
                                ErrorAsPrimitive>::WireResponseContext()
    : ::fidl::internal::ResponseContext(
          ::fidl::WireResponse<
              ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>::Type,
          ::fidl_test_protocols::kWithErrorSyntax_ErrorAsPrimitive_Ordinal) {}

void ::fidl::WireResponseContext<
    ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>::
    OnReply(uint8_t* reply) {
  OnReply(
      reinterpret_cast<::fidl::WireResponse<
          ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>*>(reply));
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
::fidl::Result fidl::internal::
    WireClientImpl<::fidl_test_protocols::WithErrorSyntax>::ErrorAsPrimitive(
        ::fit::callback<
            void(::fidl::WireResponse<::fidl_test_protocols::WithErrorSyntax::
                                          ErrorAsPrimitive>* response)>
            _cb) {
  class ResponseContext final
      : public ::fidl::WireResponseContext<
            ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive> {
   public:
    ResponseContext(
        ::fit::callback<
            void(::fidl::WireResponse<::fidl_test_protocols::WithErrorSyntax::
                                          ErrorAsPrimitive>* response)>
            cb)
        : cb_(std::move(cb)) {}

    void OnReply(::fidl::WireResponse<
                 ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>*
                     response) override {
      cb_(response);

      delete this;
    }

    void OnError() override { delete this; }

   private:
    ::fit::callback<void(
        ::fidl::WireResponse<::fidl_test_protocols::WithErrorSyntax::
                                 ErrorAsPrimitive>* response)>
        cb_;
  };

  auto* _context = new ResponseContext(std::move(_cb));
  ::fidl::internal::ClientBase::PrepareAsyncTxn(_context);
  ::fidl::WireRequest<
      ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>::
      OwnedEncodedMessage _request(_context->Txid());
  return _request.GetOutgoingMessage().Write(this, _context);
}

::fidl::Result fidl::internal::
    WireClientImpl<::fidl_test_protocols::WithErrorSyntax>::ErrorAsPrimitive(
        ::fidl::WireResponseContext<
            ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>*
            _context) {
  ::fidl::internal::ClientBase::PrepareAsyncTxn(_context);

  ::fidl::WireRequest<
      ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>::
      OwnedEncodedMessage _request(_context->Txid());
  return _request.GetOutgoingMessage().Write(this, _context);
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
::fidl::WireResult<::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>
fidl::internal::WireClientImpl<
    ::fidl_test_protocols::WithErrorSyntax>::ErrorAsEnum_Sync() {
  if (auto _channel = ::fidl::internal::ClientBase::GetChannel()) {
    return ::fidl::WireResult<
        ::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>(
        ::fidl::UnownedClientEnd<::fidl_test_protocols::WithErrorSyntax>(
            _channel->handle()));
  }
  return ::fidl::WireResult<
      ::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>(
      ::fidl::Result(ZX_ERR_CANCELED, ::fidl::kErrorChannelUnbound));
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
::fidl::WireUnownedResult<::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>
fidl::internal::WireClientImpl<::fidl_test_protocols::WithErrorSyntax>::
    ErrorAsEnum_Sync(::fidl::BufferSpan _response_buffer) {
  if (auto _channel = ::fidl::internal::ClientBase::GetChannel()) {
    return ::fidl::WireUnownedResult<
        ::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>(
        ::fidl::UnownedClientEnd<::fidl_test_protocols::WithErrorSyntax>(
            _channel->handle()),
        _response_buffer.data, _response_buffer.capacity);
  }
  return ::fidl::WireUnownedResult<
      ::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>(
      ::fidl::Result(ZX_ERR_CANCELED, ::fidl::kErrorChannelUnbound));
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__

::fidl::WireResponseContext<
    ::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>::WireResponseContext()
    : ::fidl::internal::ResponseContext(
          ::fidl::WireResponse<
              ::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>::Type,
          ::fidl_test_protocols::kWithErrorSyntax_ErrorAsEnum_Ordinal) {}

void ::fidl::WireResponseContext<
    ::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>::OnReply(uint8_t*
                                                                      reply) {
  OnReply(reinterpret_cast<::fidl::WireResponse<
              ::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>*>(reply));
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
::fidl::Result fidl::internal::
    WireClientImpl<::fidl_test_protocols::WithErrorSyntax>::ErrorAsEnum(
        ::fit::callback<void(
            ::fidl::WireResponse<
                ::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>* response)>
            _cb) {
  class ResponseContext final
      : public ::fidl::WireResponseContext<
            ::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum> {
   public:
    ResponseContext(
        ::fit::callback<void(
            ::fidl::WireResponse<
                ::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>* response)>
            cb)
        : cb_(std::move(cb)) {}

    void OnReply(::fidl::WireResponse<
                 ::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>* response)
        override {
      cb_(response);

      delete this;
    }

    void OnError() override { delete this; }

   private:
    ::fit::callback<void(
        ::fidl::WireResponse<
            ::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>* response)>
        cb_;
  };

  auto* _context = new ResponseContext(std::move(_cb));
  ::fidl::internal::ClientBase::PrepareAsyncTxn(_context);
  ::fidl::WireRequest<::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>::
      OwnedEncodedMessage _request(_context->Txid());
  return _request.GetOutgoingMessage().Write(this, _context);
}

::fidl::Result fidl::internal::
    WireClientImpl<::fidl_test_protocols::WithErrorSyntax>::ErrorAsEnum(
        ::fidl::WireResponseContext<
            ::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>* _context) {
  ::fidl::internal::ClientBase::PrepareAsyncTxn(_context);

  ::fidl::WireRequest<::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>::
      OwnedEncodedMessage _request(_context->Txid());
  return _request.GetOutgoingMessage().Write(this, _context);
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
std::optional<::fidl::UnbindInfo> fidl::internal::WireClientImpl<
    ::fidl_test_protocols::WithErrorSyntax>::DispatchEvent(fidl_incoming_msg_t*
                                                               msg) {
  FidlHandleInfoCloseMany(msg->handles, msg->num_handles);
  return ::fidl::UnbindInfo{::fidl::UnbindInfo::kUnexpectedMessage,
                            ZX_ERR_NOT_SUPPORTED};
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__

::fidl::DispatchResult fidl::internal::
    WireServerDispatcher<::fidl_test_protocols::WithErrorSyntax>::TryDispatch(
        ::fidl::WireServer<::fidl_test_protocols::WithErrorSyntax>* impl,
        fidl_incoming_msg_t* msg, ::fidl::Transaction* txn) {
  static const ::fidl::internal::MethodEntry entries[] = {
      {
          ::fidl_test_protocols::kWithErrorSyntax_ResponseAsStruct_Ordinal,
          ::fidl::WireRequest<
              ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>::Type,
          [](void* interface, void* bytes, ::fidl::Transaction* txn) {
            ::fidl::WireServer<::fidl_test_protocols::WithErrorSyntax>::
                ResponseAsStructCompleter::Sync completer(txn);
            reinterpret_cast<
                ::fidl::WireServer<::fidl_test_protocols::WithErrorSyntax>*>(
                interface)
                ->ResponseAsStruct(reinterpret_cast<::fidl::WireRequest<
                                       ::fidl_test_protocols::WithErrorSyntax::
                                           ResponseAsStruct>*>(bytes),
                                   completer);
          },
      },
      {
          ::fidl_test_protocols::kWithErrorSyntax_ErrorAsPrimitive_Ordinal,
          ::fidl::WireRequest<
              ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>::Type,
          [](void* interface, void* bytes, ::fidl::Transaction* txn) {
            ::fidl::WireServer<::fidl_test_protocols::WithErrorSyntax>::
                ErrorAsPrimitiveCompleter::Sync completer(txn);
            reinterpret_cast<
                ::fidl::WireServer<::fidl_test_protocols::WithErrorSyntax>*>(
                interface)
                ->ErrorAsPrimitive(reinterpret_cast<::fidl::WireRequest<
                                       ::fidl_test_protocols::WithErrorSyntax::
                                           ErrorAsPrimitive>*>(bytes),
                                   completer);
          },
      },
      {
          ::fidl_test_protocols::kWithErrorSyntax_ErrorAsEnum_Ordinal,
          ::fidl::WireRequest<
              ::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>::Type,
          [](void* interface, void* bytes, ::fidl::Transaction* txn) {
            ::fidl::WireServer<::fidl_test_protocols::WithErrorSyntax>::
                ErrorAsEnumCompleter::Sync completer(txn);
            reinterpret_cast<
                ::fidl::WireServer<::fidl_test_protocols::WithErrorSyntax>*>(
                interface)
                ->ErrorAsEnum(
                    reinterpret_cast<::fidl::WireRequest<
                        ::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>*>(
                        bytes),
                    completer);
          },
      },
  };
  return ::fidl::internal::TryDispatch(
      impl, msg, txn, entries,
      entries + sizeof(entries) / sizeof(::fidl::internal::MethodEntry));
}

::fidl::DispatchResult fidl::internal::
    WireServerDispatcher<::fidl_test_protocols::WithErrorSyntax>::Dispatch(
        ::fidl::WireServer<::fidl_test_protocols::WithErrorSyntax>* impl,
        fidl_incoming_msg_t* msg, ::fidl::Transaction* txn) {
  ::fidl::DispatchResult dispatch_result = TryDispatch(impl, msg, txn);
  if (dispatch_result == ::fidl::DispatchResult::kNotFound) {
    FidlHandleInfoCloseMany(msg->handles, msg->num_handles);
    txn->InternalError(
        {::fidl::UnbindInfo::kUnexpectedMessage, ZX_ERR_NOT_SUPPORTED});
  }
  return dispatch_result;
}
::fidl::DispatchResult
fidl::WireServer<::fidl_test_protocols::WithErrorSyntax>::dispatch_message(
    fidl_incoming_msg_t* msg, ::fidl::Transaction* txn) {
  return ::fidl::internal::WireServerDispatcher<
      ::fidl_test_protocols::WithErrorSyntax>::Dispatch(this, msg, txn);
}

::fidl::DispatchResult fidl::internal::
    WireDispatcher<::fidl_test_protocols::WithErrorSyntax>::TryDispatch(
        ::fidl::WireInterface<::fidl_test_protocols::WithErrorSyntax>* impl,
        fidl_incoming_msg_t* msg, ::fidl::Transaction* txn) {
  static const ::fidl::internal::MethodEntry entries[] = {
      {
          ::fidl_test_protocols::kWithErrorSyntax_ResponseAsStruct_Ordinal,
          ::fidl::WireRequest<
              ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>::Type,
          [](void* interface, void* bytes, ::fidl::Transaction* txn) {
            ::fidl::WireServer<::fidl_test_protocols::WithErrorSyntax>::
                ResponseAsStructCompleter::Sync completer(txn);
            reinterpret_cast<
                ::fidl::WireInterface<::fidl_test_protocols::WithErrorSyntax>*>(
                interface)
                ->ResponseAsStruct(completer);
          },
      },
      {
          ::fidl_test_protocols::kWithErrorSyntax_ErrorAsPrimitive_Ordinal,
          ::fidl::WireRequest<
              ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>::Type,
          [](void* interface, void* bytes, ::fidl::Transaction* txn) {
            ::fidl::WireServer<::fidl_test_protocols::WithErrorSyntax>::
                ErrorAsPrimitiveCompleter::Sync completer(txn);
            reinterpret_cast<
                ::fidl::WireInterface<::fidl_test_protocols::WithErrorSyntax>*>(
                interface)
                ->ErrorAsPrimitive(completer);
          },
      },
      {
          ::fidl_test_protocols::kWithErrorSyntax_ErrorAsEnum_Ordinal,
          ::fidl::WireRequest<
              ::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>::Type,
          [](void* interface, void* bytes, ::fidl::Transaction* txn) {
            ::fidl::WireServer<::fidl_test_protocols::WithErrorSyntax>::
                ErrorAsEnumCompleter::Sync completer(txn);
            reinterpret_cast<
                ::fidl::WireInterface<::fidl_test_protocols::WithErrorSyntax>*>(
                interface)
                ->ErrorAsEnum(completer);
          },
      },
  };
  return ::fidl::internal::TryDispatch(
      impl, msg, txn, entries,
      entries + sizeof(entries) / sizeof(::fidl::internal::MethodEntry));
}

::fidl::DispatchResult fidl::internal::
    WireDispatcher<::fidl_test_protocols::WithErrorSyntax>::Dispatch(
        ::fidl::WireInterface<::fidl_test_protocols::WithErrorSyntax>* impl,
        fidl_incoming_msg_t* msg, ::fidl::Transaction* txn) {
  ::fidl::DispatchResult dispatch_result = TryDispatch(impl, msg, txn);
  if (dispatch_result == ::fidl::DispatchResult::kNotFound) {
    FidlHandleInfoCloseMany(msg->handles, msg->num_handles);
    txn->InternalError(
        {::fidl::UnbindInfo::kUnexpectedMessage, ZX_ERR_NOT_SUPPORTED});
  }
  return dispatch_result;
}
::fidl::DispatchResult
fidl::WireInterface<::fidl_test_protocols::WithErrorSyntax>::dispatch_message(
    fidl_incoming_msg_t* msg, ::fidl::Transaction* txn) {
  return ::fidl::internal::WireDispatcher<
      ::fidl_test_protocols::WithErrorSyntax>::Dispatch(this, msg, txn);
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
::fidl::Result fidl::WireServer<::fidl_test_protocols::WithErrorSyntax>::
    ResponseAsStructCompleterBase::Reply(
        ::fidl_test_protocols::wire::WithErrorSyntaxResponseAsStructResult
            result) {
  ::fidl::OwnedEncodedMessage<::fidl::WireResponse<
      ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>>
      _response{result};
  return ::fidl::WireServer<::fidl_test_protocols::WithErrorSyntax>::
      ResponseAsStructCompleterBase::SendReply(&_response.GetOutgoingMessage());
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
::fidl::Result fidl::WireServer<::fidl_test_protocols::WithErrorSyntax>::
    ResponseAsStructCompleterBase::ReplySuccess(int64_t a, int64_t b,
                                                int64_t c) {
  ::fidl_test_protocols::wire::WithErrorSyntaxResponseAsStructResponse
      _response;
  _response.a = std::move(a);
  _response.b = std::move(b);
  _response.c = std::move(c);

  return Reply(
      ::fidl_test_protocols::wire::WithErrorSyntaxResponseAsStructResult::
          WithResponse(
              ::fidl::ObjectView<::fidl_test_protocols::wire::
                                     WithErrorSyntaxResponseAsStructResponse>::
                  FromExternal(&_response)));
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
::fidl::Result fidl::WireServer<::fidl_test_protocols::WithErrorSyntax>::
    ResponseAsStructCompleterBase::ReplyError(uint32_t error) {
  return Reply(
      ::fidl_test_protocols::wire::WithErrorSyntaxResponseAsStructResult::
          WithErr(::fidl::ObjectView<uint32_t>::FromExternal(&error)));
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
::fidl::Result fidl::WireServer<::fidl_test_protocols::WithErrorSyntax>::
    ResponseAsStructCompleterBase::Reply(
        ::fidl::BufferSpan _backing_buffer,
        ::fidl_test_protocols::wire::WithErrorSyntaxResponseAsStructResult
            result) {
  ::fidl::WireResponse<
      ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>::
      UnownedEncodedMessage _response(_backing_buffer.data,
                                      _backing_buffer.capacity, result);
  return CompleterBase::SendReply(&_response.GetOutgoingMessage());
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
::fidl::Result fidl::WireServer<::fidl_test_protocols::WithErrorSyntax>::
    ResponseAsStructCompleterBase::ReplySuccess(::fidl::BufferSpan _buffer,
                                                int64_t a, int64_t b,
                                                int64_t c) {
  ::fidl_test_protocols::wire::WithErrorSyntaxResponseAsStructResponse response;
  response.a = std::move(a);
  response.b = std::move(b);
  response.c = std::move(c);

  return Reply(
      std::move(_buffer),
      ::fidl_test_protocols::wire::WithErrorSyntaxResponseAsStructResult::
          WithResponse(
              ::fidl::ObjectView<::fidl_test_protocols::wire::
                                     WithErrorSyntaxResponseAsStructResponse>::
                  FromExternal(&response)));
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
::fidl::Result fidl::WireServer<::fidl_test_protocols::WithErrorSyntax>::
    ErrorAsPrimitiveCompleterBase::Reply(
        ::fidl_test_protocols::wire::WithErrorSyntaxErrorAsPrimitiveResult
            result) {
  ::fidl::OwnedEncodedMessage<::fidl::WireResponse<
      ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>>
      _response{result};
  return ::fidl::WireServer<::fidl_test_protocols::WithErrorSyntax>::
      ErrorAsPrimitiveCompleterBase::SendReply(&_response.GetOutgoingMessage());
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
::fidl::Result fidl::WireServer<::fidl_test_protocols::WithErrorSyntax>::
    ErrorAsPrimitiveCompleterBase::ReplySuccess() {
  ::fidl_test_protocols::wire::WithErrorSyntaxErrorAsPrimitiveResponse
      _response;

  return Reply(
      ::fidl_test_protocols::wire::WithErrorSyntaxErrorAsPrimitiveResult::
          WithResponse(
              ::fidl::ObjectView<::fidl_test_protocols::wire::
                                     WithErrorSyntaxErrorAsPrimitiveResponse>::
                  FromExternal(&_response)));
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
::fidl::Result fidl::WireServer<::fidl_test_protocols::WithErrorSyntax>::
    ErrorAsPrimitiveCompleterBase::ReplyError(uint32_t error) {
  return Reply(
      ::fidl_test_protocols::wire::WithErrorSyntaxErrorAsPrimitiveResult::
          WithErr(::fidl::ObjectView<uint32_t>::FromExternal(&error)));
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
::fidl::Result fidl::WireServer<::fidl_test_protocols::WithErrorSyntax>::
    ErrorAsPrimitiveCompleterBase::Reply(
        ::fidl::BufferSpan _backing_buffer,
        ::fidl_test_protocols::wire::WithErrorSyntaxErrorAsPrimitiveResult
            result) {
  ::fidl::WireResponse<
      ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>::
      UnownedEncodedMessage _response(_backing_buffer.data,
                                      _backing_buffer.capacity, result);
  return CompleterBase::SendReply(&_response.GetOutgoingMessage());
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
::fidl::Result fidl::WireServer<::fidl_test_protocols::WithErrorSyntax>::
    ErrorAsPrimitiveCompleterBase::ReplySuccess(::fidl::BufferSpan _buffer) {
  ::fidl_test_protocols::wire::WithErrorSyntaxErrorAsPrimitiveResponse response;

  return Reply(
      std::move(_buffer),
      ::fidl_test_protocols::wire::WithErrorSyntaxErrorAsPrimitiveResult::
          WithResponse(
              ::fidl::ObjectView<::fidl_test_protocols::wire::
                                     WithErrorSyntaxErrorAsPrimitiveResponse>::
                  FromExternal(&response)));
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
::fidl::Result fidl::WireServer<::fidl_test_protocols::WithErrorSyntax>::
    ErrorAsEnumCompleterBase::Reply(
        ::fidl_test_protocols::wire::WithErrorSyntaxErrorAsEnumResult result) {
  ::fidl::OwnedEncodedMessage<
      ::fidl::WireResponse<::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>>
      _response{result};
  return ::fidl::WireServer<::fidl_test_protocols::WithErrorSyntax>::
      ErrorAsEnumCompleterBase::SendReply(&_response.GetOutgoingMessage());
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
::fidl::Result fidl::WireServer<::fidl_test_protocols::WithErrorSyntax>::
    ErrorAsEnumCompleterBase::ReplySuccess() {
  ::fidl_test_protocols::wire::WithErrorSyntaxErrorAsEnumResponse _response;

  return Reply(
      ::fidl_test_protocols::wire::WithErrorSyntaxErrorAsEnumResult::
          WithResponse(
              ::fidl::ObjectView<::fidl_test_protocols::wire::
                                     WithErrorSyntaxErrorAsEnumResponse>::
                  FromExternal(&_response)));
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
::fidl::Result fidl::WireServer<::fidl_test_protocols::WithErrorSyntax>::
    ErrorAsEnumCompleterBase::ReplyError(
        ::fidl_test_protocols::wire::ErrorEnun error) {
  return Reply(
      ::fidl_test_protocols::wire::WithErrorSyntaxErrorAsEnumResult::WithErr(
          ::fidl::ObjectView<
              ::fidl_test_protocols::wire::ErrorEnun>::FromExternal(&error)));
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
::fidl::Result fidl::WireServer<::fidl_test_protocols::WithErrorSyntax>::
    ErrorAsEnumCompleterBase::Reply(
        ::fidl::BufferSpan _backing_buffer,
        ::fidl_test_protocols::wire::WithErrorSyntaxErrorAsEnumResult result) {
  ::fidl::WireResponse<::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>::
      UnownedEncodedMessage _response(_backing_buffer.data,
                                      _backing_buffer.capacity, result);
  return CompleterBase::SendReply(&_response.GetOutgoingMessage());
}
#endif  // __Fuchsia__

#ifdef __Fuchsia__
::fidl::Result fidl::WireServer<::fidl_test_protocols::WithErrorSyntax>::
    ErrorAsEnumCompleterBase::ReplySuccess(::fidl::BufferSpan _buffer) {
  ::fidl_test_protocols::wire::WithErrorSyntaxErrorAsEnumResponse response;

  return Reply(
      std::move(_buffer),
      ::fidl_test_protocols::wire::WithErrorSyntaxErrorAsEnumResult::
          WithResponse(
              ::fidl::ObjectView<::fidl_test_protocols::wire::
                                     WithErrorSyntaxErrorAsEnumResponse>::
                  FromExternal(&response)));
}
#endif  // __Fuchsia__

void ::fidl::WireRequest<::fidl_test_protocols::WithErrorSyntax::
                             ResponseAsStruct>::_InitHeader(zx_txid_t _txid) {
  fidl_init_txn_header(
      &_hdr, _txid,
      ::fidl_test_protocols::kWithErrorSyntax_ResponseAsStruct_Ordinal);
}

void ::fidl::WireResponse<
    ::fidl_test_protocols::WithErrorSyntax::ResponseAsStruct>::_InitHeader() {
  fidl_init_txn_header(
      &_hdr, 0,
      ::fidl_test_protocols::kWithErrorSyntax_ResponseAsStruct_Ordinal);
}

void ::fidl::WireRequest<::fidl_test_protocols::WithErrorSyntax::
                             ErrorAsPrimitive>::_InitHeader(zx_txid_t _txid) {
  fidl_init_txn_header(
      &_hdr, _txid,
      ::fidl_test_protocols::kWithErrorSyntax_ErrorAsPrimitive_Ordinal);
}

void ::fidl::WireResponse<
    ::fidl_test_protocols::WithErrorSyntax::ErrorAsPrimitive>::_InitHeader() {
  fidl_init_txn_header(
      &_hdr, 0,
      ::fidl_test_protocols::kWithErrorSyntax_ErrorAsPrimitive_Ordinal);
}

void ::fidl::WireRequest<::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>::
    _InitHeader(zx_txid_t _txid) {
  fidl_init_txn_header(
      &_hdr, _txid,
      ::fidl_test_protocols::kWithErrorSyntax_ErrorAsEnum_Ordinal);
}

void ::fidl::WireResponse<
    ::fidl_test_protocols::WithErrorSyntax::ErrorAsEnum>::_InitHeader() {
  fidl_init_txn_header(
      &_hdr, 0, ::fidl_test_protocols::kWithErrorSyntax_ErrorAsEnum_Ordinal);
}

#ifdef __Fuchsia__

#endif  // __Fuchsia__