zircon/system/fidl/fuchsia-device-manager/gen/llcpp/fidl.cc

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

#include <fuchsia/device/manager/llcpp/fidl.h>
#include <memory>

namespace llcpp {

namespace fuchsia {
namespace device {
namespace manager {

namespace {

[[maybe_unused]]
constexpr uint64_t kDebugDumper_DumpTree_Ordinal = 0x3804588c00000000lu;
[[maybe_unused]]
constexpr uint64_t kDebugDumper_DumpTree_GenOrdinal = 0x2985d961d4cd5c04lu;
extern "C" const fidl_type_t fuchsia_device_manager_DebugDumperDumpTreeRequestTable;
extern "C" const fidl_type_t fuchsia_device_manager_DebugDumperDumpTreeResponseTable;
[[maybe_unused]]
constexpr uint64_t kDebugDumper_DumpDrivers_Ordinal = 0x5237dc7300000000lu;
[[maybe_unused]]
constexpr uint64_t kDebugDumper_DumpDrivers_GenOrdinal = 0x1cbb832b151a378lu;
extern "C" const fidl_type_t fuchsia_device_manager_DebugDumperDumpDriversRequestTable;
extern "C" const fidl_type_t fuchsia_device_manager_DebugDumperDumpDriversResponseTable;
[[maybe_unused]]
constexpr uint64_t kDebugDumper_DumpBindingProperties_Ordinal = 0x1954f6f100000000lu;
[[maybe_unused]]
constexpr uint64_t kDebugDumper_DumpBindingProperties_GenOrdinal = 0x15b8794479ed66edlu;
extern "C" const fidl_type_t fuchsia_device_manager_DebugDumperDumpBindingPropertiesRequestTable;
extern "C" const fidl_type_t fuchsia_device_manager_DebugDumperDumpBindingPropertiesResponseTable;

}  // namespace
template <>
DebugDumper::ResultOf::DumpTree_Impl<DebugDumper::DumpTreeResponse>::DumpTree_Impl(zx::unowned_channel _client_end, ::zx::vmo output) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DumpTreeRequest, ::fidl::MessageDirection::kSending>();
  ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
  auto& _write_bytes_array = _write_bytes_inlined;
  uint8_t* _write_bytes = _write_bytes_array.view().data();
  memset(_write_bytes, 0, DumpTreeRequest::PrimarySize);
  auto& _request = *reinterpret_cast<DumpTreeRequest*>(_write_bytes);
  _request.output = std::move(output);
  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(DumpTreeRequest));
  ::fidl::DecodedMessage<DumpTreeRequest> _decoded_request(std::move(_request_bytes));
  Super::SetResult(
      DebugDumper::InPlace::DumpTree(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
}

DebugDumper::ResultOf::DumpTree DebugDumper::SyncClient::DumpTree(::zx::vmo output) {
  return ResultOf::DumpTree(zx::unowned_channel(this->channel_), std::move(output));
}

DebugDumper::ResultOf::DumpTree DebugDumper::Call::DumpTree(zx::unowned_channel _client_end, ::zx::vmo output) {
  return ResultOf::DumpTree(std::move(_client_end), std::move(output));
}

template <>
DebugDumper::UnownedResultOf::DumpTree_Impl<DebugDumper::DumpTreeResponse>::DumpTree_Impl(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::vmo output, ::fidl::BytePart _response_buffer) {
  if (_request_buffer.capacity() < DumpTreeRequest::PrimarySize) {
    Super::SetFailure(::fidl::DecodeResult<DumpTreeResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
    return;
  }
  memset(_request_buffer.data(), 0, DumpTreeRequest::PrimarySize);
  auto& _request = *reinterpret_cast<DumpTreeRequest*>(_request_buffer.data());
  _request.output = std::move(output);
  _request_buffer.set_actual(sizeof(DumpTreeRequest));
  ::fidl::DecodedMessage<DumpTreeRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      DebugDumper::InPlace::DumpTree(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
}

DebugDumper::UnownedResultOf::DumpTree DebugDumper::SyncClient::DumpTree(::fidl::BytePart _request_buffer, ::zx::vmo output, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::DumpTree(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(output), std::move(_response_buffer));
}

DebugDumper::UnownedResultOf::DumpTree DebugDumper::Call::DumpTree(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::vmo output, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::DumpTree(std::move(_client_end), std::move(_request_buffer), std::move(output), std::move(_response_buffer));
}

::fidl::DecodeResult<DebugDumper::DumpTreeResponse> DebugDumper::InPlace::DumpTree(zx::unowned_channel _client_end, ::fidl::DecodedMessage<DumpTreeRequest> params, ::fidl::BytePart response_buffer) {
  params.message()->_hdr = {};
  params.message()->_hdr.ordinal = kDebugDumper_DumpTree_Ordinal;
  auto _encode_request_result = ::fidl::Encode(std::move(params));
  if (_encode_request_result.status != ZX_OK) {
    return ::fidl::DecodeResult<DebugDumper::DumpTreeResponse>::FromFailure(
        std::move(_encode_request_result));
  }
  auto _call_result = ::fidl::Call<DumpTreeRequest, DumpTreeResponse>(
    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
  if (_call_result.status != ZX_OK) {
    return ::fidl::DecodeResult<DebugDumper::DumpTreeResponse>::FromFailure(
        std::move(_call_result));
  }
  return ::fidl::Decode(std::move(_call_result.message));
}

template <>
DebugDumper::ResultOf::DumpDrivers_Impl<DebugDumper::DumpDriversResponse>::DumpDrivers_Impl(zx::unowned_channel _client_end, ::zx::vmo output) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DumpDriversRequest, ::fidl::MessageDirection::kSending>();
  ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
  auto& _write_bytes_array = _write_bytes_inlined;
  uint8_t* _write_bytes = _write_bytes_array.view().data();
  memset(_write_bytes, 0, DumpDriversRequest::PrimarySize);
  auto& _request = *reinterpret_cast<DumpDriversRequest*>(_write_bytes);
  _request.output = std::move(output);
  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(DumpDriversRequest));
  ::fidl::DecodedMessage<DumpDriversRequest> _decoded_request(std::move(_request_bytes));
  Super::SetResult(
      DebugDumper::InPlace::DumpDrivers(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
}

DebugDumper::ResultOf::DumpDrivers DebugDumper::SyncClient::DumpDrivers(::zx::vmo output) {
  return ResultOf::DumpDrivers(zx::unowned_channel(this->channel_), std::move(output));
}

DebugDumper::ResultOf::DumpDrivers DebugDumper::Call::DumpDrivers(zx::unowned_channel _client_end, ::zx::vmo output) {
  return ResultOf::DumpDrivers(std::move(_client_end), std::move(output));
}

template <>
DebugDumper::UnownedResultOf::DumpDrivers_Impl<DebugDumper::DumpDriversResponse>::DumpDrivers_Impl(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::vmo output, ::fidl::BytePart _response_buffer) {
  if (_request_buffer.capacity() < DumpDriversRequest::PrimarySize) {
    Super::SetFailure(::fidl::DecodeResult<DumpDriversResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
    return;
  }
  memset(_request_buffer.data(), 0, DumpDriversRequest::PrimarySize);
  auto& _request = *reinterpret_cast<DumpDriversRequest*>(_request_buffer.data());
  _request.output = std::move(output);
  _request_buffer.set_actual(sizeof(DumpDriversRequest));
  ::fidl::DecodedMessage<DumpDriversRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      DebugDumper::InPlace::DumpDrivers(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
}

DebugDumper::UnownedResultOf::DumpDrivers DebugDumper::SyncClient::DumpDrivers(::fidl::BytePart _request_buffer, ::zx::vmo output, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::DumpDrivers(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(output), std::move(_response_buffer));
}

DebugDumper::UnownedResultOf::DumpDrivers DebugDumper::Call::DumpDrivers(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::vmo output, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::DumpDrivers(std::move(_client_end), std::move(_request_buffer), std::move(output), std::move(_response_buffer));
}

::fidl::DecodeResult<DebugDumper::DumpDriversResponse> DebugDumper::InPlace::DumpDrivers(zx::unowned_channel _client_end, ::fidl::DecodedMessage<DumpDriversRequest> params, ::fidl::BytePart response_buffer) {
  params.message()->_hdr = {};
  params.message()->_hdr.ordinal = kDebugDumper_DumpDrivers_Ordinal;
  auto _encode_request_result = ::fidl::Encode(std::move(params));
  if (_encode_request_result.status != ZX_OK) {
    return ::fidl::DecodeResult<DebugDumper::DumpDriversResponse>::FromFailure(
        std::move(_encode_request_result));
  }
  auto _call_result = ::fidl::Call<DumpDriversRequest, DumpDriversResponse>(
    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
  if (_call_result.status != ZX_OK) {
    return ::fidl::DecodeResult<DebugDumper::DumpDriversResponse>::FromFailure(
        std::move(_call_result));
  }
  return ::fidl::Decode(std::move(_call_result.message));
}

template <>
DebugDumper::ResultOf::DumpBindingProperties_Impl<DebugDumper::DumpBindingPropertiesResponse>::DumpBindingProperties_Impl(zx::unowned_channel _client_end, ::zx::vmo output) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DumpBindingPropertiesRequest, ::fidl::MessageDirection::kSending>();
  ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
  auto& _write_bytes_array = _write_bytes_inlined;
  uint8_t* _write_bytes = _write_bytes_array.view().data();
  memset(_write_bytes, 0, DumpBindingPropertiesRequest::PrimarySize);
  auto& _request = *reinterpret_cast<DumpBindingPropertiesRequest*>(_write_bytes);
  _request.output = std::move(output);
  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(DumpBindingPropertiesRequest));
  ::fidl::DecodedMessage<DumpBindingPropertiesRequest> _decoded_request(std::move(_request_bytes));
  Super::SetResult(
      DebugDumper::InPlace::DumpBindingProperties(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
}

DebugDumper::ResultOf::DumpBindingProperties DebugDumper::SyncClient::DumpBindingProperties(::zx::vmo output) {
  return ResultOf::DumpBindingProperties(zx::unowned_channel(this->channel_), std::move(output));
}

DebugDumper::ResultOf::DumpBindingProperties DebugDumper::Call::DumpBindingProperties(zx::unowned_channel _client_end, ::zx::vmo output) {
  return ResultOf::DumpBindingProperties(std::move(_client_end), std::move(output));
}

template <>
DebugDumper::UnownedResultOf::DumpBindingProperties_Impl<DebugDumper::DumpBindingPropertiesResponse>::DumpBindingProperties_Impl(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::vmo output, ::fidl::BytePart _response_buffer) {
  if (_request_buffer.capacity() < DumpBindingPropertiesRequest::PrimarySize) {
    Super::SetFailure(::fidl::DecodeResult<DumpBindingPropertiesResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
    return;
  }
  memset(_request_buffer.data(), 0, DumpBindingPropertiesRequest::PrimarySize);
  auto& _request = *reinterpret_cast<DumpBindingPropertiesRequest*>(_request_buffer.data());
  _request.output = std::move(output);
  _request_buffer.set_actual(sizeof(DumpBindingPropertiesRequest));
  ::fidl::DecodedMessage<DumpBindingPropertiesRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      DebugDumper::InPlace::DumpBindingProperties(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
}

DebugDumper::UnownedResultOf::DumpBindingProperties DebugDumper::SyncClient::DumpBindingProperties(::fidl::BytePart _request_buffer, ::zx::vmo output, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::DumpBindingProperties(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(output), std::move(_response_buffer));
}

DebugDumper::UnownedResultOf::DumpBindingProperties DebugDumper::Call::DumpBindingProperties(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::vmo output, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::DumpBindingProperties(std::move(_client_end), std::move(_request_buffer), std::move(output), std::move(_response_buffer));
}

::fidl::DecodeResult<DebugDumper::DumpBindingPropertiesResponse> DebugDumper::InPlace::DumpBindingProperties(zx::unowned_channel _client_end, ::fidl::DecodedMessage<DumpBindingPropertiesRequest> params, ::fidl::BytePart response_buffer) {
  params.message()->_hdr = {};
  params.message()->_hdr.ordinal = kDebugDumper_DumpBindingProperties_Ordinal;
  auto _encode_request_result = ::fidl::Encode(std::move(params));
  if (_encode_request_result.status != ZX_OK) {
    return ::fidl::DecodeResult<DebugDumper::DumpBindingPropertiesResponse>::FromFailure(
        std::move(_encode_request_result));
  }
  auto _call_result = ::fidl::Call<DumpBindingPropertiesRequest, DumpBindingPropertiesResponse>(
    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
  if (_call_result.status != ZX_OK) {
    return ::fidl::DecodeResult<DebugDumper::DumpBindingPropertiesResponse>::FromFailure(
        std::move(_call_result));
  }
  return ::fidl::Decode(std::move(_call_result.message));
}


bool DebugDumper::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
  if (msg->num_bytes < sizeof(fidl_message_header_t)) {
    zx_handle_close_many(msg->handles, msg->num_handles);
    txn->Close(ZX_ERR_INVALID_ARGS);
    return true;
  }
  fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
  switch (hdr->ordinal) {
    case kDebugDumper_DumpTree_Ordinal:
    case kDebugDumper_DumpTree_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<DumpTreeRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->DumpTree(std::move(message->output),
        Interface::DumpTreeCompleter::Sync(txn));
      return true;
    }
    case kDebugDumper_DumpDrivers_Ordinal:
    case kDebugDumper_DumpDrivers_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<DumpDriversRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->DumpDrivers(std::move(message->output),
        Interface::DumpDriversCompleter::Sync(txn));
      return true;
    }
    case kDebugDumper_DumpBindingProperties_Ordinal:
    case kDebugDumper_DumpBindingProperties_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<DumpBindingPropertiesRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->DumpBindingProperties(std::move(message->output),
        Interface::DumpBindingPropertiesCompleter::Sync(txn));
      return true;
    }
    default: {
      return false;
    }
  }
}

bool DebugDumper::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
  bool found = TryDispatch(impl, msg, txn);
  if (!found) {
    zx_handle_close_many(msg->handles, msg->num_handles);
    txn->Close(ZX_ERR_NOT_SUPPORTED);
  }
  return found;
}


void DebugDumper::Interface::DumpTreeCompleterBase::Reply(int32_t status, uint64_t written, uint64_t available) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DumpTreeResponse, ::fidl::MessageDirection::kSending>();
  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
  auto& _response = *reinterpret_cast<DumpTreeResponse*>(_write_bytes);
  _response._hdr.ordinal = kDebugDumper_DumpTree_Ordinal;
  _response.status = std::move(status);
  _response.written = std::move(written);
  _response.available = std::move(available);
  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(DumpTreeResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<DumpTreeResponse>(std::move(_response_bytes)));
}

void DebugDumper::Interface::DumpTreeCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, uint64_t written, uint64_t available) {
  if (_buffer.capacity() < DumpTreeResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  auto& _response = *reinterpret_cast<DumpTreeResponse*>(_buffer.data());
  _response._hdr.ordinal = kDebugDumper_DumpTree_Ordinal;
  _response.status = std::move(status);
  _response.written = std::move(written);
  _response.available = std::move(available);
  _buffer.set_actual(sizeof(DumpTreeResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<DumpTreeResponse>(std::move(_buffer)));
}

void DebugDumper::Interface::DumpTreeCompleterBase::Reply(::fidl::DecodedMessage<DumpTreeResponse> params) {
  params.message()->_hdr = {};
  params.message()->_hdr.ordinal = kDebugDumper_DumpTree_Ordinal;
  CompleterBase::SendReply(std::move(params));
}


void DebugDumper::Interface::DumpDriversCompleterBase::Reply(int32_t status, uint64_t written, uint64_t available) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DumpDriversResponse, ::fidl::MessageDirection::kSending>();
  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
  auto& _response = *reinterpret_cast<DumpDriversResponse*>(_write_bytes);
  _response._hdr.ordinal = kDebugDumper_DumpDrivers_Ordinal;
  _response.status = std::move(status);
  _response.written = std::move(written);
  _response.available = std::move(available);
  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(DumpDriversResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<DumpDriversResponse>(std::move(_response_bytes)));
}

void DebugDumper::Interface::DumpDriversCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, uint64_t written, uint64_t available) {
  if (_buffer.capacity() < DumpDriversResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  auto& _response = *reinterpret_cast<DumpDriversResponse*>(_buffer.data());
  _response._hdr.ordinal = kDebugDumper_DumpDrivers_Ordinal;
  _response.status = std::move(status);
  _response.written = std::move(written);
  _response.available = std::move(available);
  _buffer.set_actual(sizeof(DumpDriversResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<DumpDriversResponse>(std::move(_buffer)));
}

void DebugDumper::Interface::DumpDriversCompleterBase::Reply(::fidl::DecodedMessage<DumpDriversResponse> params) {
  params.message()->_hdr = {};
  params.message()->_hdr.ordinal = kDebugDumper_DumpDrivers_Ordinal;
  CompleterBase::SendReply(std::move(params));
}


void DebugDumper::Interface::DumpBindingPropertiesCompleterBase::Reply(int32_t status, uint64_t written, uint64_t available) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DumpBindingPropertiesResponse, ::fidl::MessageDirection::kSending>();
  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
  auto& _response = *reinterpret_cast<DumpBindingPropertiesResponse*>(_write_bytes);
  _response._hdr.ordinal = kDebugDumper_DumpBindingProperties_Ordinal;
  _response.status = std::move(status);
  _response.written = std::move(written);
  _response.available = std::move(available);
  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(DumpBindingPropertiesResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<DumpBindingPropertiesResponse>(std::move(_response_bytes)));
}

void DebugDumper::Interface::DumpBindingPropertiesCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, uint64_t written, uint64_t available) {
  if (_buffer.capacity() < DumpBindingPropertiesResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  auto& _response = *reinterpret_cast<DumpBindingPropertiesResponse*>(_buffer.data());
  _response._hdr.ordinal = kDebugDumper_DumpBindingProperties_Ordinal;
  _response.status = std::move(status);
  _response.written = std::move(written);
  _response.available = std::move(available);
  _buffer.set_actual(sizeof(DumpBindingPropertiesResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<DumpBindingPropertiesResponse>(std::move(_buffer)));
}

void DebugDumper::Interface::DumpBindingPropertiesCompleterBase::Reply(::fidl::DecodedMessage<DumpBindingPropertiesResponse> params) {
  params.message()->_hdr = {};
  params.message()->_hdr.ordinal = kDebugDumper_DumpBindingProperties_Ordinal;
  CompleterBase::SendReply(std::move(params));
}


namespace {

[[maybe_unused]]
constexpr uint64_t kAdministrator_Suspend_Ordinal = 0x7ecaa18c00000000lu;
[[maybe_unused]]
constexpr uint64_t kAdministrator_Suspend_GenOrdinal = 0x4bb44c32133da26elu;
extern "C" const fidl_type_t fuchsia_device_manager_AdministratorSuspendRequestTable;
extern "C" const fidl_type_t fuchsia_device_manager_AdministratorSuspendResponseTable;
[[maybe_unused]]
constexpr uint64_t kAdministrator_Resume_Ordinal = 0x3f61f33b00000000lu;
[[maybe_unused]]
constexpr uint64_t kAdministrator_Resume_GenOrdinal = 0x7e953b4960a4cbaelu;
extern "C" const fidl_type_t fuchsia_device_manager_AdministratorResumeRequestTable;
extern "C" const fidl_type_t fuchsia_device_manager_AdministratorResumeResponseTable;

}  // namespace
template <>
Administrator::ResultOf::Suspend_Impl<Administrator::SuspendResponse>::Suspend_Impl(zx::unowned_channel _client_end, uint32_t flags) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SuspendRequest, ::fidl::MessageDirection::kSending>();
  ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
  auto& _write_bytes_array = _write_bytes_inlined;
  uint8_t* _write_bytes = _write_bytes_array.view().data();
  memset(_write_bytes, 0, SuspendRequest::PrimarySize);
  auto& _request = *reinterpret_cast<SuspendRequest*>(_write_bytes);
  _request.flags = std::move(flags);
  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SuspendRequest));
  ::fidl::DecodedMessage<SuspendRequest> _decoded_request(std::move(_request_bytes));
  Super::SetResult(
      Administrator::InPlace::Suspend(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
}

Administrator::ResultOf::Suspend Administrator::SyncClient::Suspend(uint32_t flags) {
  return ResultOf::Suspend(zx::unowned_channel(this->channel_), std::move(flags));
}

Administrator::ResultOf::Suspend Administrator::Call::Suspend(zx::unowned_channel _client_end, uint32_t flags) {
  return ResultOf::Suspend(std::move(_client_end), std::move(flags));
}

template <>
Administrator::UnownedResultOf::Suspend_Impl<Administrator::SuspendResponse>::Suspend_Impl(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer) {
  if (_request_buffer.capacity() < SuspendRequest::PrimarySize) {
    Super::SetFailure(::fidl::DecodeResult<SuspendResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
    return;
  }
  memset(_request_buffer.data(), 0, SuspendRequest::PrimarySize);
  auto& _request = *reinterpret_cast<SuspendRequest*>(_request_buffer.data());
  _request.flags = std::move(flags);
  _request_buffer.set_actual(sizeof(SuspendRequest));
  ::fidl::DecodedMessage<SuspendRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      Administrator::InPlace::Suspend(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
}

Administrator::UnownedResultOf::Suspend Administrator::SyncClient::Suspend(::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::Suspend(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(flags), std::move(_response_buffer));
}

Administrator::UnownedResultOf::Suspend Administrator::Call::Suspend(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::Suspend(std::move(_client_end), std::move(_request_buffer), std::move(flags), std::move(_response_buffer));
}

::fidl::DecodeResult<Administrator::SuspendResponse> Administrator::InPlace::Suspend(zx::unowned_channel _client_end, ::fidl::DecodedMessage<SuspendRequest> params, ::fidl::BytePart response_buffer) {
  params.message()->_hdr = {};
  params.message()->_hdr.ordinal = kAdministrator_Suspend_Ordinal;
  auto _encode_request_result = ::fidl::Encode(std::move(params));
  if (_encode_request_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Administrator::SuspendResponse>::FromFailure(
        std::move(_encode_request_result));
  }
  auto _call_result = ::fidl::Call<SuspendRequest, SuspendResponse>(
    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
  if (_call_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Administrator::SuspendResponse>::FromFailure(
        std::move(_call_result));
  }
  return ::fidl::Decode(std::move(_call_result.message));
}

template <>
Administrator::ResultOf::Resume_Impl<Administrator::ResumeResponse>::Resume_Impl(zx::unowned_channel _client_end, SystemPowerState state) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ResumeRequest, ::fidl::MessageDirection::kSending>();
  ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
  auto& _write_bytes_array = _write_bytes_inlined;
  uint8_t* _write_bytes = _write_bytes_array.view().data();
  memset(_write_bytes, 0, ResumeRequest::PrimarySize);
  auto& _request = *reinterpret_cast<ResumeRequest*>(_write_bytes);
  _request.state = std::move(state);
  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ResumeRequest));
  ::fidl::DecodedMessage<ResumeRequest> _decoded_request(std::move(_request_bytes));
  Super::SetResult(
      Administrator::InPlace::Resume(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
}

Administrator::ResultOf::Resume Administrator::SyncClient::Resume(SystemPowerState state) {
  return ResultOf::Resume(zx::unowned_channel(this->channel_), std::move(state));
}

Administrator::ResultOf::Resume Administrator::Call::Resume(zx::unowned_channel _client_end, SystemPowerState state) {
  return ResultOf::Resume(std::move(_client_end), std::move(state));
}

template <>
Administrator::UnownedResultOf::Resume_Impl<Administrator::ResumeResponse>::Resume_Impl(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, SystemPowerState state, ::fidl::BytePart _response_buffer) {
  if (_request_buffer.capacity() < ResumeRequest::PrimarySize) {
    Super::SetFailure(::fidl::DecodeResult<ResumeResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
    return;
  }
  memset(_request_buffer.data(), 0, ResumeRequest::PrimarySize);
  auto& _request = *reinterpret_cast<ResumeRequest*>(_request_buffer.data());
  _request.state = std::move(state);
  _request_buffer.set_actual(sizeof(ResumeRequest));
  ::fidl::DecodedMessage<ResumeRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      Administrator::InPlace::Resume(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
}

Administrator::UnownedResultOf::Resume Administrator::SyncClient::Resume(::fidl::BytePart _request_buffer, SystemPowerState state, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::Resume(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(state), std::move(_response_buffer));
}

Administrator::UnownedResultOf::Resume Administrator::Call::Resume(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, SystemPowerState state, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::Resume(std::move(_client_end), std::move(_request_buffer), std::move(state), std::move(_response_buffer));
}

::fidl::DecodeResult<Administrator::ResumeResponse> Administrator::InPlace::Resume(zx::unowned_channel _client_end, ::fidl::DecodedMessage<ResumeRequest> params, ::fidl::BytePart response_buffer) {
  params.message()->_hdr = {};
  params.message()->_hdr.ordinal = kAdministrator_Resume_Ordinal;
  auto _encode_request_result = ::fidl::Encode(std::move(params));
  if (_encode_request_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Administrator::ResumeResponse>::FromFailure(
        std::move(_encode_request_result));
  }
  auto _call_result = ::fidl::Call<ResumeRequest, ResumeResponse>(
    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
  if (_call_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Administrator::ResumeResponse>::FromFailure(
        std::move(_call_result));
  }
  return ::fidl::Decode(std::move(_call_result.message));
}


bool Administrator::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
  if (msg->num_bytes < sizeof(fidl_message_header_t)) {
    zx_handle_close_many(msg->handles, msg->num_handles);
    txn->Close(ZX_ERR_INVALID_ARGS);
    return true;
  }
  fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
  switch (hdr->ordinal) {
    case kAdministrator_Suspend_Ordinal:
    case kAdministrator_Suspend_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<SuspendRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->Suspend(std::move(message->flags),
        Interface::SuspendCompleter::Sync(txn));
      return true;
    }
    case kAdministrator_Resume_Ordinal:
    case kAdministrator_Resume_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<ResumeRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->Resume(std::move(message->state),
        Interface::ResumeCompleter::Sync(txn));
      return true;
    }
    default: {
      return false;
    }
  }
}

bool Administrator::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
  bool found = TryDispatch(impl, msg, txn);
  if (!found) {
    zx_handle_close_many(msg->handles, msg->num_handles);
    txn->Close(ZX_ERR_NOT_SUPPORTED);
  }
  return found;
}


void Administrator::Interface::SuspendCompleterBase::Reply(int32_t status) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SuspendResponse, ::fidl::MessageDirection::kSending>();
  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
  auto& _response = *reinterpret_cast<SuspendResponse*>(_write_bytes);
  _response._hdr.ordinal = kAdministrator_Suspend_Ordinal;
  _response.status = std::move(status);
  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SuspendResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<SuspendResponse>(std::move(_response_bytes)));
}

void Administrator::Interface::SuspendCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
  if (_buffer.capacity() < SuspendResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  auto& _response = *reinterpret_cast<SuspendResponse*>(_buffer.data());
  _response._hdr.ordinal = kAdministrator_Suspend_Ordinal;
  _response.status = std::move(status);
  _buffer.set_actual(sizeof(SuspendResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<SuspendResponse>(std::move(_buffer)));
}

void Administrator::Interface::SuspendCompleterBase::Reply(::fidl::DecodedMessage<SuspendResponse> params) {
  params.message()->_hdr = {};
  params.message()->_hdr.ordinal = kAdministrator_Suspend_Ordinal;
  CompleterBase::SendReply(std::move(params));
}


void Administrator::Interface::ResumeCompleterBase::Reply(int32_t status) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ResumeResponse, ::fidl::MessageDirection::kSending>();
  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
  auto& _response = *reinterpret_cast<ResumeResponse*>(_write_bytes);
  _response._hdr.ordinal = kAdministrator_Resume_Ordinal;
  _response.status = std::move(status);
  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(ResumeResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<ResumeResponse>(std::move(_response_bytes)));
}

void Administrator::Interface::ResumeCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
  if (_buffer.capacity() < ResumeResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  auto& _response = *reinterpret_cast<ResumeResponse*>(_buffer.data());
  _response._hdr.ordinal = kAdministrator_Resume_Ordinal;
  _response.status = std::move(status);
  _buffer.set_actual(sizeof(ResumeResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<ResumeResponse>(std::move(_buffer)));
}

void Administrator::Interface::ResumeCompleterBase::Reply(::fidl::DecodedMessage<ResumeResponse> params) {
  params.message()->_hdr = {};
  params.message()->_hdr.ordinal = kAdministrator_Resume_Ordinal;
  CompleterBase::SendReply(std::move(params));
}


namespace {

[[maybe_unused]]
constexpr uint64_t kDevhostController_CreateDeviceStub_Ordinal = 0x2d8e104b00000000lu;
[[maybe_unused]]
constexpr uint64_t kDevhostController_CreateDeviceStub_GenOrdinal = 0x62409c9e94ff9699lu;
extern "C" const fidl_type_t fuchsia_device_manager_DevhostControllerCreateDeviceStubRequestTable;
[[maybe_unused]]
constexpr uint64_t kDevhostController_CreateDevice_Ordinal = 0x2f6f95b700000000lu;
[[maybe_unused]]
constexpr uint64_t kDevhostController_CreateDevice_GenOrdinal = 0x7dbabaee2c92e2c6lu;
extern "C" const fidl_type_t fuchsia_device_manager_DevhostControllerCreateDeviceRequestTable;
[[maybe_unused]]
constexpr uint64_t kDevhostController_CreateCompositeDevice_Ordinal = 0x358e5a0900000000lu;
[[maybe_unused]]
constexpr uint64_t kDevhostController_CreateCompositeDevice_GenOrdinal = 0x1d0ddbfd4f798c80lu;
extern "C" const fidl_type_t fuchsia_device_manager_DevhostControllerCreateCompositeDeviceRequestTable;
extern "C" const fidl_type_t fuchsia_device_manager_DevhostControllerCreateCompositeDeviceResponseTable;

}  // namespace

DevhostController::ResultOf::CreateDeviceStub_Impl::CreateDeviceStub_Impl(zx::unowned_channel _client_end, ::zx::channel rpc, uint32_t protocol_id, uint64_t local_device_id) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CreateDeviceStubRequest, ::fidl::MessageDirection::kSending>();
  ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
  auto& _write_bytes_array = _write_bytes_inlined;
  uint8_t* _write_bytes = _write_bytes_array.view().data();
  memset(_write_bytes, 0, CreateDeviceStubRequest::PrimarySize);
  auto& _request = *reinterpret_cast<CreateDeviceStubRequest*>(_write_bytes);
  _request.rpc = std::move(rpc);
  _request.protocol_id = std::move(protocol_id);
  _request.local_device_id = std::move(local_device_id);
  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(CreateDeviceStubRequest));
  ::fidl::DecodedMessage<CreateDeviceStubRequest> _decoded_request(std::move(_request_bytes));
  Super::operator=(
      DevhostController::InPlace::CreateDeviceStub(std::move(_client_end), std::move(_decoded_request)));
}

DevhostController::ResultOf::CreateDeviceStub DevhostController::SyncClient::CreateDeviceStub(::zx::channel rpc, uint32_t protocol_id, uint64_t local_device_id) {
  return ResultOf::CreateDeviceStub(zx::unowned_channel(this->channel_), std::move(rpc), std::move(protocol_id), std::move(local_device_id));
}

DevhostController::ResultOf::CreateDeviceStub DevhostController::Call::CreateDeviceStub(zx::unowned_channel _client_end, ::zx::channel rpc, uint32_t protocol_id, uint64_t local_device_id) {
  return ResultOf::CreateDeviceStub(std::move(_client_end), std::move(rpc), std::move(protocol_id), std::move(local_device_id));
}


DevhostController::UnownedResultOf::CreateDeviceStub_Impl::CreateDeviceStub_Impl(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel rpc, uint32_t protocol_id, uint64_t local_device_id) {
  if (_request_buffer.capacity() < CreateDeviceStubRequest::PrimarySize) {
    Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
    Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
    return;
  }
  memset(_request_buffer.data(), 0, CreateDeviceStubRequest::PrimarySize);
  auto& _request = *reinterpret_cast<CreateDeviceStubRequest*>(_request_buffer.data());
  _request.rpc = std::move(rpc);
  _request.protocol_id = std::move(protocol_id);
  _request.local_device_id = std::move(local_device_id);
  _request_buffer.set_actual(sizeof(CreateDeviceStubRequest));
  ::fidl::DecodedMessage<CreateDeviceStubRequest> _decoded_request(std::move(_request_buffer));
  Super::operator=(
      DevhostController::InPlace::CreateDeviceStub(std::move(_client_end), std::move(_decoded_request)));
}

DevhostController::UnownedResultOf::CreateDeviceStub DevhostController::SyncClient::CreateDeviceStub(::fidl::BytePart _request_buffer, ::zx::channel rpc, uint32_t protocol_id, uint64_t local_device_id) {
  return UnownedResultOf::CreateDeviceStub(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(rpc), std::move(protocol_id), std::move(local_device_id));
}

DevhostController::UnownedResultOf::CreateDeviceStub DevhostController::Call::CreateDeviceStub(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel rpc, uint32_t protocol_id, uint64_t local_device_id) {
  return UnownedResultOf::CreateDeviceStub(std::move(_client_end), std::move(_request_buffer), std::move(rpc), std::move(protocol_id), std::move(local_device_id));
}

::fidl::internal::StatusAndError DevhostController::InPlace::CreateDeviceStub(zx::unowned_channel _client_end, ::fidl::DecodedMessage<CreateDeviceStubRequest> params) {
  params.message()->_hdr = {};
  params.message()->_hdr.ordinal = kDevhostController_CreateDeviceStub_Ordinal;
  auto _encode_request_result = ::fidl::Encode(std::move(params));
  if (_encode_request_result.status != ZX_OK) {
    return ::fidl::internal::StatusAndError::FromFailure(
        std::move(_encode_request_result));
  }
  zx_status_t _write_status =
      ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
  if (_write_status != ZX_OK) {
    return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
  } else {
    return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
  }
}


DevhostController::ResultOf::CreateDevice_Impl::CreateDevice_Impl(zx::unowned_channel _client_end, ::zx::channel rpc, ::fidl::StringView driver_path, ::zx::vmo driver, ::zx::handle parent_proxy, ::fidl::StringView proxy_args, uint64_t local_device_id) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CreateDeviceRequest, ::fidl::MessageDirection::kSending>();
  std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
  auto& _write_bytes_array = *_write_bytes_boxed;
  CreateDeviceRequest _request = {};
  _request.rpc = std::move(rpc);
  _request.driver_path = std::move(driver_path);
  _request.driver = std::move(driver);
  _request.parent_proxy = std::move(parent_proxy);
  _request.proxy_args = std::move(proxy_args);
  _request.local_device_id = std::move(local_device_id);
  auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
  if (_linearize_result.status != ZX_OK) {
    Super::SetFailure(std::move(_linearize_result));
    return;
  }
  ::fidl::DecodedMessage<CreateDeviceRequest> _decoded_request = std::move(_linearize_result.message);
  Super::operator=(
      DevhostController::InPlace::CreateDevice(std::move(_client_end), std::move(_decoded_request)));
}

DevhostController::ResultOf::CreateDevice DevhostController::SyncClient::CreateDevice(::zx::channel rpc, ::fidl::StringView driver_path, ::zx::vmo driver, ::zx::handle parent_proxy, ::fidl::StringView proxy_args, uint64_t local_device_id) {
  return ResultOf::CreateDevice(zx::unowned_channel(this->channel_), std::move(rpc), std::move(driver_path), std::move(driver), std::move(parent_proxy), std::move(proxy_args), std::move(local_device_id));
}

DevhostController::ResultOf::CreateDevice DevhostController::Call::CreateDevice(zx::unowned_channel _client_end, ::zx::channel rpc, ::fidl::StringView driver_path, ::zx::vmo driver, ::zx::handle parent_proxy, ::fidl::StringView proxy_args, uint64_t local_device_id) {
  return ResultOf::CreateDevice(std::move(_client_end), std::move(rpc), std::move(driver_path), std::move(driver), std::move(parent_proxy), std::move(proxy_args), std::move(local_device_id));
}


DevhostController::UnownedResultOf::CreateDevice_Impl::CreateDevice_Impl(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel rpc, ::fidl::StringView driver_path, ::zx::vmo driver, ::zx::handle parent_proxy, ::fidl::StringView proxy_args, uint64_t local_device_id) {
  if (_request_buffer.capacity() < CreateDeviceRequest::PrimarySize) {
    Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
    Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
    return;
  }
  CreateDeviceRequest _request = {};
  _request.rpc = std::move(rpc);
  _request.driver_path = std::move(driver_path);
  _request.driver = std::move(driver);
  _request.parent_proxy = std::move(parent_proxy);
  _request.proxy_args = std::move(proxy_args);
  _request.local_device_id = std::move(local_device_id);
  auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
  if (_linearize_result.status != ZX_OK) {
    Super::SetFailure(std::move(_linearize_result));
    return;
  }
  ::fidl::DecodedMessage<CreateDeviceRequest> _decoded_request = std::move(_linearize_result.message);
  Super::operator=(
      DevhostController::InPlace::CreateDevice(std::move(_client_end), std::move(_decoded_request)));
}

DevhostController::UnownedResultOf::CreateDevice DevhostController::SyncClient::CreateDevice(::fidl::BytePart _request_buffer, ::zx::channel rpc, ::fidl::StringView driver_path, ::zx::vmo driver, ::zx::handle parent_proxy, ::fidl::StringView proxy_args, uint64_t local_device_id) {
  return UnownedResultOf::CreateDevice(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(rpc), std::move(driver_path), std::move(driver), std::move(parent_proxy), std::move(proxy_args), std::move(local_device_id));
}

DevhostController::UnownedResultOf::CreateDevice DevhostController::Call::CreateDevice(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel rpc, ::fidl::StringView driver_path, ::zx::vmo driver, ::zx::handle parent_proxy, ::fidl::StringView proxy_args, uint64_t local_device_id) {
  return UnownedResultOf::CreateDevice(std::move(_client_end), std::move(_request_buffer), std::move(rpc), std::move(driver_path), std::move(driver), std::move(parent_proxy), std::move(proxy_args), std::move(local_device_id));
}

::fidl::internal::StatusAndError DevhostController::InPlace::CreateDevice(zx::unowned_channel _client_end, ::fidl::DecodedMessage<CreateDeviceRequest> params) {
  params.message()->_hdr = {};
  params.message()->_hdr.ordinal = kDevhostController_CreateDevice_Ordinal;
  auto _encode_request_result = ::fidl::Encode(std::move(params));
  if (_encode_request_result.status != ZX_OK) {
    return ::fidl::internal::StatusAndError::FromFailure(
        std::move(_encode_request_result));
  }
  zx_status_t _write_status =
      ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
  if (_write_status != ZX_OK) {
    return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
  } else {
    return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
  }
}

template <>
DevhostController::ResultOf::CreateCompositeDevice_Impl<DevhostController::CreateCompositeDeviceResponse>::CreateCompositeDevice_Impl(zx::unowned_channel _client_end, ::zx::channel rpc, ::fidl::VectorView<uint64_t> components, ::fidl::StringView name, uint64_t local_device_id) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CreateCompositeDeviceRequest, ::fidl::MessageDirection::kSending>();
  ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
  auto& _write_bytes_array = _write_bytes_inlined;
  CreateCompositeDeviceRequest _request = {};
  _request.rpc = std::move(rpc);
  _request.components = std::move(components);
  _request.name = std::move(name);
  _request.local_device_id = std::move(local_device_id);
  auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
  if (_linearize_result.status != ZX_OK) {
    Super::SetFailure(std::move(_linearize_result));
    return;
  }
  ::fidl::DecodedMessage<CreateCompositeDeviceRequest> _decoded_request = std::move(_linearize_result.message);
  Super::SetResult(
      DevhostController::InPlace::CreateCompositeDevice(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
}

DevhostController::ResultOf::CreateCompositeDevice DevhostController::SyncClient::CreateCompositeDevice(::zx::channel rpc, ::fidl::VectorView<uint64_t> components, ::fidl::StringView name, uint64_t local_device_id) {
  return ResultOf::CreateCompositeDevice(zx::unowned_channel(this->channel_), std::move(rpc), std::move(components), std::move(name), std::move(local_device_id));
}

DevhostController::ResultOf::CreateCompositeDevice DevhostController::Call::CreateCompositeDevice(zx::unowned_channel _client_end, ::zx::channel rpc, ::fidl::VectorView<uint64_t> components, ::fidl::StringView name, uint64_t local_device_id) {
  return ResultOf::CreateCompositeDevice(std::move(_client_end), std::move(rpc), std::move(components), std::move(name), std::move(local_device_id));
}

template <>
DevhostController::UnownedResultOf::CreateCompositeDevice_Impl<DevhostController::CreateCompositeDeviceResponse>::CreateCompositeDevice_Impl(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel rpc, ::fidl::VectorView<uint64_t> components, ::fidl::StringView name, uint64_t local_device_id, ::fidl::BytePart _response_buffer) {
  if (_request_buffer.capacity() < CreateCompositeDeviceRequest::PrimarySize) {
    Super::SetFailure(::fidl::DecodeResult<CreateCompositeDeviceResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
    return;
  }
  CreateCompositeDeviceRequest _request = {};
  _request.rpc = std::move(rpc);
  _request.components = std::move(components);
  _request.name = std::move(name);
  _request.local_device_id = std::move(local_device_id);
  auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
  if (_linearize_result.status != ZX_OK) {
    Super::SetFailure(std::move(_linearize_result));
    return;
  }
  ::fidl::DecodedMessage<CreateCompositeDeviceRequest> _decoded_request = std::move(_linearize_result.message);
  Super::SetResult(
      DevhostController::InPlace::CreateCompositeDevice(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
}

DevhostController::UnownedResultOf::CreateCompositeDevice DevhostController::SyncClient::CreateCompositeDevice(::fidl::BytePart _request_buffer, ::zx::channel rpc, ::fidl::VectorView<uint64_t> components, ::fidl::StringView name, uint64_t local_device_id, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::CreateCompositeDevice(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(rpc), std::move(components), std::move(name), std::move(local_device_id), std::move(_response_buffer));
}

DevhostController::UnownedResultOf::CreateCompositeDevice DevhostController::Call::CreateCompositeDevice(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel rpc, ::fidl::VectorView<uint64_t> components, ::fidl::StringView name, uint64_t local_device_id, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::CreateCompositeDevice(std::move(_client_end), std::move(_request_buffer), std::move(rpc), std::move(components), std::move(name), std::move(local_device_id), std::move(_response_buffer));
}

::fidl::DecodeResult<DevhostController::CreateCompositeDeviceResponse> DevhostController::InPlace::CreateCompositeDevice(zx::unowned_channel _client_end, ::fidl::DecodedMessage<CreateCompositeDeviceRequest> params, ::fidl::BytePart response_buffer) {
  params.message()->_hdr = {};
  params.message()->_hdr.ordinal = kDevhostController_CreateCompositeDevice_Ordinal;
  auto _encode_request_result = ::fidl::Encode(std::move(params));
  if (_encode_request_result.status != ZX_OK) {
    return ::fidl::DecodeResult<DevhostController::CreateCompositeDeviceResponse>::FromFailure(
        std::move(_encode_request_result));
  }
  auto _call_result = ::fidl::Call<CreateCompositeDeviceRequest, CreateCompositeDeviceResponse>(
    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
  if (_call_result.status != ZX_OK) {
    return ::fidl::DecodeResult<DevhostController::CreateCompositeDeviceResponse>::FromFailure(
        std::move(_call_result));
  }
  return ::fidl::Decode(std::move(_call_result.message));
}


bool DevhostController::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
  if (msg->num_bytes < sizeof(fidl_message_header_t)) {
    zx_handle_close_many(msg->handles, msg->num_handles);
    txn->Close(ZX_ERR_INVALID_ARGS);
    return true;
  }
  fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
  switch (hdr->ordinal) {
    case kDevhostController_CreateDeviceStub_Ordinal:
    case kDevhostController_CreateDeviceStub_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<CreateDeviceStubRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->CreateDeviceStub(std::move(message->rpc), std::move(message->protocol_id), std::move(message->local_device_id),
        Interface::CreateDeviceStubCompleter::Sync(txn));
      return true;
    }
    case kDevhostController_CreateDevice_Ordinal:
    case kDevhostController_CreateDevice_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<CreateDeviceRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->CreateDevice(std::move(message->rpc), std::move(message->driver_path), std::move(message->driver), std::move(message->parent_proxy), std::move(message->proxy_args), std::move(message->local_device_id),
        Interface::CreateDeviceCompleter::Sync(txn));
      return true;
    }
    case kDevhostController_CreateCompositeDevice_Ordinal:
    case kDevhostController_CreateCompositeDevice_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<CreateCompositeDeviceRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->CreateCompositeDevice(std::move(message->rpc), std::move(message->components), std::move(message->name), std::move(message->local_device_id),
        Interface::CreateCompositeDeviceCompleter::Sync(txn));
      return true;
    }
    default: {
      return false;
    }
  }
}

bool DevhostController::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
  bool found = TryDispatch(impl, msg, txn);
  if (!found) {
    zx_handle_close_many(msg->handles, msg->num_handles);
    txn->Close(ZX_ERR_NOT_SUPPORTED);
  }
  return found;
}


void DevhostController::Interface::CreateCompositeDeviceCompleterBase::Reply(int32_t status) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CreateCompositeDeviceResponse, ::fidl::MessageDirection::kSending>();
  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
  auto& _response = *reinterpret_cast<CreateCompositeDeviceResponse*>(_write_bytes);
  _response._hdr.ordinal = kDevhostController_CreateCompositeDevice_Ordinal;
  _response.status = std::move(status);
  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(CreateCompositeDeviceResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<CreateCompositeDeviceResponse>(std::move(_response_bytes)));
}

void DevhostController::Interface::CreateCompositeDeviceCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
  if (_buffer.capacity() < CreateCompositeDeviceResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  auto& _response = *reinterpret_cast<CreateCompositeDeviceResponse*>(_buffer.data());
  _response._hdr.ordinal = kDevhostController_CreateCompositeDevice_Ordinal;
  _response.status = std::move(status);
  _buffer.set_actual(sizeof(CreateCompositeDeviceResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<CreateCompositeDeviceResponse>(std::move(_buffer)));
}

void DevhostController::Interface::CreateCompositeDeviceCompleterBase::Reply(::fidl::DecodedMessage<CreateCompositeDeviceResponse> params) {
  params.message()->_hdr = {};
  params.message()->_hdr.ordinal = kDevhostController_CreateCompositeDevice_Ordinal;
  CompleterBase::SendReply(std::move(params));
}


::llcpp::fuchsia::device::manager::Coordinator_AddDevice_Result::Coordinator_AddDevice_Result() {
  tag_ = Tag::Invalid;
}

::llcpp::fuchsia::device::manager::Coordinator_AddDevice_Result::~Coordinator_AddDevice_Result() {
  Destroy();
}

void ::llcpp::fuchsia::device::manager::Coordinator_AddDevice_Result::Destroy() {
  switch (which()) {
  case Tag::kResponse:
    response_.~Coordinator_AddDevice_Response();
    break;
  default:
    break;
  }
  tag_ = Tag::Invalid;
}

void ::llcpp::fuchsia::device::manager::Coordinator_AddDevice_Result::MoveImpl_(Coordinator_AddDevice_Result&& other) {
  switch (other.which()) {
  case Tag::kResponse:
    mutable_response() = std::move(other.mutable_response());
    break;
  case Tag::kErr:
    mutable_err() = std::move(other.mutable_err());
    break;
  default:
    break;
  }
  other.Destroy();
}

void ::llcpp::fuchsia::device::manager::Coordinator_AddDevice_Result::SizeAndOffsetAssertionHelper() {
  static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_AddDevice_Result, response_) == 8);
  static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_AddDevice_Result, err_) == 8);
  static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator_AddDevice_Result) == ::llcpp::fuchsia::device::manager::Coordinator_AddDevice_Result::PrimarySize);
}


Coordinator_AddDevice_Response& ::llcpp::fuchsia::device::manager::Coordinator_AddDevice_Result::mutable_response() {
  if (which() != Tag::kResponse) {
    Destroy();
    new (&response_) Coordinator_AddDevice_Response;
  }
  tag_ = Tag::kResponse;
  return response_;
}

int32_t& ::llcpp::fuchsia::device::manager::Coordinator_AddDevice_Result::mutable_err() {
  if (which() != Tag::kErr) {
    Destroy();
    new (&err_) int32_t;
  }
  tag_ = Tag::kErr;
  return err_;
}


::llcpp::fuchsia::device::manager::Coordinator_AddDeviceInvisible_Result::Coordinator_AddDeviceInvisible_Result() {
  tag_ = Tag::Invalid;
}

::llcpp::fuchsia::device::manager::Coordinator_AddDeviceInvisible_Result::~Coordinator_AddDeviceInvisible_Result() {
  Destroy();
}

void ::llcpp::fuchsia::device::manager::Coordinator_AddDeviceInvisible_Result::Destroy() {
  switch (which()) {
  case Tag::kResponse:
    response_.~Coordinator_AddDeviceInvisible_Response();
    break;
  default:
    break;
  }
  tag_ = Tag::Invalid;
}

void ::llcpp::fuchsia::device::manager::Coordinator_AddDeviceInvisible_Result::MoveImpl_(Coordinator_AddDeviceInvisible_Result&& other) {
  switch (other.which()) {
  case Tag::kResponse:
    mutable_response() = std::move(other.mutable_response());
    break;
  case Tag::kErr:
    mutable_err() = std::move(other.mutable_err());
    break;
  default:
    break;
  }
  other.Destroy();
}

void ::llcpp::fuchsia::device::manager::Coordinator_AddDeviceInvisible_Result::SizeAndOffsetAssertionHelper() {
  static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_AddDeviceInvisible_Result, response_) == 8);
  static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_AddDeviceInvisible_Result, err_) == 8);
  static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator_AddDeviceInvisible_Result) == ::llcpp::fuchsia::device::manager::Coordinator_AddDeviceInvisible_Result::PrimarySize);
}


Coordinator_AddDeviceInvisible_Response& ::llcpp::fuchsia::device::manager::Coordinator_AddDeviceInvisible_Result::mutable_response() {
  if (which() != Tag::kResponse) {
    Destroy();
    new (&response_) Coordinator_AddDeviceInvisible_Response;
  }
  tag_ = Tag::kResponse;
  return response_;
}

int32_t& ::llcpp::fuchsia::device::manager::Coordinator_AddDeviceInvisible_Result::mutable_err() {
  if (which() != Tag::kErr) {
    Destroy();
    new (&err_) int32_t;
  }
  tag_ = Tag::kErr;
  return err_;
}


::llcpp::fuchsia::device::manager::Coordinator_UnbindDone_Result::Coordinator_UnbindDone_Result() {
  tag_ = Tag::Invalid;
}

::llcpp::fuchsia::device::manager::Coordinator_UnbindDone_Result::~Coordinator_UnbindDone_Result() {
  Destroy();
}

void ::llcpp::fuchsia::device::manager::Coordinator_UnbindDone_Result::Destroy() {
  switch (which()) {
  case Tag::kResponse:
    response_.~Coordinator_UnbindDone_Response();
    break;
  default:
    break;
  }
  tag_ = Tag::Invalid;
}

void ::llcpp::fuchsia::device::manager::Coordinator_UnbindDone_Result::MoveImpl_(Coordinator_UnbindDone_Result&& other) {
  switch (other.which()) {
  case Tag::kResponse:
    mutable_response() = std::move(other.mutable_response());
    break;
  case Tag::kErr:
    mutable_err() = std::move(other.mutable_err());
    break;
  default:
    break;
  }
  other.Destroy();
}

void ::llcpp::fuchsia::device::manager::Coordinator_UnbindDone_Result::SizeAndOffsetAssertionHelper() {
  static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_UnbindDone_Result, response_) == 4);
  static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_UnbindDone_Result, err_) == 4);
  static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator_UnbindDone_Result) == ::llcpp::fuchsia::device::manager::Coordinator_UnbindDone_Result::PrimarySize);
}


Coordinator_UnbindDone_Response& ::llcpp::fuchsia::device::manager::Coordinator_UnbindDone_Result::mutable_response() {
  if (which() != Tag::kResponse) {
    Destroy();
    new (&response_) Coordinator_UnbindDone_Response;
  }
  tag_ = Tag::kResponse;
  return response_;
}

int32_t& ::llcpp::fuchsia::device::manager::Coordinator_UnbindDone_Result::mutable_err() {
  if (which() != Tag::kErr) {
    Destroy();
    new (&err_) int32_t;
  }
  tag_ = Tag::kErr;
  return err_;
}


::llcpp::fuchsia::device::manager::Coordinator_RunCompatibilityTests_Result::Coordinator_RunCompatibilityTests_Result() {
  tag_ = Tag::Invalid;
}

::llcpp::fuchsia::device::manager::Coordinator_RunCompatibilityTests_Result::~Coordinator_RunCompatibilityTests_Result() {
  Destroy();
}

void ::llcpp::fuchsia::device::manager::Coordinator_RunCompatibilityTests_Result::Destroy() {
  switch (which()) {
  case Tag::kResponse:
    response_.~Coordinator_RunCompatibilityTests_Response();
    break;
  default:
    break;
  }
  tag_ = Tag::Invalid;
}

void ::llcpp::fuchsia::device::manager::Coordinator_RunCompatibilityTests_Result::MoveImpl_(Coordinator_RunCompatibilityTests_Result&& other) {
  switch (other.which()) {
  case Tag::kResponse:
    mutable_response() = std::move(other.mutable_response());
    break;
  case Tag::kErr:
    mutable_err() = std::move(other.mutable_err());
    break;
  default:
    break;
  }
  other.Destroy();
}

void ::llcpp::fuchsia::device::manager::Coordinator_RunCompatibilityTests_Result::SizeAndOffsetAssertionHelper() {
  static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_RunCompatibilityTests_Result, response_) == 4);
  static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_RunCompatibilityTests_Result, err_) == 4);
  static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator_RunCompatibilityTests_Result) == ::llcpp::fuchsia::device::manager::Coordinator_RunCompatibilityTests_Result::PrimarySize);
}


Coordinator_RunCompatibilityTests_Response& ::llcpp::fuchsia::device::manager::Coordinator_RunCompatibilityTests_Result::mutable_response() {
  if (which() != Tag::kResponse) {
    Destroy();
    new (&response_) Coordinator_RunCompatibilityTests_Response;
  }
  tag_ = Tag::kResponse;
  return response_;
}

int32_t& ::llcpp::fuchsia::device::manager::Coordinator_RunCompatibilityTests_Result::mutable_err() {
  if (which() != Tag::kErr) {
    Destroy();
    new (&err_) int32_t;
  }
  tag_ = Tag::kErr;
  return err_;
}


::llcpp::fuchsia::device::manager::Coordinator_RemoveDone_Result::Coordinator_RemoveDone_Result() {
  tag_ = Tag::Invalid;
}

::llcpp::fuchsia::device::manager::Coordinator_RemoveDone_Result::~Coordinator_RemoveDone_Result() {
  Destroy();
}

void ::llcpp::fuchsia::device::manager::Coordinator_RemoveDone_Result::Destroy() {
  switch (which()) {
  case Tag::kResponse:
    response_.~Coordinator_RemoveDone_Response();
    break;
  default:
    break;
  }
  tag_ = Tag::Invalid;
}

void ::llcpp::fuchsia::device::manager::Coordinator_RemoveDone_Result::MoveImpl_(Coordinator_RemoveDone_Result&& other) {
  switch (other.which()) {
  case Tag::kResponse:
    mutable_response() = std::move(other.mutable_response());
    break;
  case Tag::kErr:
    mutable_err() = std::move(other.mutable_err());
    break;
  default:
    break;
  }
  other.Destroy();
}

void ::llcpp::fuchsia::device::manager::Coordinator_RemoveDone_Result::SizeAndOffsetAssertionHelper() {
  static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_RemoveDone_Result, response_) == 4);
  static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_RemoveDone_Result, err_) == 4);
  static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator_RemoveDone_Result) == ::llcpp::fuchsia::device::manager::Coordinator_RemoveDone_Result::PrimarySize);
}


Coordinator_RemoveDone_Response& ::llcpp::fuchsia::device::manager::Coordinator_RemoveDone_Result::mutable_response() {
  if (which() != Tag::kResponse) {
    Destroy();
    new (&response_) Coordinator_RemoveDone_Response;
  }
  tag_ = Tag::kResponse;
  return response_;
}

int32_t& ::llcpp::fuchsia::device::manager::Coordinator_RemoveDone_Result::mutable_err() {
  if (which() != Tag::kErr) {
    Destroy();
    new (&err_) int32_t;
  }
  tag_ = Tag::kErr;
  return err_;
}


::llcpp::fuchsia::device::manager::Coordinator_PublishMetadata_Result::Coordinator_PublishMetadata_Result() {
  tag_ = Tag::Invalid;
}

::llcpp::fuchsia::device::manager::Coordinator_PublishMetadata_Result::~Coordinator_PublishMetadata_Result() {
  Destroy();
}

void ::llcpp::fuchsia::device::manager::Coordinator_PublishMetadata_Result::Destroy() {
  switch (which()) {
  case Tag::kResponse:
    response_.~Coordinator_PublishMetadata_Response();
    break;
  default:
    break;
  }
  tag_ = Tag::Invalid;
}

void ::llcpp::fuchsia::device::manager::Coordinator_PublishMetadata_Result::MoveImpl_(Coordinator_PublishMetadata_Result&& other) {
  switch (other.which()) {
  case Tag::kResponse:
    mutable_response() = std::move(other.mutable_response());
    break;
  case Tag::kErr:
    mutable_err() = std::move(other.mutable_err());
    break;
  default:
    break;
  }
  other.Destroy();
}

void ::llcpp::fuchsia::device::manager::Coordinator_PublishMetadata_Result::SizeAndOffsetAssertionHelper() {
  static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_PublishMetadata_Result, response_) == 4);
  static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_PublishMetadata_Result, err_) == 4);
  static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator_PublishMetadata_Result) == ::llcpp::fuchsia::device::manager::Coordinator_PublishMetadata_Result::PrimarySize);
}


Coordinator_PublishMetadata_Response& ::llcpp::fuchsia::device::manager::Coordinator_PublishMetadata_Result::mutable_response() {
  if (which() != Tag::kResponse) {
    Destroy();
    new (&response_) Coordinator_PublishMetadata_Response;
  }
  tag_ = Tag::kResponse;
  return response_;
}

int32_t& ::llcpp::fuchsia::device::manager::Coordinator_PublishMetadata_Result::mutable_err() {
  if (which() != Tag::kErr) {
    Destroy();
    new (&err_) int32_t;
  }
  tag_ = Tag::kErr;
  return err_;
}


::llcpp::fuchsia::device::manager::Coordinator_MakeVisible_Result::Coordinator_MakeVisible_Result() {
  tag_ = Tag::Invalid;
}

::llcpp::fuchsia::device::manager::Coordinator_MakeVisible_Result::~Coordinator_MakeVisible_Result() {
  Destroy();
}

void ::llcpp::fuchsia::device::manager::Coordinator_MakeVisible_Result::Destroy() {
  switch (which()) {
  case Tag::kResponse:
    response_.~Coordinator_MakeVisible_Response();
    break;
  default:
    break;
  }
  tag_ = Tag::Invalid;
}

void ::llcpp::fuchsia::device::manager::Coordinator_MakeVisible_Result::MoveImpl_(Coordinator_MakeVisible_Result&& other) {
  switch (other.which()) {
  case Tag::kResponse:
    mutable_response() = std::move(other.mutable_response());
    break;
  case Tag::kErr:
    mutable_err() = std::move(other.mutable_err());
    break;
  default:
    break;
  }
  other.Destroy();
}

void ::llcpp::fuchsia::device::manager::Coordinator_MakeVisible_Result::SizeAndOffsetAssertionHelper() {
  static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_MakeVisible_Result, response_) == 4);
  static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_MakeVisible_Result, err_) == 4);
  static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator_MakeVisible_Result) == ::llcpp::fuchsia::device::manager::Coordinator_MakeVisible_Result::PrimarySize);
}


Coordinator_MakeVisible_Response& ::llcpp::fuchsia::device::manager::Coordinator_MakeVisible_Result::mutable_response() {
  if (which() != Tag::kResponse) {
    Destroy();
    new (&response_) Coordinator_MakeVisible_Response;
  }
  tag_ = Tag::kResponse;
  return response_;
}

int32_t& ::llcpp::fuchsia::device::manager::Coordinator_MakeVisible_Result::mutable_err() {
  if (which() != Tag::kErr) {
    Destroy();
    new (&err_) int32_t;
  }
  tag_ = Tag::kErr;
  return err_;
}


::llcpp::fuchsia::device::manager::Coordinator_LoadFirmware_Result::Coordinator_LoadFirmware_Result() {
  tag_ = Tag::Invalid;
}

::llcpp::fuchsia::device::manager::Coordinator_LoadFirmware_Result::~Coordinator_LoadFirmware_Result() {
  Destroy();
}

void ::llcpp::fuchsia::device::manager::Coordinator_LoadFirmware_Result::Destroy() {
  switch (which()) {
  case Tag::kResponse:
    response_.~Coordinator_LoadFirmware_Response();
    break;
  default:
    break;
  }
  tag_ = Tag::Invalid;
}

void ::llcpp::fuchsia::device::manager::Coordinator_LoadFirmware_Result::MoveImpl_(Coordinator_LoadFirmware_Result&& other) {
  switch (other.which()) {
  case Tag::kResponse:
    mutable_response() = std::move(other.mutable_response());
    break;
  case Tag::kErr:
    mutable_err() = std::move(other.mutable_err());
    break;
  default:
    break;
  }
  other.Destroy();
}

void ::llcpp::fuchsia::device::manager::Coordinator_LoadFirmware_Result::SizeAndOffsetAssertionHelper() {
  static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_LoadFirmware_Result, response_) == 8);
  static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_LoadFirmware_Result, err_) == 8);
  static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator_LoadFirmware_Result) == ::llcpp::fuchsia::device::manager::Coordinator_LoadFirmware_Result::PrimarySize);
}


Coordinator_LoadFirmware_Response& ::llcpp::fuchsia::device::manager::Coordinator_LoadFirmware_Result::mutable_response() {
  if (which() != Tag::kResponse) {
    Destroy();
    new (&response_) Coordinator_LoadFirmware_Response;
  }
  tag_ = Tag::kResponse;
  return response_;
}

int32_t& ::llcpp::fuchsia::device::manager::Coordinator_LoadFirmware_Result::mutable_err() {
  if (which() != Tag::kErr) {
    Destroy();
    new (&err_) int32_t;
  }
  tag_ = Tag::kErr;
  return err_;
}


::llcpp::fuchsia::device::manager::Coordinator_GetTopologicalPath_Result::Coordinator_GetTopologicalPath_Result() {
  tag_ = Tag::Invalid;
}

::llcpp::fuchsia::device::manager::Coordinator_GetTopologicalPath_Result::~Coordinator_GetTopologicalPath_Result() {
  Destroy();
}

void ::llcpp::fuchsia::device::manager::Coordinator_GetTopologicalPath_Result::Destroy() {
  switch (which()) {
  case Tag::kResponse:
    response_.~Coordinator_GetTopologicalPath_Response();
    break;
  default:
    break;
  }
  tag_ = Tag::Invalid;
}

void ::llcpp::fuchsia::device::manager::Coordinator_GetTopologicalPath_Result::MoveImpl_(Coordinator_GetTopologicalPath_Result&& other) {
  switch (other.which()) {
  case Tag::kResponse:
    mutable_response() = std::move(other.mutable_response());
    break;
  case Tag::kErr:
    mutable_err() = std::move(other.mutable_err());
    break;
  default:
    break;
  }
  other.Destroy();
}

void ::llcpp::fuchsia::device::manager::Coordinator_GetTopologicalPath_Result::SizeAndOffsetAssertionHelper() {
  static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_GetTopologicalPath_Result, response_) == 8);
  static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_GetTopologicalPath_Result, err_) == 8);
  static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator_GetTopologicalPath_Result) == ::llcpp::fuchsia::device::manager::Coordinator_GetTopologicalPath_Result::PrimarySize);
}


Coordinator_GetTopologicalPath_Response& ::llcpp::fuchsia::device::manager::Coordinator_GetTopologicalPath_Result::mutable_response() {
  if (which() != Tag::kResponse) {
    Destroy();
    new (&response_) Coordinator_GetTopologicalPath_Response;
  }
  tag_ = Tag::kResponse;
  return response_;
}

int32_t& ::llcpp::fuchsia::device::manager::Coordinator_GetTopologicalPath_Result::mutable_err() {
  if (which() != Tag::kErr) {
    Destroy();
    new (&err_) int32_t;
  }
  tag_ = Tag::kErr;
  return err_;
}


::llcpp::fuchsia::device::manager::Coordinator_GetMetadata_Result::Coordinator_GetMetadata_Result() {
  tag_ = Tag::Invalid;
}

::llcpp::fuchsia::device::manager::Coordinator_GetMetadata_Result::~Coordinator_GetMetadata_Result() {
  Destroy();
}

void ::llcpp::fuchsia::device::manager::Coordinator_GetMetadata_Result::Destroy() {
  switch (which()) {
  case Tag::kResponse:
    response_.~Coordinator_GetMetadata_Response();
    break;
  default:
    break;
  }
  tag_ = Tag::Invalid;
}

void ::llcpp::fuchsia::device::manager::Coordinator_GetMetadata_Result::MoveImpl_(Coordinator_GetMetadata_Result&& other) {
  switch (other.which()) {
  case Tag::kResponse:
    mutable_response() = std::move(other.mutable_response());
    break;
  case Tag::kErr:
    mutable_err() = std::move(other.mutable_err());
    break;
  default:
    break;
  }
  other.Destroy();
}

void ::llcpp::fuchsia::device::manager::Coordinator_GetMetadata_Result::SizeAndOffsetAssertionHelper() {
  static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_GetMetadata_Result, response_) == 8);
  static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_GetMetadata_Result, err_) == 8);
  static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator_GetMetadata_Result) == ::llcpp::fuchsia::device::manager::Coordinator_GetMetadata_Result::PrimarySize);
}


Coordinator_GetMetadata_Response& ::llcpp::fuchsia::device::manager::Coordinator_GetMetadata_Result::mutable_response() {
  if (which() != Tag::kResponse) {
    Destroy();
    new (&response_) Coordinator_GetMetadata_Response;
  }
  tag_ = Tag::kResponse;
  return response_;
}

int32_t& ::llcpp::fuchsia::device::manager::Coordinator_GetMetadata_Result::mutable_err() {
  if (which() != Tag::kErr) {
    Destroy();
    new (&err_) int32_t;
  }
  tag_ = Tag::kErr;
  return err_;
}


::llcpp::fuchsia::device::manager::Coordinator_GetMetadataSize_Result::Coordinator_GetMetadataSize_Result() {
  tag_ = Tag::Invalid;
}

::llcpp::fuchsia::device::manager::Coordinator_GetMetadataSize_Result::~Coordinator_GetMetadataSize_Result() {
  Destroy();
}

void ::llcpp::fuchsia::device::manager::Coordinator_GetMetadataSize_Result::Destroy() {
  switch (which()) {
  case Tag::kResponse:
    response_.~Coordinator_GetMetadataSize_Response();
    break;
  default:
    break;
  }
  tag_ = Tag::Invalid;
}

void ::llcpp::fuchsia::device::manager::Coordinator_GetMetadataSize_Result::MoveImpl_(Coordinator_GetMetadataSize_Result&& other) {
  switch (other.which()) {
  case Tag::kResponse:
    mutable_response() = std::move(other.mutable_response());
    break;
  case Tag::kErr:
    mutable_err() = std::move(other.mutable_err());
    break;
  default:
    break;
  }
  other.Destroy();
}

void ::llcpp::fuchsia::device::manager::Coordinator_GetMetadataSize_Result::SizeAndOffsetAssertionHelper() {
  static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_GetMetadataSize_Result, response_) == 8);
  static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_GetMetadataSize_Result, err_) == 8);
  static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator_GetMetadataSize_Result) == ::llcpp::fuchsia::device::manager::Coordinator_GetMetadataSize_Result::PrimarySize);
}


Coordinator_GetMetadataSize_Response& ::llcpp::fuchsia::device::manager::Coordinator_GetMetadataSize_Result::mutable_response() {
  if (which() != Tag::kResponse) {
    Destroy();
    new (&response_) Coordinator_GetMetadataSize_Response;
  }
  tag_ = Tag::kResponse;
  return response_;
}

int32_t& ::llcpp::fuchsia::device::manager::Coordinator_GetMetadataSize_Result::mutable_err() {
  if (which() != Tag::kErr) {
    Destroy();
    new (&err_) int32_t;
  }
  tag_ = Tag::kErr;
  return err_;
}


::llcpp::fuchsia::device::manager::Coordinator_DirectoryWatch_Result::Coordinator_DirectoryWatch_Result() {
  tag_ = Tag::Invalid;
}

::llcpp::fuchsia::device::manager::Coordinator_DirectoryWatch_Result::~Coordinator_DirectoryWatch_Result() {
  Destroy();
}

void ::llcpp::fuchsia::device::manager::Coordinator_DirectoryWatch_Result::Destroy() {
  switch (which()) {
  case Tag::kResponse:
    response_.~Coordinator_DirectoryWatch_Response();
    break;
  default:
    break;
  }
  tag_ = Tag::Invalid;
}

void ::llcpp::fuchsia::device::manager::Coordinator_DirectoryWatch_Result::MoveImpl_(Coordinator_DirectoryWatch_Result&& other) {
  switch (other.which()) {
  case Tag::kResponse:
    mutable_response() = std::move(other.mutable_response());
    break;
  case Tag::kErr:
    mutable_err() = std::move(other.mutable_err());
    break;
  default:
    break;
  }
  other.Destroy();
}

void ::llcpp::fuchsia::device::manager::Coordinator_DirectoryWatch_Result::SizeAndOffsetAssertionHelper() {
  static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_DirectoryWatch_Result, response_) == 4);
  static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_DirectoryWatch_Result, err_) == 4);
  static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator_DirectoryWatch_Result) == ::llcpp::fuchsia::device::manager::Coordinator_DirectoryWatch_Result::PrimarySize);
}


Coordinator_DirectoryWatch_Response& ::llcpp::fuchsia::device::manager::Coordinator_DirectoryWatch_Result::mutable_response() {
  if (which() != Tag::kResponse) {
    Destroy();
    new (&response_) Coordinator_DirectoryWatch_Response;
  }
  tag_ = Tag::kResponse;
  return response_;
}

int32_t& ::llcpp::fuchsia::device::manager::Coordinator_DirectoryWatch_Result::mutable_err() {
  if (which() != Tag::kErr) {
    Destroy();
    new (&err_) int32_t;
  }
  tag_ = Tag::kErr;
  return err_;
}


::llcpp::fuchsia::device::manager::Coordinator_BindDevice_Result::Coordinator_BindDevice_Result() {
  tag_ = Tag::Invalid;
}

::llcpp::fuchsia::device::manager::Coordinator_BindDevice_Result::~Coordinator_BindDevice_Result() {
  Destroy();
}

void ::llcpp::fuchsia::device::manager::Coordinator_BindDevice_Result::Destroy() {
  switch (which()) {
  case Tag::kResponse:
    response_.~Coordinator_BindDevice_Response();
    break;
  default:
    break;
  }
  tag_ = Tag::Invalid;
}

void ::llcpp::fuchsia::device::manager::Coordinator_BindDevice_Result::MoveImpl_(Coordinator_BindDevice_Result&& other) {
  switch (other.which()) {
  case Tag::kResponse:
    mutable_response() = std::move(other.mutable_response());
    break;
  case Tag::kErr:
    mutable_err() = std::move(other.mutable_err());
    break;
  default:
    break;
  }
  other.Destroy();
}

void ::llcpp::fuchsia::device::manager::Coordinator_BindDevice_Result::SizeAndOffsetAssertionHelper() {
  static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_BindDevice_Result, response_) == 4);
  static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_BindDevice_Result, err_) == 4);
  static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator_BindDevice_Result) == ::llcpp::fuchsia::device::manager::Coordinator_BindDevice_Result::PrimarySize);
}


Coordinator_BindDevice_Response& ::llcpp::fuchsia::device::manager::Coordinator_BindDevice_Result::mutable_response() {
  if (which() != Tag::kResponse) {
    Destroy();
    new (&response_) Coordinator_BindDevice_Response;
  }
  tag_ = Tag::kResponse;
  return response_;
}

int32_t& ::llcpp::fuchsia::device::manager::Coordinator_BindDevice_Result::mutable_err() {
  if (which() != Tag::kErr) {
    Destroy();
    new (&err_) int32_t;
  }
  tag_ = Tag::kErr;
  return err_;
}


::llcpp::fuchsia::device::manager::Coordinator_AddMetadata_Result::Coordinator_AddMetadata_Result() {
  tag_ = Tag::Invalid;
}

::llcpp::fuchsia::device::manager::Coordinator_AddMetadata_Result::~Coordinator_AddMetadata_Result() {
  Destroy();
}

void ::llcpp::fuchsia::device::manager::Coordinator_AddMetadata_Result::Destroy() {
  switch (which()) {
  case Tag::kResponse:
    response_.~Coordinator_AddMetadata_Response();
    break;
  default:
    break;
  }
  tag_ = Tag::Invalid;
}

void ::llcpp::fuchsia::device::manager::Coordinator_AddMetadata_Result::MoveImpl_(Coordinator_AddMetadata_Result&& other) {
  switch (other.which()) {
  case Tag::kResponse:
    mutable_response() = std::move(other.mutable_response());
    break;
  case Tag::kErr:
    mutable_err() = std::move(other.mutable_err());
    break;
  default:
    break;
  }
  other.Destroy();
}

void ::llcpp::fuchsia::device::manager::Coordinator_AddMetadata_Result::SizeAndOffsetAssertionHelper() {
  static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_AddMetadata_Result, response_) == 4);
  static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_AddMetadata_Result, err_) == 4);
  static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator_AddMetadata_Result) == ::llcpp::fuchsia::device::manager::Coordinator_AddMetadata_Result::PrimarySize);
}


Coordinator_AddMetadata_Response& ::llcpp::fuchsia::device::manager::Coordinator_AddMetadata_Result::mutable_response() {
  if (which() != Tag::kResponse) {
    Destroy();
    new (&response_) Coordinator_AddMetadata_Response;
  }
  tag_ = Tag::kResponse;
  return response_;
}

int32_t& ::llcpp::fuchsia::device::manager::Coordinator_AddMetadata_Result::mutable_err() {
  if (which() != Tag::kErr) {
    Destroy();
    new (&err_) int32_t;
  }
  tag_ = Tag::kErr;
  return err_;
}


::llcpp::fuchsia::device::manager::Coordinator_AddCompositeDevice_Result::Coordinator_AddCompositeDevice_Result() {
  tag_ = Tag::Invalid;
}

::llcpp::fuchsia::device::manager::Coordinator_AddCompositeDevice_Result::~Coordinator_AddCompositeDevice_Result() {
  Destroy();
}

void ::llcpp::fuchsia::device::manager::Coordinator_AddCompositeDevice_Result::Destroy() {
  switch (which()) {
  case Tag::kResponse:
    response_.~Coordinator_AddCompositeDevice_Response();
    break;
  default:
    break;
  }
  tag_ = Tag::Invalid;
}

void ::llcpp::fuchsia::device::manager::Coordinator_AddCompositeDevice_Result::MoveImpl_(Coordinator_AddCompositeDevice_Result&& other) {
  switch (other.which()) {
  case Tag::kResponse:
    mutable_response() = std::move(other.mutable_response());
    break;
  case Tag::kErr:
    mutable_err() = std::move(other.mutable_err());
    break;
  default:
    break;
  }
  other.Destroy();
}

void ::llcpp::fuchsia::device::manager::Coordinator_AddCompositeDevice_Result::SizeAndOffsetAssertionHelper() {
  static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_AddCompositeDevice_Result, response_) == 4);
  static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_AddCompositeDevice_Result, err_) == 4);
  static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator_AddCompositeDevice_Result) == ::llcpp::fuchsia::device::manager::Coordinator_AddCompositeDevice_Result::PrimarySize);
}


Coordinator_AddCompositeDevice_Response& ::llcpp::fuchsia::device::manager::Coordinator_AddCompositeDevice_Result::mutable_response() {
  if (which() != Tag::kResponse) {
    Destroy();
    new (&response_) Coordinator_AddCompositeDevice_Response;
  }
  tag_ = Tag::kResponse;
  return response_;
}

int32_t& ::llcpp::fuchsia::device::manager::Coordinator_AddCompositeDevice_Result::mutable_err() {
  if (which() != Tag::kErr) {
    Destroy();
    new (&err_) int32_t;
  }
  tag_ = Tag::kErr;
  return err_;
}


namespace {

[[maybe_unused]]
constexpr uint64_t kDeviceController_BindDriver_Ordinal = 0x3d3eea9b00000000lu;
[[maybe_unused]]
constexpr uint64_t kDeviceController_BindDriver_GenOrdinal = 0x1600a1d1d6024855lu;
extern "C" const fidl_type_t fuchsia_device_manager_DeviceControllerBindDriverRequestTable;
extern "C" const fidl_type_t fuchsia_device_manager_DeviceControllerBindDriverResponseTable;
[[maybe_unused]]
constexpr uint64_t kDeviceController_ConnectProxy_Ordinal = 0x582e0d9b00000000lu;
[[maybe_unused]]
constexpr uint64_t kDeviceController_ConnectProxy_GenOrdinal = 0x72206da90d1f3f2flu;
extern "C" const fidl_type_t fuchsia_device_manager_DeviceControllerConnectProxyRequestTable;
[[maybe_unused]]
constexpr uint64_t kDeviceController_Unbind_Ordinal = 0x72bdd28200000000lu;
[[maybe_unused]]
constexpr uint64_t kDeviceController_Unbind_GenOrdinal = 0x2d3f793e42cc3fd0lu;
[[maybe_unused]]
constexpr uint64_t kDeviceController_CompleteRemoval_Ordinal = 0x1554eba800000000lu;
[[maybe_unused]]
constexpr uint64_t kDeviceController_CompleteRemoval_GenOrdinal = 0x25d6d94c85d60771lu;
[[maybe_unused]]
constexpr uint64_t kDeviceController_RemoveDevice_Ordinal = 0x5db4ce200000000lu;
[[maybe_unused]]
constexpr uint64_t kDeviceController_RemoveDevice_GenOrdinal = 0x7b9cb8cf970eb164lu;
[[maybe_unused]]
constexpr uint64_t kDeviceController_Suspend_Ordinal = 0x4490901a00000000lu;
[[maybe_unused]]
constexpr uint64_t kDeviceController_Suspend_GenOrdinal = 0x77bf98a1d5d4adbblu;
extern "C" const fidl_type_t fuchsia_device_manager_DeviceControllerSuspendRequestTable;
extern "C" const fidl_type_t fuchsia_device_manager_DeviceControllerSuspendResponseTable;
[[maybe_unused]]
constexpr uint64_t kDeviceController_Resume_Ordinal = 0x4d69ba3300000000lu;
[[maybe_unused]]
constexpr uint64_t kDeviceController_Resume_GenOrdinal = 0x4f111286b7bd9caflu;
extern "C" const fidl_type_t fuchsia_device_manager_DeviceControllerResumeRequestTable;
extern "C" const fidl_type_t fuchsia_device_manager_DeviceControllerResumeResponseTable;
[[maybe_unused]]
constexpr uint64_t kDeviceController_CompleteCompatibilityTests_Ordinal = 0x475e367c00000000lu;
[[maybe_unused]]
constexpr uint64_t kDeviceController_CompleteCompatibilityTests_GenOrdinal = 0x3883342451945549lu;
extern "C" const fidl_type_t fuchsia_device_manager_DeviceControllerCompleteCompatibilityTestsRequestTable;

}  // namespace
template <>
DeviceController::ResultOf::BindDriver_Impl<DeviceController::BindDriverResponse>::BindDriver_Impl(zx::unowned_channel _client_end, ::fidl::StringView driver_path, ::zx::vmo driver) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<BindDriverRequest, ::fidl::MessageDirection::kSending>();
  std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
  auto& _write_bytes_array = *_write_bytes_boxed;
  BindDriverRequest _request = {};
  _request.driver_path = std::move(driver_path);
  _request.driver = std::move(driver);
  auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
  if (_linearize_result.status != ZX_OK) {
    Super::SetFailure(std::move(_linearize_result));
    return;
  }
  ::fidl::DecodedMessage<BindDriverRequest> _decoded_request = std::move(_linearize_result.message);
  Super::SetResult(
      DeviceController::InPlace::BindDriver(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
}

DeviceController::ResultOf::BindDriver DeviceController::SyncClient::BindDriver(::fidl::StringView driver_path, ::zx::vmo driver) {
  return ResultOf::BindDriver(zx::unowned_channel(this->channel_), std::move(driver_path), std::move(driver));
}

DeviceController::ResultOf::BindDriver DeviceController::Call::BindDriver(zx::unowned_channel _client_end, ::fidl::StringView driver_path, ::zx::vmo driver) {
  return ResultOf::BindDriver(std::move(_client_end), std::move(driver_path), std::move(driver));
}

template <>
DeviceController::UnownedResultOf::BindDriver_Impl<DeviceController::BindDriverResponse>::BindDriver_Impl(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView driver_path, ::zx::vmo driver, ::fidl::BytePart _response_buffer) {
  if (_request_buffer.capacity() < BindDriverRequest::PrimarySize) {
    Super::SetFailure(::fidl::DecodeResult<BindDriverResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
    return;
  }
  BindDriverRequest _request = {};
  _request.driver_path = std::move(driver_path);
  _request.driver = std::move(driver);
  auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
  if (_linearize_result.status != ZX_OK) {
    Super::SetFailure(std::move(_linearize_result));
    return;
  }
  ::fidl::DecodedMessage<BindDriverRequest> _decoded_request = std::move(_linearize_result.message);
  Super::SetResult(
      DeviceController::InPlace::BindDriver(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
}

DeviceController::UnownedResultOf::BindDriver DeviceController::SyncClient::BindDriver(::fidl::BytePart _request_buffer, ::fidl::StringView driver_path, ::zx::vmo driver, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::BindDriver(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(driver_path), std::move(driver), std::move(_response_buffer));
}

DeviceController::UnownedResultOf::BindDriver DeviceController::Call::BindDriver(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView driver_path, ::zx::vmo driver, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::BindDriver(std::move(_client_end), std::move(_request_buffer), std::move(driver_path), std::move(driver), std::move(_response_buffer));
}

::fidl::DecodeResult<DeviceController::BindDriverResponse> DeviceController::InPlace::BindDriver(zx::unowned_channel _client_end, ::fidl::DecodedMessage<BindDriverRequest> params, ::fidl::BytePart response_buffer) {
  params.message()->_hdr = {};
  params.message()->_hdr.ordinal = kDeviceController_BindDriver_Ordinal;
  auto _encode_request_result = ::fidl::Encode(std::move(params));
  if (_encode_request_result.status != ZX_OK) {
    return ::fidl::DecodeResult<DeviceController::BindDriverResponse>::FromFailure(
        std::move(_encode_request_result));
  }
  auto _call_result = ::fidl::Call<BindDriverRequest, BindDriverResponse>(
    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
  if (_call_result.status != ZX_OK) {
    return ::fidl::DecodeResult<DeviceController::BindDriverResponse>::FromFailure(
        std::move(_call_result));
  }
  return ::fidl::Decode(std::move(_call_result.message));
}


DeviceController::ResultOf::ConnectProxy_Impl::ConnectProxy_Impl(zx::unowned_channel _client_end, ::zx::channel shadow) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ConnectProxyRequest, ::fidl::MessageDirection::kSending>();
  ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
  auto& _write_bytes_array = _write_bytes_inlined;
  uint8_t* _write_bytes = _write_bytes_array.view().data();
  memset(_write_bytes, 0, ConnectProxyRequest::PrimarySize);
  auto& _request = *reinterpret_cast<ConnectProxyRequest*>(_write_bytes);
  _request.shadow = std::move(shadow);
  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ConnectProxyRequest));
  ::fidl::DecodedMessage<ConnectProxyRequest> _decoded_request(std::move(_request_bytes));
  Super::operator=(
      DeviceController::InPlace::ConnectProxy(std::move(_client_end), std::move(_decoded_request)));
}

DeviceController::ResultOf::ConnectProxy DeviceController::SyncClient::ConnectProxy(::zx::channel shadow) {
  return ResultOf::ConnectProxy(zx::unowned_channel(this->channel_), std::move(shadow));
}

DeviceController::ResultOf::ConnectProxy DeviceController::Call::ConnectProxy(zx::unowned_channel _client_end, ::zx::channel shadow) {
  return ResultOf::ConnectProxy(std::move(_client_end), std::move(shadow));
}


DeviceController::UnownedResultOf::ConnectProxy_Impl::ConnectProxy_Impl(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel shadow) {
  if (_request_buffer.capacity() < ConnectProxyRequest::PrimarySize) {
    Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
    Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
    return;
  }
  memset(_request_buffer.data(), 0, ConnectProxyRequest::PrimarySize);
  auto& _request = *reinterpret_cast<ConnectProxyRequest*>(_request_buffer.data());
  _request.shadow = std::move(shadow);
  _request_buffer.set_actual(sizeof(ConnectProxyRequest));
  ::fidl::DecodedMessage<ConnectProxyRequest> _decoded_request(std::move(_request_buffer));
  Super::operator=(
      DeviceController::InPlace::ConnectProxy(std::move(_client_end), std::move(_decoded_request)));
}

DeviceController::UnownedResultOf::ConnectProxy DeviceController::SyncClient::ConnectProxy(::fidl::BytePart _request_buffer, ::zx::channel shadow) {
  return UnownedResultOf::ConnectProxy(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(shadow));
}

DeviceController::UnownedResultOf::ConnectProxy DeviceController::Call::ConnectProxy(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel shadow) {
  return UnownedResultOf::ConnectProxy(std::move(_client_end), std::move(_request_buffer), std::move(shadow));
}

::fidl::internal::StatusAndError DeviceController::InPlace::ConnectProxy(zx::unowned_channel _client_end, ::fidl::DecodedMessage<ConnectProxyRequest> params) {
  params.message()->_hdr = {};
  params.message()->_hdr.ordinal = kDeviceController_ConnectProxy_Ordinal;
  auto _encode_request_result = ::fidl::Encode(std::move(params));
  if (_encode_request_result.status != ZX_OK) {
    return ::fidl::internal::StatusAndError::FromFailure(
        std::move(_encode_request_result));
  }
  zx_status_t _write_status =
      ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
  if (_write_status != ZX_OK) {
    return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
  } else {
    return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
  }
}


DeviceController::ResultOf::Unbind_Impl::Unbind_Impl(zx::unowned_channel _client_end) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<UnbindRequest, ::fidl::MessageDirection::kSending>();
  ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
  auto& _write_bytes_array = _write_bytes_inlined;
  uint8_t* _write_bytes = _write_bytes_array.view().data();
  memset(_write_bytes, 0, UnbindRequest::PrimarySize);
  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(UnbindRequest));
  ::fidl::DecodedMessage<UnbindRequest> _decoded_request(std::move(_request_bytes));
  Super::operator=(
      DeviceController::InPlace::Unbind(std::move(_client_end)));
}

DeviceController::ResultOf::Unbind DeviceController::SyncClient::Unbind() {
  return ResultOf::Unbind(zx::unowned_channel(this->channel_));
}

DeviceController::ResultOf::Unbind DeviceController::Call::Unbind(zx::unowned_channel _client_end) {
  return ResultOf::Unbind(std::move(_client_end));
}

::fidl::internal::StatusAndError DeviceController::InPlace::Unbind(zx::unowned_channel _client_end) {
  constexpr uint32_t _write_num_bytes = sizeof(UnbindRequest);
  ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
  ::fidl::BytePart _request_buffer = _write_bytes.view();
  _request_buffer.set_actual(_write_num_bytes);
  ::fidl::DecodedMessage<UnbindRequest> params(std::move(_request_buffer));
  params.message()->_hdr = {};
  params.message()->_hdr.ordinal = kDeviceController_Unbind_Ordinal;
  auto _encode_request_result = ::fidl::Encode(std::move(params));
  if (_encode_request_result.status != ZX_OK) {
    return ::fidl::internal::StatusAndError::FromFailure(
        std::move(_encode_request_result));
  }
  zx_status_t _write_status =
      ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
  if (_write_status != ZX_OK) {
    return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
  } else {
    return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
  }
}


DeviceController::ResultOf::CompleteRemoval_Impl::CompleteRemoval_Impl(zx::unowned_channel _client_end) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CompleteRemovalRequest, ::fidl::MessageDirection::kSending>();
  ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
  auto& _write_bytes_array = _write_bytes_inlined;
  uint8_t* _write_bytes = _write_bytes_array.view().data();
  memset(_write_bytes, 0, CompleteRemovalRequest::PrimarySize);
  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(CompleteRemovalRequest));
  ::fidl::DecodedMessage<CompleteRemovalRequest> _decoded_request(std::move(_request_bytes));
  Super::operator=(
      DeviceController::InPlace::CompleteRemoval(std::move(_client_end)));
}

DeviceController::ResultOf::CompleteRemoval DeviceController::SyncClient::CompleteRemoval() {
  return ResultOf::CompleteRemoval(zx::unowned_channel(this->channel_));
}

DeviceController::ResultOf::CompleteRemoval DeviceController::Call::CompleteRemoval(zx::unowned_channel _client_end) {
  return ResultOf::CompleteRemoval(std::move(_client_end));
}

::fidl::internal::StatusAndError DeviceController::InPlace::CompleteRemoval(zx::unowned_channel _client_end) {
  constexpr uint32_t _write_num_bytes = sizeof(CompleteRemovalRequest);
  ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
  ::fidl::BytePart _request_buffer = _write_bytes.view();
  _request_buffer.set_actual(_write_num_bytes);
  ::fidl::DecodedMessage<CompleteRemovalRequest> params(std::move(_request_buffer));
  params.message()->_hdr = {};
  params.message()->_hdr.ordinal = kDeviceController_CompleteRemoval_Ordinal;
  auto _encode_request_result = ::fidl::Encode(std::move(params));
  if (_encode_request_result.status != ZX_OK) {
    return ::fidl::internal::StatusAndError::FromFailure(
        std::move(_encode_request_result));
  }
  zx_status_t _write_status =
      ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
  if (_write_status != ZX_OK) {
    return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
  } else {
    return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
  }
}


DeviceController::ResultOf::RemoveDevice_Impl::RemoveDevice_Impl(zx::unowned_channel _client_end) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RemoveDeviceRequest, ::fidl::MessageDirection::kSending>();
  ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
  auto& _write_bytes_array = _write_bytes_inlined;
  uint8_t* _write_bytes = _write_bytes_array.view().data();
  memset(_write_bytes, 0, RemoveDeviceRequest::PrimarySize);
  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(RemoveDeviceRequest));
  ::fidl::DecodedMessage<RemoveDeviceRequest> _decoded_request(std::move(_request_bytes));
  Super::operator=(
      DeviceController::InPlace::RemoveDevice(std::move(_client_end)));
}

DeviceController::ResultOf::RemoveDevice DeviceController::SyncClient::RemoveDevice() {
  return ResultOf::RemoveDevice(zx::unowned_channel(this->channel_));
}

DeviceController::ResultOf::RemoveDevice DeviceController::Call::RemoveDevice(zx::unowned_channel _client_end) {
  return ResultOf::RemoveDevice(std::move(_client_end));
}

::fidl::internal::StatusAndError DeviceController::InPlace::RemoveDevice(zx::unowned_channel _client_end) {
  constexpr uint32_t _write_num_bytes = sizeof(RemoveDeviceRequest);
  ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
  ::fidl::BytePart _request_buffer = _write_bytes.view();
  _request_buffer.set_actual(_write_num_bytes);
  ::fidl::DecodedMessage<RemoveDeviceRequest> params(std::move(_request_buffer));
  params.message()->_hdr = {};
  params.message()->_hdr.ordinal = kDeviceController_RemoveDevice_Ordinal;
  auto _encode_request_result = ::fidl::Encode(std::move(params));
  if (_encode_request_result.status != ZX_OK) {
    return ::fidl::internal::StatusAndError::FromFailure(
        std::move(_encode_request_result));
  }
  zx_status_t _write_status =
      ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
  if (_write_status != ZX_OK) {
    return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
  } else {
    return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
  }
}

template <>
DeviceController::ResultOf::Suspend_Impl<DeviceController::SuspendResponse>::Suspend_Impl(zx::unowned_channel _client_end, uint32_t flags) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SuspendRequest, ::fidl::MessageDirection::kSending>();
  ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
  auto& _write_bytes_array = _write_bytes_inlined;
  uint8_t* _write_bytes = _write_bytes_array.view().data();
  memset(_write_bytes, 0, SuspendRequest::PrimarySize);
  auto& _request = *reinterpret_cast<SuspendRequest*>(_write_bytes);
  _request.flags = std::move(flags);
  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SuspendRequest));
  ::fidl::DecodedMessage<SuspendRequest> _decoded_request(std::move(_request_bytes));
  Super::SetResult(
      DeviceController::InPlace::Suspend(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
}

DeviceController::ResultOf::Suspend DeviceController::SyncClient::Suspend(uint32_t flags) {
  return ResultOf::Suspend(zx::unowned_channel(this->channel_), std::move(flags));
}

DeviceController::ResultOf::Suspend DeviceController::Call::Suspend(zx::unowned_channel _client_end, uint32_t flags) {
  return ResultOf::Suspend(std::move(_client_end), std::move(flags));
}

template <>
DeviceController::UnownedResultOf::Suspend_Impl<DeviceController::SuspendResponse>::Suspend_Impl(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer) {
  if (_request_buffer.capacity() < SuspendRequest::PrimarySize) {
    Super::SetFailure(::fidl::DecodeResult<SuspendResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
    return;
  }
  memset(_request_buffer.data(), 0, SuspendRequest::PrimarySize);
  auto& _request = *reinterpret_cast<SuspendRequest*>(_request_buffer.data());
  _request.flags = std::move(flags);
  _request_buffer.set_actual(sizeof(SuspendRequest));
  ::fidl::DecodedMessage<SuspendRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      DeviceController::InPlace::Suspend(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
}

DeviceController::UnownedResultOf::Suspend DeviceController::SyncClient::Suspend(::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::Suspend(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(flags), std::move(_response_buffer));
}

DeviceController::UnownedResultOf::Suspend DeviceController::Call::Suspend(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::Suspend(std::move(_client_end), std::move(_request_buffer), std::move(flags), std::move(_response_buffer));
}

::fidl::DecodeResult<DeviceController::SuspendResponse> DeviceController::InPlace::Suspend(zx::unowned_channel _client_end, ::fidl::DecodedMessage<SuspendRequest> params, ::fidl::BytePart response_buffer) {
  params.message()->_hdr = {};
  params.message()->_hdr.ordinal = kDeviceController_Suspend_Ordinal;
  auto _encode_request_result = ::fidl::Encode(std::move(params));
  if (_encode_request_result.status != ZX_OK) {
    return ::fidl::DecodeResult<DeviceController::SuspendResponse>::FromFailure(
        std::move(_encode_request_result));
  }
  auto _call_result = ::fidl::Call<SuspendRequest, SuspendResponse>(
    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
  if (_call_result.status != ZX_OK) {
    return ::fidl::DecodeResult<DeviceController::SuspendResponse>::FromFailure(
        std::move(_call_result));
  }
  return ::fidl::Decode(std::move(_call_result.message));
}

template <>
DeviceController::ResultOf::Resume_Impl<DeviceController::ResumeResponse>::Resume_Impl(zx::unowned_channel _client_end, uint32_t target_system_state) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ResumeRequest, ::fidl::MessageDirection::kSending>();
  ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
  auto& _write_bytes_array = _write_bytes_inlined;
  uint8_t* _write_bytes = _write_bytes_array.view().data();
  memset(_write_bytes, 0, ResumeRequest::PrimarySize);
  auto& _request = *reinterpret_cast<ResumeRequest*>(_write_bytes);
  _request.target_system_state = std::move(target_system_state);
  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ResumeRequest));
  ::fidl::DecodedMessage<ResumeRequest> _decoded_request(std::move(_request_bytes));
  Super::SetResult(
      DeviceController::InPlace::Resume(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
}

DeviceController::ResultOf::Resume DeviceController::SyncClient::Resume(uint32_t target_system_state) {
  return ResultOf::Resume(zx::unowned_channel(this->channel_), std::move(target_system_state));
}

DeviceController::ResultOf::Resume DeviceController::Call::Resume(zx::unowned_channel _client_end, uint32_t target_system_state) {
  return ResultOf::Resume(std::move(_client_end), std::move(target_system_state));
}

template <>
DeviceController::UnownedResultOf::Resume_Impl<DeviceController::ResumeResponse>::Resume_Impl(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t target_system_state, ::fidl::BytePart _response_buffer) {
  if (_request_buffer.capacity() < ResumeRequest::PrimarySize) {
    Super::SetFailure(::fidl::DecodeResult<ResumeResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
    return;
  }
  memset(_request_buffer.data(), 0, ResumeRequest::PrimarySize);
  auto& _request = *reinterpret_cast<ResumeRequest*>(_request_buffer.data());
  _request.target_system_state = std::move(target_system_state);
  _request_buffer.set_actual(sizeof(ResumeRequest));
  ::fidl::DecodedMessage<ResumeRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      DeviceController::InPlace::Resume(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
}

DeviceController::UnownedResultOf::Resume DeviceController::SyncClient::Resume(::fidl::BytePart _request_buffer, uint32_t target_system_state, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::Resume(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(target_system_state), std::move(_response_buffer));
}

DeviceController::UnownedResultOf::Resume DeviceController::Call::Resume(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t target_system_state, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::Resume(std::move(_client_end), std::move(_request_buffer), std::move(target_system_state), std::move(_response_buffer));
}

::fidl::DecodeResult<DeviceController::ResumeResponse> DeviceController::InPlace::Resume(zx::unowned_channel _client_end, ::fidl::DecodedMessage<ResumeRequest> params, ::fidl::BytePart response_buffer) {
  params.message()->_hdr = {};
  params.message()->_hdr.ordinal = kDeviceController_Resume_Ordinal;
  auto _encode_request_result = ::fidl::Encode(std::move(params));
  if (_encode_request_result.status != ZX_OK) {
    return ::fidl::DecodeResult<DeviceController::ResumeResponse>::FromFailure(
        std::move(_encode_request_result));
  }
  auto _call_result = ::fidl::Call<ResumeRequest, ResumeResponse>(
    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
  if (_call_result.status != ZX_OK) {
    return ::fidl::DecodeResult<DeviceController::ResumeResponse>::FromFailure(
        std::move(_call_result));
  }
  return ::fidl::Decode(std::move(_call_result.message));
}


DeviceController::ResultOf::CompleteCompatibilityTests_Impl::CompleteCompatibilityTests_Impl(zx::unowned_channel _client_end, CompatibilityTestStatus status) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CompleteCompatibilityTestsRequest, ::fidl::MessageDirection::kSending>();
  ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
  auto& _write_bytes_array = _write_bytes_inlined;
  uint8_t* _write_bytes = _write_bytes_array.view().data();
  memset(_write_bytes, 0, CompleteCompatibilityTestsRequest::PrimarySize);
  auto& _request = *reinterpret_cast<CompleteCompatibilityTestsRequest*>(_write_bytes);
  _request.status = std::move(status);
  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(CompleteCompatibilityTestsRequest));
  ::fidl::DecodedMessage<CompleteCompatibilityTestsRequest> _decoded_request(std::move(_request_bytes));
  Super::operator=(
      DeviceController::InPlace::CompleteCompatibilityTests(std::move(_client_end), std::move(_decoded_request)));
}

DeviceController::ResultOf::CompleteCompatibilityTests DeviceController::SyncClient::CompleteCompatibilityTests(CompatibilityTestStatus status) {
  return ResultOf::CompleteCompatibilityTests(zx::unowned_channel(this->channel_), std::move(status));
}

DeviceController::ResultOf::CompleteCompatibilityTests DeviceController::Call::CompleteCompatibilityTests(zx::unowned_channel _client_end, CompatibilityTestStatus status) {
  return ResultOf::CompleteCompatibilityTests(std::move(_client_end), std::move(status));
}


DeviceController::UnownedResultOf::CompleteCompatibilityTests_Impl::CompleteCompatibilityTests_Impl(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, CompatibilityTestStatus status) {
  if (_request_buffer.capacity() < CompleteCompatibilityTestsRequest::PrimarySize) {
    Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
    Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
    return;
  }
  memset(_request_buffer.data(), 0, CompleteCompatibilityTestsRequest::PrimarySize);
  auto& _request = *reinterpret_cast<CompleteCompatibilityTestsRequest*>(_request_buffer.data());
  _request.status = std::move(status);
  _request_buffer.set_actual(sizeof(CompleteCompatibilityTestsRequest));
  ::fidl::DecodedMessage<CompleteCompatibilityTestsRequest> _decoded_request(std::move(_request_buffer));
  Super::operator=(
      DeviceController::InPlace::CompleteCompatibilityTests(std::move(_client_end), std::move(_decoded_request)));
}

DeviceController::UnownedResultOf::CompleteCompatibilityTests DeviceController::SyncClient::CompleteCompatibilityTests(::fidl::BytePart _request_buffer, CompatibilityTestStatus status) {
  return UnownedResultOf::CompleteCompatibilityTests(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(status));
}

DeviceController::UnownedResultOf::CompleteCompatibilityTests DeviceController::Call::CompleteCompatibilityTests(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, CompatibilityTestStatus status) {
  return UnownedResultOf::CompleteCompatibilityTests(std::move(_client_end), std::move(_request_buffer), std::move(status));
}

::fidl::internal::StatusAndError DeviceController::InPlace::CompleteCompatibilityTests(zx::unowned_channel _client_end, ::fidl::DecodedMessage<CompleteCompatibilityTestsRequest> params) {
  params.message()->_hdr = {};
  params.message()->_hdr.ordinal = kDeviceController_CompleteCompatibilityTests_Ordinal;
  auto _encode_request_result = ::fidl::Encode(std::move(params));
  if (_encode_request_result.status != ZX_OK) {
    return ::fidl::internal::StatusAndError::FromFailure(
        std::move(_encode_request_result));
  }
  zx_status_t _write_status =
      ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
  if (_write_status != ZX_OK) {
    return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
  } else {
    return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
  }
}


bool DeviceController::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
  if (msg->num_bytes < sizeof(fidl_message_header_t)) {
    zx_handle_close_many(msg->handles, msg->num_handles);
    txn->Close(ZX_ERR_INVALID_ARGS);
    return true;
  }
  fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
  switch (hdr->ordinal) {
    case kDeviceController_BindDriver_Ordinal:
    case kDeviceController_BindDriver_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<BindDriverRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->BindDriver(std::move(message->driver_path), std::move(message->driver),
        Interface::BindDriverCompleter::Sync(txn));
      return true;
    }
    case kDeviceController_ConnectProxy_Ordinal:
    case kDeviceController_ConnectProxy_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<ConnectProxyRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->ConnectProxy(std::move(message->shadow),
        Interface::ConnectProxyCompleter::Sync(txn));
      return true;
    }
    case kDeviceController_Unbind_Ordinal:
    case kDeviceController_Unbind_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<UnbindRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      impl->Unbind(
        Interface::UnbindCompleter::Sync(txn));
      return true;
    }
    case kDeviceController_CompleteRemoval_Ordinal:
    case kDeviceController_CompleteRemoval_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<CompleteRemovalRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      impl->CompleteRemoval(
        Interface::CompleteRemovalCompleter::Sync(txn));
      return true;
    }
    case kDeviceController_RemoveDevice_Ordinal:
    case kDeviceController_RemoveDevice_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<RemoveDeviceRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      impl->RemoveDevice(
        Interface::RemoveDeviceCompleter::Sync(txn));
      return true;
    }
    case kDeviceController_Suspend_Ordinal:
    case kDeviceController_Suspend_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<SuspendRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->Suspend(std::move(message->flags),
        Interface::SuspendCompleter::Sync(txn));
      return true;
    }
    case kDeviceController_Resume_Ordinal:
    case kDeviceController_Resume_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<ResumeRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->Resume(std::move(message->target_system_state),
        Interface::ResumeCompleter::Sync(txn));
      return true;
    }
    case kDeviceController_CompleteCompatibilityTests_Ordinal:
    case kDeviceController_CompleteCompatibilityTests_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<CompleteCompatibilityTestsRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->CompleteCompatibilityTests(std::move(message->status),
        Interface::CompleteCompatibilityTestsCompleter::Sync(txn));
      return true;
    }
    default: {
      return false;
    }
  }
}

bool DeviceController::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
  bool found = TryDispatch(impl, msg, txn);
  if (!found) {
    zx_handle_close_many(msg->handles, msg->num_handles);
    txn->Close(ZX_ERR_NOT_SUPPORTED);
  }
  return found;
}


void DeviceController::Interface::BindDriverCompleterBase::Reply(int32_t status, ::zx::channel test_output) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<BindDriverResponse, ::fidl::MessageDirection::kSending>();
  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
  auto& _response = *reinterpret_cast<BindDriverResponse*>(_write_bytes);
  _response._hdr.ordinal = kDeviceController_BindDriver_Ordinal;
  _response.status = std::move(status);
  _response.test_output = std::move(test_output);
  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(BindDriverResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<BindDriverResponse>(std::move(_response_bytes)));
}

void DeviceController::Interface::BindDriverCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::zx::channel test_output) {
  if (_buffer.capacity() < BindDriverResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  auto& _response = *reinterpret_cast<BindDriverResponse*>(_buffer.data());
  _response._hdr.ordinal = kDeviceController_BindDriver_Ordinal;
  _response.status = std::move(status);
  _response.test_output = std::move(test_output);
  _buffer.set_actual(sizeof(BindDriverResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<BindDriverResponse>(std::move(_buffer)));
}

void DeviceController::Interface::BindDriverCompleterBase::Reply(::fidl::DecodedMessage<BindDriverResponse> params) {
  params.message()->_hdr = {};
  params.message()->_hdr.ordinal = kDeviceController_BindDriver_Ordinal;
  CompleterBase::SendReply(std::move(params));
}


void DeviceController::Interface::SuspendCompleterBase::Reply(int32_t status) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SuspendResponse, ::fidl::MessageDirection::kSending>();
  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
  auto& _response = *reinterpret_cast<SuspendResponse*>(_write_bytes);
  _response._hdr.ordinal = kDeviceController_Suspend_Ordinal;
  _response.status = std::move(status);
  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SuspendResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<SuspendResponse>(std::move(_response_bytes)));
}

void DeviceController::Interface::SuspendCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
  if (_buffer.capacity() < SuspendResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  auto& _response = *reinterpret_cast<SuspendResponse*>(_buffer.data());
  _response._hdr.ordinal = kDeviceController_Suspend_Ordinal;
  _response.status = std::move(status);
  _buffer.set_actual(sizeof(SuspendResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<SuspendResponse>(std::move(_buffer)));
}

void DeviceController::Interface::SuspendCompleterBase::Reply(::fidl::DecodedMessage<SuspendResponse> params) {
  params.message()->_hdr = {};
  params.message()->_hdr.ordinal = kDeviceController_Suspend_Ordinal;
  CompleterBase::SendReply(std::move(params));
}


void DeviceController::Interface::ResumeCompleterBase::Reply(int32_t status) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ResumeResponse, ::fidl::MessageDirection::kSending>();
  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
  auto& _response = *reinterpret_cast<ResumeResponse*>(_write_bytes);
  _response._hdr.ordinal = kDeviceController_Resume_Ordinal;
  _response.status = std::move(status);
  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(ResumeResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<ResumeResponse>(std::move(_response_bytes)));
}

void DeviceController::Interface::ResumeCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
  if (_buffer.capacity() < ResumeResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  auto& _response = *reinterpret_cast<ResumeResponse*>(_buffer.data());
  _response._hdr.ordinal = kDeviceController_Resume_Ordinal;
  _response.status = std::move(status);
  _buffer.set_actual(sizeof(ResumeResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<ResumeResponse>(std::move(_buffer)));
}

void DeviceController::Interface::ResumeCompleterBase::Reply(::fidl::DecodedMessage<ResumeResponse> params) {
  params.message()->_hdr = {};
  params.message()->_hdr.ordinal = kDeviceController_Resume_Ordinal;
  CompleterBase::SendReply(std::move(params));
}


namespace {

[[maybe_unused]]
constexpr uint64_t kCoordinator_AddDevice_Ordinal = 0x4a5e94e200000000lu;
[[maybe_unused]]
constexpr uint64_t kCoordinator_AddDevice_GenOrdinal = 0x2790f5d086adbf8flu;
extern "C" const fidl_type_t fuchsia_device_manager_CoordinatorAddDeviceRequestTable;
extern "C" const fidl_type_t fuchsia_device_manager_CoordinatorAddDeviceResponseTable;
[[maybe_unused]]
constexpr uint64_t kCoordinator_AddDeviceInvisible_Ordinal = 0x6bf4eece00000000lu;
[[maybe_unused]]
constexpr uint64_t kCoordinator_AddDeviceInvisible_GenOrdinal = 0x1c96c2aa95cb3b9blu;
extern "C" const fidl_type_t fuchsia_device_manager_CoordinatorAddDeviceInvisibleRequestTable;
extern "C" const fidl_type_t fuchsia_device_manager_CoordinatorAddDeviceInvisibleResponseTable;
[[maybe_unused]]
constexpr uint64_t kCoordinator_ScheduleRemove_Ordinal = 0x65a3b60600000000lu;
[[maybe_unused]]
constexpr uint64_t kCoordinator_ScheduleRemove_GenOrdinal = 0x1bdeb4d5d1f4d21elu;
extern "C" const fidl_type_t fuchsia_device_manager_CoordinatorScheduleRemoveRequestTable;
[[maybe_unused]]
constexpr uint64_t kCoordinator_ScheduleUnbindChildren_Ordinal = 0x59a4dcaf00000000lu;
[[maybe_unused]]
constexpr uint64_t kCoordinator_ScheduleUnbindChildren_GenOrdinal = 0x658a6d68027b7139lu;
[[maybe_unused]]
constexpr uint64_t kCoordinator_UnbindDone_Ordinal = 0x4503c92800000000lu;
[[maybe_unused]]
constexpr uint64_t kCoordinator_UnbindDone_GenOrdinal = 0x1337d8a6b92e311clu;
extern "C" const fidl_type_t fuchsia_device_manager_CoordinatorUnbindDoneResponseTable;
[[maybe_unused]]
constexpr uint64_t kCoordinator_RemoveDone_Ordinal = 0x2ebb580c00000000lu;
[[maybe_unused]]
constexpr uint64_t kCoordinator_RemoveDone_GenOrdinal = 0x2f805bef0a2a3cf7lu;
extern "C" const fidl_type_t fuchsia_device_manager_CoordinatorRemoveDoneResponseTable;
[[maybe_unused]]
constexpr uint64_t kCoordinator_MakeVisible_Ordinal = 0x52d55e5c00000000lu;
[[maybe_unused]]
constexpr uint64_t kCoordinator_MakeVisible_GenOrdinal = 0x37d4026fe66cf62blu;
extern "C" const fidl_type_t fuchsia_device_manager_CoordinatorMakeVisibleResponseTable;
[[maybe_unused]]
constexpr uint64_t kCoordinator_BindDevice_Ordinal = 0x5012286100000000lu;
[[maybe_unused]]
constexpr uint64_t kCoordinator_BindDevice_GenOrdinal = 0x274db0bd334639calu;
extern "C" const fidl_type_t fuchsia_device_manager_CoordinatorBindDeviceRequestTable;
extern "C" const fidl_type_t fuchsia_device_manager_CoordinatorBindDeviceResponseTable;
[[maybe_unused]]
constexpr uint64_t kCoordinator_GetTopologicalPath_Ordinal = 0x69b2d39100000000lu;
[[maybe_unused]]
constexpr uint64_t kCoordinator_GetTopologicalPath_GenOrdinal = 0x319ccef1252fd6bflu;
extern "C" const fidl_type_t fuchsia_device_manager_CoordinatorGetTopologicalPathResponseTable;
[[maybe_unused]]
constexpr uint64_t kCoordinator_LoadFirmware_Ordinal = 0x7ad6a07500000000lu;
[[maybe_unused]]
constexpr uint64_t kCoordinator_LoadFirmware_GenOrdinal = 0x5c24700e7a9815bdlu;
extern "C" const fidl_type_t fuchsia_device_manager_CoordinatorLoadFirmwareRequestTable;
extern "C" const fidl_type_t fuchsia_device_manager_CoordinatorLoadFirmwareResponseTable;
[[maybe_unused]]
constexpr uint64_t kCoordinator_GetMetadata_Ordinal = 0x2fabb5cd00000000lu;
[[maybe_unused]]
constexpr uint64_t kCoordinator_GetMetadata_GenOrdinal = 0x34abe1351145bf3flu;
extern "C" const fidl_type_t fuchsia_device_manager_CoordinatorGetMetadataRequestTable;
extern "C" const fidl_type_t fuchsia_device_manager_CoordinatorGetMetadataResponseTable;
[[maybe_unused]]
constexpr uint64_t kCoordinator_GetMetadataSize_Ordinal = 0x313e071100000000lu;
[[maybe_unused]]
constexpr uint64_t kCoordinator_GetMetadataSize_GenOrdinal = 0x290826b5b7483d61lu;
extern "C" const fidl_type_t fuchsia_device_manager_CoordinatorGetMetadataSizeRequestTable;
extern "C" const fidl_type_t fuchsia_device_manager_CoordinatorGetMetadataSizeResponseTable;
[[maybe_unused]]
constexpr uint64_t kCoordinator_AddMetadata_Ordinal = 0x31ea228600000000lu;
[[maybe_unused]]
constexpr uint64_t kCoordinator_AddMetadata_GenOrdinal = 0x7acb84ea4eb23c94lu;
extern "C" const fidl_type_t fuchsia_device_manager_CoordinatorAddMetadataRequestTable;
extern "C" const fidl_type_t fuchsia_device_manager_CoordinatorAddMetadataResponseTable;
[[maybe_unused]]
constexpr uint64_t kCoordinator_PublishMetadata_Ordinal = 0x1ad94f5300000000lu;
[[maybe_unused]]
constexpr uint64_t kCoordinator_PublishMetadata_GenOrdinal = 0x3355f89ab7bf7c65lu;
extern "C" const fidl_type_t fuchsia_device_manager_CoordinatorPublishMetadataRequestTable;
extern "C" const fidl_type_t fuchsia_device_manager_CoordinatorPublishMetadataResponseTable;
[[maybe_unused]]
constexpr uint64_t kCoordinator_AddCompositeDevice_Ordinal = 0x4838d35600000000lu;
[[maybe_unused]]
constexpr uint64_t kCoordinator_AddCompositeDevice_GenOrdinal = 0x1610b2d89769d054lu;
extern "C" const fidl_type_t fuchsia_device_manager_CoordinatorAddCompositeDeviceRequestTable;
extern "C" const fidl_type_t fuchsia_device_manager_CoordinatorAddCompositeDeviceResponseTable;
[[maybe_unused]]
constexpr uint64_t kCoordinator_DirectoryWatch_Ordinal = 0x2a37159400000000lu;
[[maybe_unused]]
constexpr uint64_t kCoordinator_DirectoryWatch_GenOrdinal = 0x4299b4cc9acc68e4lu;
extern "C" const fidl_type_t fuchsia_device_manager_CoordinatorDirectoryWatchRequestTable;
extern "C" const fidl_type_t fuchsia_device_manager_CoordinatorDirectoryWatchResponseTable;
[[maybe_unused]]
constexpr uint64_t kCoordinator_RunCompatibilityTests_Ordinal = 0x167858fb00000000lu;
[[maybe_unused]]
constexpr uint64_t kCoordinator_RunCompatibilityTests_GenOrdinal = 0x634a2580075931b2lu;
extern "C" const fidl_type_t fuchsia_device_manager_CoordinatorRunCompatibilityTestsResponseTable;

}  // namespace
template <>
Coordinator::ResultOf::AddDevice_Impl<Coordinator::AddDeviceResponse>::AddDevice_Impl(zx::unowned_channel _client_end, ::zx::channel rpc, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, AddDeviceConfig device_add_config, ::zx::channel client_remote) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<AddDeviceRequest, ::fidl::MessageDirection::kSending>();
  std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
  auto& _write_bytes_array = *_write_bytes_boxed;
  AddDeviceRequest _request = {};
  _request.rpc = std::move(rpc);
  _request.props = std::move(props);
  _request.name = std::move(name);
  _request.protocol_id = std::move(protocol_id);
  _request.driver_path = std::move(driver_path);
  _request.args = std::move(args);
  _request.device_add_config = std::move(device_add_config);
  _request.client_remote = std::move(client_remote);
  auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
  if (_linearize_result.status != ZX_OK) {
    Super::SetFailure(std::move(_linearize_result));
    return;
  }
  ::fidl::DecodedMessage<AddDeviceRequest> _decoded_request = std::move(_linearize_result.message);
  Super::SetResult(
      Coordinator::InPlace::AddDevice(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
}

Coordinator::ResultOf::AddDevice Coordinator::SyncClient::AddDevice(::zx::channel rpc, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, AddDeviceConfig device_add_config, ::zx::channel client_remote) {
  return ResultOf::AddDevice(zx::unowned_channel(this->channel_), std::move(rpc), std::move(props), std::move(name), std::move(protocol_id), std::move(driver_path), std::move(args), std::move(device_add_config), std::move(client_remote));
}

Coordinator::ResultOf::AddDevice Coordinator::Call::AddDevice(zx::unowned_channel _client_end, ::zx::channel rpc, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, AddDeviceConfig device_add_config, ::zx::channel client_remote) {
  return ResultOf::AddDevice(std::move(_client_end), std::move(rpc), std::move(props), std::move(name), std::move(protocol_id), std::move(driver_path), std::move(args), std::move(device_add_config), std::move(client_remote));
}

template <>
Coordinator::UnownedResultOf::AddDevice_Impl<Coordinator::AddDeviceResponse>::AddDevice_Impl(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel rpc, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, AddDeviceConfig device_add_config, ::zx::channel client_remote, ::fidl::BytePart _response_buffer) {
  if (_request_buffer.capacity() < AddDeviceRequest::PrimarySize) {
    Super::SetFailure(::fidl::DecodeResult<AddDeviceResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
    return;
  }
  AddDeviceRequest _request = {};
  _request.rpc = std::move(rpc);
  _request.props = std::move(props);
  _request.name = std::move(name);
  _request.protocol_id = std::move(protocol_id);
  _request.driver_path = std::move(driver_path);
  _request.args = std::move(args);
  _request.device_add_config = std::move(device_add_config);
  _request.client_remote = std::move(client_remote);
  auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
  if (_linearize_result.status != ZX_OK) {
    Super::SetFailure(std::move(_linearize_result));
    return;
  }
  ::fidl::DecodedMessage<AddDeviceRequest> _decoded_request = std::move(_linearize_result.message);
  Super::SetResult(
      Coordinator::InPlace::AddDevice(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
}

Coordinator::UnownedResultOf::AddDevice Coordinator::SyncClient::AddDevice(::fidl::BytePart _request_buffer, ::zx::channel rpc, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, AddDeviceConfig device_add_config, ::zx::channel client_remote, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::AddDevice(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(rpc), std::move(props), std::move(name), std::move(protocol_id), std::move(driver_path), std::move(args), std::move(device_add_config), std::move(client_remote), std::move(_response_buffer));
}

Coordinator::UnownedResultOf::AddDevice Coordinator::Call::AddDevice(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel rpc, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, AddDeviceConfig device_add_config, ::zx::channel client_remote, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::AddDevice(std::move(_client_end), std::move(_request_buffer), std::move(rpc), std::move(props), std::move(name), std::move(protocol_id), std::move(driver_path), std::move(args), std::move(device_add_config), std::move(client_remote), std::move(_response_buffer));
}

::fidl::DecodeResult<Coordinator::AddDeviceResponse> Coordinator::InPlace::AddDevice(zx::unowned_channel _client_end, ::fidl::DecodedMessage<AddDeviceRequest> params, ::fidl::BytePart response_buffer) {
  params.message()->_hdr = {};
  params.message()->_hdr.ordinal = kCoordinator_AddDevice_Ordinal;
  auto _encode_request_result = ::fidl::Encode(std::move(params));
  if (_encode_request_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Coordinator::AddDeviceResponse>::FromFailure(
        std::move(_encode_request_result));
  }
  auto _call_result = ::fidl::Call<AddDeviceRequest, AddDeviceResponse>(
    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
  if (_call_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Coordinator::AddDeviceResponse>::FromFailure(
        std::move(_call_result));
  }
  return ::fidl::Decode(std::move(_call_result.message));
}

template <>
Coordinator::ResultOf::AddDeviceInvisible_Impl<Coordinator::AddDeviceInvisibleResponse>::AddDeviceInvisible_Impl(zx::unowned_channel _client_end, ::zx::channel rpc, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, ::zx::channel client_remote) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<AddDeviceInvisibleRequest, ::fidl::MessageDirection::kSending>();
  std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
  auto& _write_bytes_array = *_write_bytes_boxed;
  AddDeviceInvisibleRequest _request = {};
  _request.rpc = std::move(rpc);
  _request.props = std::move(props);
  _request.name = std::move(name);
  _request.protocol_id = std::move(protocol_id);
  _request.driver_path = std::move(driver_path);
  _request.args = std::move(args);
  _request.client_remote = std::move(client_remote);
  auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
  if (_linearize_result.status != ZX_OK) {
    Super::SetFailure(std::move(_linearize_result));
    return;
  }
  ::fidl::DecodedMessage<AddDeviceInvisibleRequest> _decoded_request = std::move(_linearize_result.message);
  Super::SetResult(
      Coordinator::InPlace::AddDeviceInvisible(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
}

Coordinator::ResultOf::AddDeviceInvisible Coordinator::SyncClient::AddDeviceInvisible(::zx::channel rpc, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, ::zx::channel client_remote) {
  return ResultOf::AddDeviceInvisible(zx::unowned_channel(this->channel_), std::move(rpc), std::move(props), std::move(name), std::move(protocol_id), std::move(driver_path), std::move(args), std::move(client_remote));
}

Coordinator::ResultOf::AddDeviceInvisible Coordinator::Call::AddDeviceInvisible(zx::unowned_channel _client_end, ::zx::channel rpc, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, ::zx::channel client_remote) {
  return ResultOf::AddDeviceInvisible(std::move(_client_end), std::move(rpc), std::move(props), std::move(name), std::move(protocol_id), std::move(driver_path), std::move(args), std::move(client_remote));
}

template <>
Coordinator::UnownedResultOf::AddDeviceInvisible_Impl<Coordinator::AddDeviceInvisibleResponse>::AddDeviceInvisible_Impl(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel rpc, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, ::zx::channel client_remote, ::fidl::BytePart _response_buffer) {
  if (_request_buffer.capacity() < AddDeviceInvisibleRequest::PrimarySize) {
    Super::SetFailure(::fidl::DecodeResult<AddDeviceInvisibleResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
    return;
  }
  AddDeviceInvisibleRequest _request = {};
  _request.rpc = std::move(rpc);
  _request.props = std::move(props);
  _request.name = std::move(name);
  _request.protocol_id = std::move(protocol_id);
  _request.driver_path = std::move(driver_path);
  _request.args = std::move(args);
  _request.client_remote = std::move(client_remote);
  auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
  if (_linearize_result.status != ZX_OK) {
    Super::SetFailure(std::move(_linearize_result));
    return;
  }
  ::fidl::DecodedMessage<AddDeviceInvisibleRequest> _decoded_request = std::move(_linearize_result.message);
  Super::SetResult(
      Coordinator::InPlace::AddDeviceInvisible(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
}

Coordinator::UnownedResultOf::AddDeviceInvisible Coordinator::SyncClient::AddDeviceInvisible(::fidl::BytePart _request_buffer, ::zx::channel rpc, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, ::zx::channel client_remote, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::AddDeviceInvisible(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(rpc), std::move(props), std::move(name), std::move(protocol_id), std::move(driver_path), std::move(args), std::move(client_remote), std::move(_response_buffer));
}

Coordinator::UnownedResultOf::AddDeviceInvisible Coordinator::Call::AddDeviceInvisible(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel rpc, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, ::zx::channel client_remote, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::AddDeviceInvisible(std::move(_client_end), std::move(_request_buffer), std::move(rpc), std::move(props), std::move(name), std::move(protocol_id), std::move(driver_path), std::move(args), std::move(client_remote), std::move(_response_buffer));
}

::fidl::DecodeResult<Coordinator::AddDeviceInvisibleResponse> Coordinator::InPlace::AddDeviceInvisible(zx::unowned_channel _client_end, ::fidl::DecodedMessage<AddDeviceInvisibleRequest> params, ::fidl::BytePart response_buffer) {
  params.message()->_hdr = {};
  params.message()->_hdr.ordinal = kCoordinator_AddDeviceInvisible_Ordinal;
  auto _encode_request_result = ::fidl::Encode(std::move(params));
  if (_encode_request_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Coordinator::AddDeviceInvisibleResponse>::FromFailure(
        std::move(_encode_request_result));
  }
  auto _call_result = ::fidl::Call<AddDeviceInvisibleRequest, AddDeviceInvisibleResponse>(
    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
  if (_call_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Coordinator::AddDeviceInvisibleResponse>::FromFailure(
        std::move(_call_result));
  }
  return ::fidl::Decode(std::move(_call_result.message));
}


Coordinator::ResultOf::ScheduleRemove_Impl::ScheduleRemove_Impl(zx::unowned_channel _client_end, bool unbind_self) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ScheduleRemoveRequest, ::fidl::MessageDirection::kSending>();
  ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
  auto& _write_bytes_array = _write_bytes_inlined;
  uint8_t* _write_bytes = _write_bytes_array.view().data();
  memset(_write_bytes, 0, ScheduleRemoveRequest::PrimarySize);
  auto& _request = *reinterpret_cast<ScheduleRemoveRequest*>(_write_bytes);
  _request.unbind_self = std::move(unbind_self);
  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ScheduleRemoveRequest));
  ::fidl::DecodedMessage<ScheduleRemoveRequest> _decoded_request(std::move(_request_bytes));
  Super::operator=(
      Coordinator::InPlace::ScheduleRemove(std::move(_client_end), std::move(_decoded_request)));
}

Coordinator::ResultOf::ScheduleRemove Coordinator::SyncClient::ScheduleRemove(bool unbind_self) {
  return ResultOf::ScheduleRemove(zx::unowned_channel(this->channel_), std::move(unbind_self));
}

Coordinator::ResultOf::ScheduleRemove Coordinator::Call::ScheduleRemove(zx::unowned_channel _client_end, bool unbind_self) {
  return ResultOf::ScheduleRemove(std::move(_client_end), std::move(unbind_self));
}


Coordinator::UnownedResultOf::ScheduleRemove_Impl::ScheduleRemove_Impl(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool unbind_self) {
  if (_request_buffer.capacity() < ScheduleRemoveRequest::PrimarySize) {
    Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
    Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
    return;
  }
  memset(_request_buffer.data(), 0, ScheduleRemoveRequest::PrimarySize);
  auto& _request = *reinterpret_cast<ScheduleRemoveRequest*>(_request_buffer.data());
  _request.unbind_self = std::move(unbind_self);
  _request_buffer.set_actual(sizeof(ScheduleRemoveRequest));
  ::fidl::DecodedMessage<ScheduleRemoveRequest> _decoded_request(std::move(_request_buffer));
  Super::operator=(
      Coordinator::InPlace::ScheduleRemove(std::move(_client_end), std::move(_decoded_request)));
}

Coordinator::UnownedResultOf::ScheduleRemove Coordinator::SyncClient::ScheduleRemove(::fidl::BytePart _request_buffer, bool unbind_self) {
  return UnownedResultOf::ScheduleRemove(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(unbind_self));
}

Coordinator::UnownedResultOf::ScheduleRemove Coordinator::Call::ScheduleRemove(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool unbind_self) {
  return UnownedResultOf::ScheduleRemove(std::move(_client_end), std::move(_request_buffer), std::move(unbind_self));
}

::fidl::internal::StatusAndError Coordinator::InPlace::ScheduleRemove(zx::unowned_channel _client_end, ::fidl::DecodedMessage<ScheduleRemoveRequest> params) {
  params.message()->_hdr = {};
  params.message()->_hdr.ordinal = kCoordinator_ScheduleRemove_Ordinal;
  auto _encode_request_result = ::fidl::Encode(std::move(params));
  if (_encode_request_result.status != ZX_OK) {
    return ::fidl::internal::StatusAndError::FromFailure(
        std::move(_encode_request_result));
  }
  zx_status_t _write_status =
      ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
  if (_write_status != ZX_OK) {
    return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
  } else {
    return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
  }
}


Coordinator::ResultOf::ScheduleUnbindChildren_Impl::ScheduleUnbindChildren_Impl(zx::unowned_channel _client_end) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ScheduleUnbindChildrenRequest, ::fidl::MessageDirection::kSending>();
  ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
  auto& _write_bytes_array = _write_bytes_inlined;
  uint8_t* _write_bytes = _write_bytes_array.view().data();
  memset(_write_bytes, 0, ScheduleUnbindChildrenRequest::PrimarySize);
  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ScheduleUnbindChildrenRequest));
  ::fidl::DecodedMessage<ScheduleUnbindChildrenRequest> _decoded_request(std::move(_request_bytes));
  Super::operator=(
      Coordinator::InPlace::ScheduleUnbindChildren(std::move(_client_end)));
}

Coordinator::ResultOf::ScheduleUnbindChildren Coordinator::SyncClient::ScheduleUnbindChildren() {
  return ResultOf::ScheduleUnbindChildren(zx::unowned_channel(this->channel_));
}

Coordinator::ResultOf::ScheduleUnbindChildren Coordinator::Call::ScheduleUnbindChildren(zx::unowned_channel _client_end) {
  return ResultOf::ScheduleUnbindChildren(std::move(_client_end));
}

::fidl::internal::StatusAndError Coordinator::InPlace::ScheduleUnbindChildren(zx::unowned_channel _client_end) {
  constexpr uint32_t _write_num_bytes = sizeof(ScheduleUnbindChildrenRequest);
  ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
  ::fidl::BytePart _request_buffer = _write_bytes.view();
  _request_buffer.set_actual(_write_num_bytes);
  ::fidl::DecodedMessage<ScheduleUnbindChildrenRequest> params(std::move(_request_buffer));
  params.message()->_hdr = {};
  params.message()->_hdr.ordinal = kCoordinator_ScheduleUnbindChildren_Ordinal;
  auto _encode_request_result = ::fidl::Encode(std::move(params));
  if (_encode_request_result.status != ZX_OK) {
    return ::fidl::internal::StatusAndError::FromFailure(
        std::move(_encode_request_result));
  }
  zx_status_t _write_status =
      ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
  if (_write_status != ZX_OK) {
    return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
  } else {
    return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
  }
}

template <>
Coordinator::ResultOf::UnbindDone_Impl<Coordinator::UnbindDoneResponse>::UnbindDone_Impl(zx::unowned_channel _client_end) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<UnbindDoneRequest, ::fidl::MessageDirection::kSending>();
  ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
  auto& _write_bytes_array = _write_bytes_inlined;
  uint8_t* _write_bytes = _write_bytes_array.view().data();
  memset(_write_bytes, 0, UnbindDoneRequest::PrimarySize);
  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(UnbindDoneRequest));
  ::fidl::DecodedMessage<UnbindDoneRequest> _decoded_request(std::move(_request_bytes));
  Super::SetResult(
      Coordinator::InPlace::UnbindDone(std::move(_client_end), Super::response_buffer()));
}

Coordinator::ResultOf::UnbindDone Coordinator::SyncClient::UnbindDone() {
  return ResultOf::UnbindDone(zx::unowned_channel(this->channel_));
}

Coordinator::ResultOf::UnbindDone Coordinator::Call::UnbindDone(zx::unowned_channel _client_end) {
  return ResultOf::UnbindDone(std::move(_client_end));
}

template <>
Coordinator::UnownedResultOf::UnbindDone_Impl<Coordinator::UnbindDoneResponse>::UnbindDone_Impl(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(UnbindDoneRequest)] = {};
  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
  memset(_request_buffer.data(), 0, UnbindDoneRequest::PrimarySize);
  _request_buffer.set_actual(sizeof(UnbindDoneRequest));
  ::fidl::DecodedMessage<UnbindDoneRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      Coordinator::InPlace::UnbindDone(std::move(_client_end), std::move(_response_buffer)));
}

Coordinator::UnownedResultOf::UnbindDone Coordinator::SyncClient::UnbindDone(::fidl::BytePart _response_buffer) {
  return UnownedResultOf::UnbindDone(zx::unowned_channel(this->channel_), std::move(_response_buffer));
}

Coordinator::UnownedResultOf::UnbindDone Coordinator::Call::UnbindDone(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::UnbindDone(std::move(_client_end), std::move(_response_buffer));
}

::fidl::DecodeResult<Coordinator::UnbindDoneResponse> Coordinator::InPlace::UnbindDone(zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
  constexpr uint32_t _write_num_bytes = sizeof(UnbindDoneRequest);
  ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
  ::fidl::BytePart _request_buffer = _write_bytes.view();
  _request_buffer.set_actual(_write_num_bytes);
  ::fidl::DecodedMessage<UnbindDoneRequest> params(std::move(_request_buffer));
  params.message()->_hdr = {};
  params.message()->_hdr.ordinal = kCoordinator_UnbindDone_Ordinal;
  auto _encode_request_result = ::fidl::Encode(std::move(params));
  if (_encode_request_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Coordinator::UnbindDoneResponse>::FromFailure(
        std::move(_encode_request_result));
  }
  auto _call_result = ::fidl::Call<UnbindDoneRequest, UnbindDoneResponse>(
    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
  if (_call_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Coordinator::UnbindDoneResponse>::FromFailure(
        std::move(_call_result));
  }
  return ::fidl::Decode(std::move(_call_result.message));
}

template <>
Coordinator::ResultOf::RemoveDone_Impl<Coordinator::RemoveDoneResponse>::RemoveDone_Impl(zx::unowned_channel _client_end) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RemoveDoneRequest, ::fidl::MessageDirection::kSending>();
  ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
  auto& _write_bytes_array = _write_bytes_inlined;
  uint8_t* _write_bytes = _write_bytes_array.view().data();
  memset(_write_bytes, 0, RemoveDoneRequest::PrimarySize);
  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(RemoveDoneRequest));
  ::fidl::DecodedMessage<RemoveDoneRequest> _decoded_request(std::move(_request_bytes));
  Super::SetResult(
      Coordinator::InPlace::RemoveDone(std::move(_client_end), Super::response_buffer()));
}

Coordinator::ResultOf::RemoveDone Coordinator::SyncClient::RemoveDone() {
  return ResultOf::RemoveDone(zx::unowned_channel(this->channel_));
}

Coordinator::ResultOf::RemoveDone Coordinator::Call::RemoveDone(zx::unowned_channel _client_end) {
  return ResultOf::RemoveDone(std::move(_client_end));
}

template <>
Coordinator::UnownedResultOf::RemoveDone_Impl<Coordinator::RemoveDoneResponse>::RemoveDone_Impl(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(RemoveDoneRequest)] = {};
  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
  memset(_request_buffer.data(), 0, RemoveDoneRequest::PrimarySize);
  _request_buffer.set_actual(sizeof(RemoveDoneRequest));
  ::fidl::DecodedMessage<RemoveDoneRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      Coordinator::InPlace::RemoveDone(std::move(_client_end), std::move(_response_buffer)));
}

Coordinator::UnownedResultOf::RemoveDone Coordinator::SyncClient::RemoveDone(::fidl::BytePart _response_buffer) {
  return UnownedResultOf::RemoveDone(zx::unowned_channel(this->channel_), std::move(_response_buffer));
}

Coordinator::UnownedResultOf::RemoveDone Coordinator::Call::RemoveDone(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::RemoveDone(std::move(_client_end), std::move(_response_buffer));
}

::fidl::DecodeResult<Coordinator::RemoveDoneResponse> Coordinator::InPlace::RemoveDone(zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
  constexpr uint32_t _write_num_bytes = sizeof(RemoveDoneRequest);
  ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
  ::fidl::BytePart _request_buffer = _write_bytes.view();
  _request_buffer.set_actual(_write_num_bytes);
  ::fidl::DecodedMessage<RemoveDoneRequest> params(std::move(_request_buffer));
  params.message()->_hdr = {};
  params.message()->_hdr.ordinal = kCoordinator_RemoveDone_Ordinal;
  auto _encode_request_result = ::fidl::Encode(std::move(params));
  if (_encode_request_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Coordinator::RemoveDoneResponse>::FromFailure(
        std::move(_encode_request_result));
  }
  auto _call_result = ::fidl::Call<RemoveDoneRequest, RemoveDoneResponse>(
    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
  if (_call_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Coordinator::RemoveDoneResponse>::FromFailure(
        std::move(_call_result));
  }
  return ::fidl::Decode(std::move(_call_result.message));
}

template <>
Coordinator::ResultOf::MakeVisible_Impl<Coordinator::MakeVisibleResponse>::MakeVisible_Impl(zx::unowned_channel _client_end) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<MakeVisibleRequest, ::fidl::MessageDirection::kSending>();
  ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
  auto& _write_bytes_array = _write_bytes_inlined;
  uint8_t* _write_bytes = _write_bytes_array.view().data();
  memset(_write_bytes, 0, MakeVisibleRequest::PrimarySize);
  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(MakeVisibleRequest));
  ::fidl::DecodedMessage<MakeVisibleRequest> _decoded_request(std::move(_request_bytes));
  Super::SetResult(
      Coordinator::InPlace::MakeVisible(std::move(_client_end), Super::response_buffer()));
}

Coordinator::ResultOf::MakeVisible Coordinator::SyncClient::MakeVisible() {
  return ResultOf::MakeVisible(zx::unowned_channel(this->channel_));
}

Coordinator::ResultOf::MakeVisible Coordinator::Call::MakeVisible(zx::unowned_channel _client_end) {
  return ResultOf::MakeVisible(std::move(_client_end));
}

template <>
Coordinator::UnownedResultOf::MakeVisible_Impl<Coordinator::MakeVisibleResponse>::MakeVisible_Impl(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(MakeVisibleRequest)] = {};
  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
  memset(_request_buffer.data(), 0, MakeVisibleRequest::PrimarySize);
  _request_buffer.set_actual(sizeof(MakeVisibleRequest));
  ::fidl::DecodedMessage<MakeVisibleRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      Coordinator::InPlace::MakeVisible(std::move(_client_end), std::move(_response_buffer)));
}

Coordinator::UnownedResultOf::MakeVisible Coordinator::SyncClient::MakeVisible(::fidl::BytePart _response_buffer) {
  return UnownedResultOf::MakeVisible(zx::unowned_channel(this->channel_), std::move(_response_buffer));
}

Coordinator::UnownedResultOf::MakeVisible Coordinator::Call::MakeVisible(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::MakeVisible(std::move(_client_end), std::move(_response_buffer));
}

::fidl::DecodeResult<Coordinator::MakeVisibleResponse> Coordinator::InPlace::MakeVisible(zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
  constexpr uint32_t _write_num_bytes = sizeof(MakeVisibleRequest);
  ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
  ::fidl::BytePart _request_buffer = _write_bytes.view();
  _request_buffer.set_actual(_write_num_bytes);
  ::fidl::DecodedMessage<MakeVisibleRequest> params(std::move(_request_buffer));
  params.message()->_hdr = {};
  params.message()->_hdr.ordinal = kCoordinator_MakeVisible_Ordinal;
  auto _encode_request_result = ::fidl::Encode(std::move(params));
  if (_encode_request_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Coordinator::MakeVisibleResponse>::FromFailure(
        std::move(_encode_request_result));
  }
  auto _call_result = ::fidl::Call<MakeVisibleRequest, MakeVisibleResponse>(
    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
  if (_call_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Coordinator::MakeVisibleResponse>::FromFailure(
        std::move(_call_result));
  }
  return ::fidl::Decode(std::move(_call_result.message));
}

template <>
Coordinator::ResultOf::BindDevice_Impl<Coordinator::BindDeviceResponse>::BindDevice_Impl(zx::unowned_channel _client_end, ::fidl::StringView driver_path) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<BindDeviceRequest, ::fidl::MessageDirection::kSending>();
  std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
  auto& _write_bytes_array = *_write_bytes_boxed;
  BindDeviceRequest _request = {};
  _request.driver_path = std::move(driver_path);
  auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
  if (_linearize_result.status != ZX_OK) {
    Super::SetFailure(std::move(_linearize_result));
    return;
  }
  ::fidl::DecodedMessage<BindDeviceRequest> _decoded_request = std::move(_linearize_result.message);
  Super::SetResult(
      Coordinator::InPlace::BindDevice(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
}

Coordinator::ResultOf::BindDevice Coordinator::SyncClient::BindDevice(::fidl::StringView driver_path) {
  return ResultOf::BindDevice(zx::unowned_channel(this->channel_), std::move(driver_path));
}

Coordinator::ResultOf::BindDevice Coordinator::Call::BindDevice(zx::unowned_channel _client_end, ::fidl::StringView driver_path) {
  return ResultOf::BindDevice(std::move(_client_end), std::move(driver_path));
}

template <>
Coordinator::UnownedResultOf::BindDevice_Impl<Coordinator::BindDeviceResponse>::BindDevice_Impl(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView driver_path, ::fidl::BytePart _response_buffer) {
  if (_request_buffer.capacity() < BindDeviceRequest::PrimarySize) {
    Super::SetFailure(::fidl::DecodeResult<BindDeviceResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
    return;
  }
  BindDeviceRequest _request = {};
  _request.driver_path = std::move(driver_path);
  auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
  if (_linearize_result.status != ZX_OK) {
    Super::SetFailure(std::move(_linearize_result));
    return;
  }
  ::fidl::DecodedMessage<BindDeviceRequest> _decoded_request = std::move(_linearize_result.message);
  Super::SetResult(
      Coordinator::InPlace::BindDevice(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
}

Coordinator::UnownedResultOf::BindDevice Coordinator::SyncClient::BindDevice(::fidl::BytePart _request_buffer, ::fidl::StringView driver_path, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::BindDevice(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(driver_path), std::move(_response_buffer));
}

Coordinator::UnownedResultOf::BindDevice Coordinator::Call::BindDevice(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView driver_path, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::BindDevice(std::move(_client_end), std::move(_request_buffer), std::move(driver_path), std::move(_response_buffer));
}

::fidl::DecodeResult<Coordinator::BindDeviceResponse> Coordinator::InPlace::BindDevice(zx::unowned_channel _client_end, ::fidl::DecodedMessage<BindDeviceRequest> params, ::fidl::BytePart response_buffer) {
  params.message()->_hdr = {};
  params.message()->_hdr.ordinal = kCoordinator_BindDevice_Ordinal;
  auto _encode_request_result = ::fidl::Encode(std::move(params));
  if (_encode_request_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Coordinator::BindDeviceResponse>::FromFailure(
        std::move(_encode_request_result));
  }
  auto _call_result = ::fidl::Call<BindDeviceRequest, BindDeviceResponse>(
    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
  if (_call_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Coordinator::BindDeviceResponse>::FromFailure(
        std::move(_call_result));
  }
  return ::fidl::Decode(std::move(_call_result.message));
}

template <>
Coordinator::ResultOf::GetTopologicalPath_Impl<Coordinator::GetTopologicalPathResponse>::GetTopologicalPath_Impl(zx::unowned_channel _client_end) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetTopologicalPathRequest, ::fidl::MessageDirection::kSending>();
  ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
  auto& _write_bytes_array = _write_bytes_inlined;
  uint8_t* _write_bytes = _write_bytes_array.view().data();
  memset(_write_bytes, 0, GetTopologicalPathRequest::PrimarySize);
  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetTopologicalPathRequest));
  ::fidl::DecodedMessage<GetTopologicalPathRequest> _decoded_request(std::move(_request_bytes));
  Super::SetResult(
      Coordinator::InPlace::GetTopologicalPath(std::move(_client_end), Super::response_buffer()));
}

Coordinator::ResultOf::GetTopologicalPath Coordinator::SyncClient::GetTopologicalPath() {
  return ResultOf::GetTopologicalPath(zx::unowned_channel(this->channel_));
}

Coordinator::ResultOf::GetTopologicalPath Coordinator::Call::GetTopologicalPath(zx::unowned_channel _client_end) {
  return ResultOf::GetTopologicalPath(std::move(_client_end));
}

template <>
Coordinator::UnownedResultOf::GetTopologicalPath_Impl<Coordinator::GetTopologicalPathResponse>::GetTopologicalPath_Impl(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetTopologicalPathRequest)] = {};
  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
  memset(_request_buffer.data(), 0, GetTopologicalPathRequest::PrimarySize);
  _request_buffer.set_actual(sizeof(GetTopologicalPathRequest));
  ::fidl::DecodedMessage<GetTopologicalPathRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      Coordinator::InPlace::GetTopologicalPath(std::move(_client_end), std::move(_response_buffer)));
}

Coordinator::UnownedResultOf::GetTopologicalPath Coordinator::SyncClient::GetTopologicalPath(::fidl::BytePart _response_buffer) {
  return UnownedResultOf::GetTopologicalPath(zx::unowned_channel(this->channel_), std::move(_response_buffer));
}

Coordinator::UnownedResultOf::GetTopologicalPath Coordinator::Call::GetTopologicalPath(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::GetTopologicalPath(std::move(_client_end), std::move(_response_buffer));
}

::fidl::DecodeResult<Coordinator::GetTopologicalPathResponse> Coordinator::InPlace::GetTopologicalPath(zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
  constexpr uint32_t _write_num_bytes = sizeof(GetTopologicalPathRequest);
  ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
  ::fidl::BytePart _request_buffer = _write_bytes.view();
  _request_buffer.set_actual(_write_num_bytes);
  ::fidl::DecodedMessage<GetTopologicalPathRequest> params(std::move(_request_buffer));
  params.message()->_hdr = {};
  params.message()->_hdr.ordinal = kCoordinator_GetTopologicalPath_Ordinal;
  auto _encode_request_result = ::fidl::Encode(std::move(params));
  if (_encode_request_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Coordinator::GetTopologicalPathResponse>::FromFailure(
        std::move(_encode_request_result));
  }
  auto _call_result = ::fidl::Call<GetTopologicalPathRequest, GetTopologicalPathResponse>(
    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
  if (_call_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Coordinator::GetTopologicalPathResponse>::FromFailure(
        std::move(_call_result));
  }
  return ::fidl::Decode(std::move(_call_result.message));
}

template <>
Coordinator::ResultOf::LoadFirmware_Impl<Coordinator::LoadFirmwareResponse>::LoadFirmware_Impl(zx::unowned_channel _client_end, ::fidl::StringView fw_path) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LoadFirmwareRequest, ::fidl::MessageDirection::kSending>();
  std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
  auto& _write_bytes_array = *_write_bytes_boxed;
  LoadFirmwareRequest _request = {};
  _request.fw_path = std::move(fw_path);
  auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
  if (_linearize_result.status != ZX_OK) {
    Super::SetFailure(std::move(_linearize_result));
    return;
  }
  ::fidl::DecodedMessage<LoadFirmwareRequest> _decoded_request = std::move(_linearize_result.message);
  Super::SetResult(
      Coordinator::InPlace::LoadFirmware(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
}

Coordinator::ResultOf::LoadFirmware Coordinator::SyncClient::LoadFirmware(::fidl::StringView fw_path) {
  return ResultOf::LoadFirmware(zx::unowned_channel(this->channel_), std::move(fw_path));
}

Coordinator::ResultOf::LoadFirmware Coordinator::Call::LoadFirmware(zx::unowned_channel _client_end, ::fidl::StringView fw_path) {
  return ResultOf::LoadFirmware(std::move(_client_end), std::move(fw_path));
}

template <>
Coordinator::UnownedResultOf::LoadFirmware_Impl<Coordinator::LoadFirmwareResponse>::LoadFirmware_Impl(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView fw_path, ::fidl::BytePart _response_buffer) {
  if (_request_buffer.capacity() < LoadFirmwareRequest::PrimarySize) {
    Super::SetFailure(::fidl::DecodeResult<LoadFirmwareResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
    return;
  }
  LoadFirmwareRequest _request = {};
  _request.fw_path = std::move(fw_path);
  auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
  if (_linearize_result.status != ZX_OK) {
    Super::SetFailure(std::move(_linearize_result));
    return;
  }
  ::fidl::DecodedMessage<LoadFirmwareRequest> _decoded_request = std::move(_linearize_result.message);
  Super::SetResult(
      Coordinator::InPlace::LoadFirmware(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
}

Coordinator::UnownedResultOf::LoadFirmware Coordinator::SyncClient::LoadFirmware(::fidl::BytePart _request_buffer, ::fidl::StringView fw_path, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::LoadFirmware(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(fw_path), std::move(_response_buffer));
}

Coordinator::UnownedResultOf::LoadFirmware Coordinator::Call::LoadFirmware(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView fw_path, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::LoadFirmware(std::move(_client_end), std::move(_request_buffer), std::move(fw_path), std::move(_response_buffer));
}

::fidl::DecodeResult<Coordinator::LoadFirmwareResponse> Coordinator::InPlace::LoadFirmware(zx::unowned_channel _client_end, ::fidl::DecodedMessage<LoadFirmwareRequest> params, ::fidl::BytePart response_buffer) {
  params.message()->_hdr = {};
  params.message()->_hdr.ordinal = kCoordinator_LoadFirmware_Ordinal;
  auto _encode_request_result = ::fidl::Encode(std::move(params));
  if (_encode_request_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Coordinator::LoadFirmwareResponse>::FromFailure(
        std::move(_encode_request_result));
  }
  auto _call_result = ::fidl::Call<LoadFirmwareRequest, LoadFirmwareResponse>(
    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
  if (_call_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Coordinator::LoadFirmwareResponse>::FromFailure(
        std::move(_call_result));
  }
  return ::fidl::Decode(std::move(_call_result.message));
}

template <>
Coordinator::ResultOf::GetMetadata_Impl<Coordinator::GetMetadataResponse>::GetMetadata_Impl(zx::unowned_channel _client_end, uint32_t key) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetMetadataRequest, ::fidl::MessageDirection::kSending>();
  ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
  auto& _write_bytes_array = _write_bytes_inlined;
  uint8_t* _write_bytes = _write_bytes_array.view().data();
  memset(_write_bytes, 0, GetMetadataRequest::PrimarySize);
  auto& _request = *reinterpret_cast<GetMetadataRequest*>(_write_bytes);
  _request.key = std::move(key);
  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetMetadataRequest));
  ::fidl::DecodedMessage<GetMetadataRequest> _decoded_request(std::move(_request_bytes));
  Super::SetResult(
      Coordinator::InPlace::GetMetadata(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
}

Coordinator::ResultOf::GetMetadata Coordinator::SyncClient::GetMetadata(uint32_t key) {
  return ResultOf::GetMetadata(zx::unowned_channel(this->channel_), std::move(key));
}

Coordinator::ResultOf::GetMetadata Coordinator::Call::GetMetadata(zx::unowned_channel _client_end, uint32_t key) {
  return ResultOf::GetMetadata(std::move(_client_end), std::move(key));
}

template <>
Coordinator::UnownedResultOf::GetMetadata_Impl<Coordinator::GetMetadataResponse>::GetMetadata_Impl(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t key, ::fidl::BytePart _response_buffer) {
  if (_request_buffer.capacity() < GetMetadataRequest::PrimarySize) {
    Super::SetFailure(::fidl::DecodeResult<GetMetadataResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
    return;
  }
  memset(_request_buffer.data(), 0, GetMetadataRequest::PrimarySize);
  auto& _request = *reinterpret_cast<GetMetadataRequest*>(_request_buffer.data());
  _request.key = std::move(key);
  _request_buffer.set_actual(sizeof(GetMetadataRequest));
  ::fidl::DecodedMessage<GetMetadataRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      Coordinator::InPlace::GetMetadata(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
}

Coordinator::UnownedResultOf::GetMetadata Coordinator::SyncClient::GetMetadata(::fidl::BytePart _request_buffer, uint32_t key, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::GetMetadata(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(key), std::move(_response_buffer));
}

Coordinator::UnownedResultOf::GetMetadata Coordinator::Call::GetMetadata(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t key, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::GetMetadata(std::move(_client_end), std::move(_request_buffer), std::move(key), std::move(_response_buffer));
}

::fidl::DecodeResult<Coordinator::GetMetadataResponse> Coordinator::InPlace::GetMetadata(zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetMetadataRequest> params, ::fidl::BytePart response_buffer) {
  params.message()->_hdr = {};
  params.message()->_hdr.ordinal = kCoordinator_GetMetadata_Ordinal;
  auto _encode_request_result = ::fidl::Encode(std::move(params));
  if (_encode_request_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Coordinator::GetMetadataResponse>::FromFailure(
        std::move(_encode_request_result));
  }
  auto _call_result = ::fidl::Call<GetMetadataRequest, GetMetadataResponse>(
    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
  if (_call_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Coordinator::GetMetadataResponse>::FromFailure(
        std::move(_call_result));
  }
  return ::fidl::Decode(std::move(_call_result.message));
}

template <>
Coordinator::ResultOf::GetMetadataSize_Impl<Coordinator::GetMetadataSizeResponse>::GetMetadataSize_Impl(zx::unowned_channel _client_end, uint32_t key) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetMetadataSizeRequest, ::fidl::MessageDirection::kSending>();
  ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
  auto& _write_bytes_array = _write_bytes_inlined;
  uint8_t* _write_bytes = _write_bytes_array.view().data();
  memset(_write_bytes, 0, GetMetadataSizeRequest::PrimarySize);
  auto& _request = *reinterpret_cast<GetMetadataSizeRequest*>(_write_bytes);
  _request.key = std::move(key);
  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetMetadataSizeRequest));
  ::fidl::DecodedMessage<GetMetadataSizeRequest> _decoded_request(std::move(_request_bytes));
  Super::SetResult(
      Coordinator::InPlace::GetMetadataSize(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
}

Coordinator::ResultOf::GetMetadataSize Coordinator::SyncClient::GetMetadataSize(uint32_t key) {
  return ResultOf::GetMetadataSize(zx::unowned_channel(this->channel_), std::move(key));
}

Coordinator::ResultOf::GetMetadataSize Coordinator::Call::GetMetadataSize(zx::unowned_channel _client_end, uint32_t key) {
  return ResultOf::GetMetadataSize(std::move(_client_end), std::move(key));
}

template <>
Coordinator::UnownedResultOf::GetMetadataSize_Impl<Coordinator::GetMetadataSizeResponse>::GetMetadataSize_Impl(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t key, ::fidl::BytePart _response_buffer) {
  if (_request_buffer.capacity() < GetMetadataSizeRequest::PrimarySize) {
    Super::SetFailure(::fidl::DecodeResult<GetMetadataSizeResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
    return;
  }
  memset(_request_buffer.data(), 0, GetMetadataSizeRequest::PrimarySize);
  auto& _request = *reinterpret_cast<GetMetadataSizeRequest*>(_request_buffer.data());
  _request.key = std::move(key);
  _request_buffer.set_actual(sizeof(GetMetadataSizeRequest));
  ::fidl::DecodedMessage<GetMetadataSizeRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      Coordinator::InPlace::GetMetadataSize(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
}

Coordinator::UnownedResultOf::GetMetadataSize Coordinator::SyncClient::GetMetadataSize(::fidl::BytePart _request_buffer, uint32_t key, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::GetMetadataSize(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(key), std::move(_response_buffer));
}

Coordinator::UnownedResultOf::GetMetadataSize Coordinator::Call::GetMetadataSize(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t key, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::GetMetadataSize(std::move(_client_end), std::move(_request_buffer), std::move(key), std::move(_response_buffer));
}

::fidl::DecodeResult<Coordinator::GetMetadataSizeResponse> Coordinator::InPlace::GetMetadataSize(zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetMetadataSizeRequest> params, ::fidl::BytePart response_buffer) {
  params.message()->_hdr = {};
  params.message()->_hdr.ordinal = kCoordinator_GetMetadataSize_Ordinal;
  auto _encode_request_result = ::fidl::Encode(std::move(params));
  if (_encode_request_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Coordinator::GetMetadataSizeResponse>::FromFailure(
        std::move(_encode_request_result));
  }
  auto _call_result = ::fidl::Call<GetMetadataSizeRequest, GetMetadataSizeResponse>(
    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
  if (_call_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Coordinator::GetMetadataSizeResponse>::FromFailure(
        std::move(_call_result));
  }
  return ::fidl::Decode(std::move(_call_result.message));
}

template <>
Coordinator::ResultOf::AddMetadata_Impl<Coordinator::AddMetadataResponse>::AddMetadata_Impl(zx::unowned_channel _client_end, uint32_t key, ::fidl::VectorView<uint8_t> data) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<AddMetadataRequest, ::fidl::MessageDirection::kSending>();
  std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
  auto& _write_bytes_array = *_write_bytes_boxed;
  AddMetadataRequest _request = {};
  _request.key = std::move(key);
  _request.data = std::move(data);
  auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
  if (_linearize_result.status != ZX_OK) {
    Super::SetFailure(std::move(_linearize_result));
    return;
  }
  ::fidl::DecodedMessage<AddMetadataRequest> _decoded_request = std::move(_linearize_result.message);
  Super::SetResult(
      Coordinator::InPlace::AddMetadata(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
}

Coordinator::ResultOf::AddMetadata Coordinator::SyncClient::AddMetadata(uint32_t key, ::fidl::VectorView<uint8_t> data) {
  return ResultOf::AddMetadata(zx::unowned_channel(this->channel_), std::move(key), std::move(data));
}

Coordinator::ResultOf::AddMetadata Coordinator::Call::AddMetadata(zx::unowned_channel _client_end, uint32_t key, ::fidl::VectorView<uint8_t> data) {
  return ResultOf::AddMetadata(std::move(_client_end), std::move(key), std::move(data));
}

template <>
Coordinator::UnownedResultOf::AddMetadata_Impl<Coordinator::AddMetadataResponse>::AddMetadata_Impl(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t key, ::fidl::VectorView<uint8_t> data, ::fidl::BytePart _response_buffer) {
  if (_request_buffer.capacity() < AddMetadataRequest::PrimarySize) {
    Super::SetFailure(::fidl::DecodeResult<AddMetadataResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
    return;
  }
  AddMetadataRequest _request = {};
  _request.key = std::move(key);
  _request.data = std::move(data);
  auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
  if (_linearize_result.status != ZX_OK) {
    Super::SetFailure(std::move(_linearize_result));
    return;
  }
  ::fidl::DecodedMessage<AddMetadataRequest> _decoded_request = std::move(_linearize_result.message);
  Super::SetResult(
      Coordinator::InPlace::AddMetadata(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
}

Coordinator::UnownedResultOf::AddMetadata Coordinator::SyncClient::AddMetadata(::fidl::BytePart _request_buffer, uint32_t key, ::fidl::VectorView<uint8_t> data, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::AddMetadata(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(key), std::move(data), std::move(_response_buffer));
}

Coordinator::UnownedResultOf::AddMetadata Coordinator::Call::AddMetadata(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t key, ::fidl::VectorView<uint8_t> data, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::AddMetadata(std::move(_client_end), std::move(_request_buffer), std::move(key), std::move(data), std::move(_response_buffer));
}

::fidl::DecodeResult<Coordinator::AddMetadataResponse> Coordinator::InPlace::AddMetadata(zx::unowned_channel _client_end, ::fidl::DecodedMessage<AddMetadataRequest> params, ::fidl::BytePart response_buffer) {
  params.message()->_hdr = {};
  params.message()->_hdr.ordinal = kCoordinator_AddMetadata_Ordinal;
  auto _encode_request_result = ::fidl::Encode(std::move(params));
  if (_encode_request_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Coordinator::AddMetadataResponse>::FromFailure(
        std::move(_encode_request_result));
  }
  auto _call_result = ::fidl::Call<AddMetadataRequest, AddMetadataResponse>(
    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
  if (_call_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Coordinator::AddMetadataResponse>::FromFailure(
        std::move(_call_result));
  }
  return ::fidl::Decode(std::move(_call_result.message));
}

template <>
Coordinator::ResultOf::PublishMetadata_Impl<Coordinator::PublishMetadataResponse>::PublishMetadata_Impl(zx::unowned_channel _client_end, ::fidl::StringView device_path, uint32_t key, ::fidl::VectorView<uint8_t> data) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<PublishMetadataRequest, ::fidl::MessageDirection::kSending>();
  std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
  auto& _write_bytes_array = *_write_bytes_boxed;
  PublishMetadataRequest _request = {};
  _request.device_path = std::move(device_path);
  _request.key = std::move(key);
  _request.data = std::move(data);
  auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
  if (_linearize_result.status != ZX_OK) {
    Super::SetFailure(std::move(_linearize_result));
    return;
  }
  ::fidl::DecodedMessage<PublishMetadataRequest> _decoded_request = std::move(_linearize_result.message);
  Super::SetResult(
      Coordinator::InPlace::PublishMetadata(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
}

Coordinator::ResultOf::PublishMetadata Coordinator::SyncClient::PublishMetadata(::fidl::StringView device_path, uint32_t key, ::fidl::VectorView<uint8_t> data) {
  return ResultOf::PublishMetadata(zx::unowned_channel(this->channel_), std::move(device_path), std::move(key), std::move(data));
}

Coordinator::ResultOf::PublishMetadata Coordinator::Call::PublishMetadata(zx::unowned_channel _client_end, ::fidl::StringView device_path, uint32_t key, ::fidl::VectorView<uint8_t> data) {
  return ResultOf::PublishMetadata(std::move(_client_end), std::move(device_path), std::move(key), std::move(data));
}

template <>
Coordinator::UnownedResultOf::PublishMetadata_Impl<Coordinator::PublishMetadataResponse>::PublishMetadata_Impl(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView device_path, uint32_t key, ::fidl::VectorView<uint8_t> data, ::fidl::BytePart _response_buffer) {
  if (_request_buffer.capacity() < PublishMetadataRequest::PrimarySize) {
    Super::SetFailure(::fidl::DecodeResult<PublishMetadataResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
    return;
  }
  PublishMetadataRequest _request = {};
  _request.device_path = std::move(device_path);
  _request.key = std::move(key);
  _request.data = std::move(data);
  auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
  if (_linearize_result.status != ZX_OK) {
    Super::SetFailure(std::move(_linearize_result));
    return;
  }
  ::fidl::DecodedMessage<PublishMetadataRequest> _decoded_request = std::move(_linearize_result.message);
  Super::SetResult(
      Coordinator::InPlace::PublishMetadata(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
}

Coordinator::UnownedResultOf::PublishMetadata Coordinator::SyncClient::PublishMetadata(::fidl::BytePart _request_buffer, ::fidl::StringView device_path, uint32_t key, ::fidl::VectorView<uint8_t> data, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::PublishMetadata(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(device_path), std::move(key), std::move(data), std::move(_response_buffer));
}

Coordinator::UnownedResultOf::PublishMetadata Coordinator::Call::PublishMetadata(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView device_path, uint32_t key, ::fidl::VectorView<uint8_t> data, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::PublishMetadata(std::move(_client_end), std::move(_request_buffer), std::move(device_path), std::move(key), std::move(data), std::move(_response_buffer));
}

::fidl::DecodeResult<Coordinator::PublishMetadataResponse> Coordinator::InPlace::PublishMetadata(zx::unowned_channel _client_end, ::fidl::DecodedMessage<PublishMetadataRequest> params, ::fidl::BytePart response_buffer) {
  params.message()->_hdr = {};
  params.message()->_hdr.ordinal = kCoordinator_PublishMetadata_Ordinal;
  auto _encode_request_result = ::fidl::Encode(std::move(params));
  if (_encode_request_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Coordinator::PublishMetadataResponse>::FromFailure(
        std::move(_encode_request_result));
  }
  auto _call_result = ::fidl::Call<PublishMetadataRequest, PublishMetadataResponse>(
    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
  if (_call_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Coordinator::PublishMetadataResponse>::FromFailure(
        std::move(_call_result));
  }
  return ::fidl::Decode(std::move(_call_result.message));
}

template <>
Coordinator::ResultOf::AddCompositeDevice_Impl<Coordinator::AddCompositeDeviceResponse>::AddCompositeDevice_Impl(zx::unowned_channel _client_end, ::fidl::StringView name, ::fidl::VectorView<uint64_t> props, ::fidl::VectorView<DeviceComponent> components, uint32_t coresident_device_index) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<AddCompositeDeviceRequest, ::fidl::MessageDirection::kSending>();
  std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
  auto& _write_bytes_array = *_write_bytes_boxed;
  AddCompositeDeviceRequest _request = {};
  _request.name = std::move(name);
  _request.props = std::move(props);
  _request.components = std::move(components);
  _request.coresident_device_index = std::move(coresident_device_index);
  auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
  if (_linearize_result.status != ZX_OK) {
    Super::SetFailure(std::move(_linearize_result));
    return;
  }
  ::fidl::DecodedMessage<AddCompositeDeviceRequest> _decoded_request = std::move(_linearize_result.message);
  Super::SetResult(
      Coordinator::InPlace::AddCompositeDevice(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
}

Coordinator::ResultOf::AddCompositeDevice Coordinator::SyncClient::AddCompositeDevice(::fidl::StringView name, ::fidl::VectorView<uint64_t> props, ::fidl::VectorView<DeviceComponent> components, uint32_t coresident_device_index) {
  return ResultOf::AddCompositeDevice(zx::unowned_channel(this->channel_), std::move(name), std::move(props), std::move(components), std::move(coresident_device_index));
}

Coordinator::ResultOf::AddCompositeDevice Coordinator::Call::AddCompositeDevice(zx::unowned_channel _client_end, ::fidl::StringView name, ::fidl::VectorView<uint64_t> props, ::fidl::VectorView<DeviceComponent> components, uint32_t coresident_device_index) {
  return ResultOf::AddCompositeDevice(std::move(_client_end), std::move(name), std::move(props), std::move(components), std::move(coresident_device_index));
}

template <>
Coordinator::UnownedResultOf::AddCompositeDevice_Impl<Coordinator::AddCompositeDeviceResponse>::AddCompositeDevice_Impl(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView name, ::fidl::VectorView<uint64_t> props, ::fidl::VectorView<DeviceComponent> components, uint32_t coresident_device_index, ::fidl::BytePart _response_buffer) {
  if (_request_buffer.capacity() < AddCompositeDeviceRequest::PrimarySize) {
    Super::SetFailure(::fidl::DecodeResult<AddCompositeDeviceResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
    return;
  }
  AddCompositeDeviceRequest _request = {};
  _request.name = std::move(name);
  _request.props = std::move(props);
  _request.components = std::move(components);
  _request.coresident_device_index = std::move(coresident_device_index);
  auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
  if (_linearize_result.status != ZX_OK) {
    Super::SetFailure(std::move(_linearize_result));
    return;
  }
  ::fidl::DecodedMessage<AddCompositeDeviceRequest> _decoded_request = std::move(_linearize_result.message);
  Super::SetResult(
      Coordinator::InPlace::AddCompositeDevice(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
}

Coordinator::UnownedResultOf::AddCompositeDevice Coordinator::SyncClient::AddCompositeDevice(::fidl::BytePart _request_buffer, ::fidl::StringView name, ::fidl::VectorView<uint64_t> props, ::fidl::VectorView<DeviceComponent> components, uint32_t coresident_device_index, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::AddCompositeDevice(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(name), std::move(props), std::move(components), std::move(coresident_device_index), std::move(_response_buffer));
}

Coordinator::UnownedResultOf::AddCompositeDevice Coordinator::Call::AddCompositeDevice(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView name, ::fidl::VectorView<uint64_t> props, ::fidl::VectorView<DeviceComponent> components, uint32_t coresident_device_index, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::AddCompositeDevice(std::move(_client_end), std::move(_request_buffer), std::move(name), std::move(props), std::move(components), std::move(coresident_device_index), std::move(_response_buffer));
}

::fidl::DecodeResult<Coordinator::AddCompositeDeviceResponse> Coordinator::InPlace::AddCompositeDevice(zx::unowned_channel _client_end, ::fidl::DecodedMessage<AddCompositeDeviceRequest> params, ::fidl::BytePart response_buffer) {
  params.message()->_hdr = {};
  params.message()->_hdr.ordinal = kCoordinator_AddCompositeDevice_Ordinal;
  auto _encode_request_result = ::fidl::Encode(std::move(params));
  if (_encode_request_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Coordinator::AddCompositeDeviceResponse>::FromFailure(
        std::move(_encode_request_result));
  }
  auto _call_result = ::fidl::Call<AddCompositeDeviceRequest, AddCompositeDeviceResponse>(
    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
  if (_call_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Coordinator::AddCompositeDeviceResponse>::FromFailure(
        std::move(_call_result));
  }
  return ::fidl::Decode(std::move(_call_result.message));
}

template <>
Coordinator::ResultOf::DirectoryWatch_Impl<Coordinator::DirectoryWatchResponse>::DirectoryWatch_Impl(zx::unowned_channel _client_end, uint32_t mask, uint32_t options, ::zx::channel watcher) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DirectoryWatchRequest, ::fidl::MessageDirection::kSending>();
  ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
  auto& _write_bytes_array = _write_bytes_inlined;
  uint8_t* _write_bytes = _write_bytes_array.view().data();
  memset(_write_bytes, 0, DirectoryWatchRequest::PrimarySize);
  auto& _request = *reinterpret_cast<DirectoryWatchRequest*>(_write_bytes);
  _request.mask = std::move(mask);
  _request.options = std::move(options);
  _request.watcher = std::move(watcher);
  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(DirectoryWatchRequest));
  ::fidl::DecodedMessage<DirectoryWatchRequest> _decoded_request(std::move(_request_bytes));
  Super::SetResult(
      Coordinator::InPlace::DirectoryWatch(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
}

Coordinator::ResultOf::DirectoryWatch Coordinator::SyncClient::DirectoryWatch(uint32_t mask, uint32_t options, ::zx::channel watcher) {
  return ResultOf::DirectoryWatch(zx::unowned_channel(this->channel_), std::move(mask), std::move(options), std::move(watcher));
}

Coordinator::ResultOf::DirectoryWatch Coordinator::Call::DirectoryWatch(zx::unowned_channel _client_end, uint32_t mask, uint32_t options, ::zx::channel watcher) {
  return ResultOf::DirectoryWatch(std::move(_client_end), std::move(mask), std::move(options), std::move(watcher));
}

template <>
Coordinator::UnownedResultOf::DirectoryWatch_Impl<Coordinator::DirectoryWatchResponse>::DirectoryWatch_Impl(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t mask, uint32_t options, ::zx::channel watcher, ::fidl::BytePart _response_buffer) {
  if (_request_buffer.capacity() < DirectoryWatchRequest::PrimarySize) {
    Super::SetFailure(::fidl::DecodeResult<DirectoryWatchResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
    return;
  }
  memset(_request_buffer.data(), 0, DirectoryWatchRequest::PrimarySize);
  auto& _request = *reinterpret_cast<DirectoryWatchRequest*>(_request_buffer.data());
  _request.mask = std::move(mask);
  _request.options = std::move(options);
  _request.watcher = std::move(watcher);
  _request_buffer.set_actual(sizeof(DirectoryWatchRequest));
  ::fidl::DecodedMessage<DirectoryWatchRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      Coordinator::InPlace::DirectoryWatch(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
}

Coordinator::UnownedResultOf::DirectoryWatch Coordinator::SyncClient::DirectoryWatch(::fidl::BytePart _request_buffer, uint32_t mask, uint32_t options, ::zx::channel watcher, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::DirectoryWatch(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(mask), std::move(options), std::move(watcher), std::move(_response_buffer));
}

Coordinator::UnownedResultOf::DirectoryWatch Coordinator::Call::DirectoryWatch(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t mask, uint32_t options, ::zx::channel watcher, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::DirectoryWatch(std::move(_client_end), std::move(_request_buffer), std::move(mask), std::move(options), std::move(watcher), std::move(_response_buffer));
}

::fidl::DecodeResult<Coordinator::DirectoryWatchResponse> Coordinator::InPlace::DirectoryWatch(zx::unowned_channel _client_end, ::fidl::DecodedMessage<DirectoryWatchRequest> params, ::fidl::BytePart response_buffer) {
  params.message()->_hdr = {};
  params.message()->_hdr.ordinal = kCoordinator_DirectoryWatch_Ordinal;
  auto _encode_request_result = ::fidl::Encode(std::move(params));
  if (_encode_request_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Coordinator::DirectoryWatchResponse>::FromFailure(
        std::move(_encode_request_result));
  }
  auto _call_result = ::fidl::Call<DirectoryWatchRequest, DirectoryWatchResponse>(
    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
  if (_call_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Coordinator::DirectoryWatchResponse>::FromFailure(
        std::move(_call_result));
  }
  return ::fidl::Decode(std::move(_call_result.message));
}

template <>
Coordinator::ResultOf::RunCompatibilityTests_Impl<Coordinator::RunCompatibilityTestsResponse>::RunCompatibilityTests_Impl(zx::unowned_channel _client_end, int64_t hook_wait_time) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RunCompatibilityTestsRequest, ::fidl::MessageDirection::kSending>();
  ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
  auto& _write_bytes_array = _write_bytes_inlined;
  uint8_t* _write_bytes = _write_bytes_array.view().data();
  memset(_write_bytes, 0, RunCompatibilityTestsRequest::PrimarySize);
  auto& _request = *reinterpret_cast<RunCompatibilityTestsRequest*>(_write_bytes);
  _request.hook_wait_time = std::move(hook_wait_time);
  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(RunCompatibilityTestsRequest));
  ::fidl::DecodedMessage<RunCompatibilityTestsRequest> _decoded_request(std::move(_request_bytes));
  Super::SetResult(
      Coordinator::InPlace::RunCompatibilityTests(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
}

Coordinator::ResultOf::RunCompatibilityTests Coordinator::SyncClient::RunCompatibilityTests(int64_t hook_wait_time) {
  return ResultOf::RunCompatibilityTests(zx::unowned_channel(this->channel_), std::move(hook_wait_time));
}

Coordinator::ResultOf::RunCompatibilityTests Coordinator::Call::RunCompatibilityTests(zx::unowned_channel _client_end, int64_t hook_wait_time) {
  return ResultOf::RunCompatibilityTests(std::move(_client_end), std::move(hook_wait_time));
}

template <>
Coordinator::UnownedResultOf::RunCompatibilityTests_Impl<Coordinator::RunCompatibilityTestsResponse>::RunCompatibilityTests_Impl(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int64_t hook_wait_time, ::fidl::BytePart _response_buffer) {
  if (_request_buffer.capacity() < RunCompatibilityTestsRequest::PrimarySize) {
    Super::SetFailure(::fidl::DecodeResult<RunCompatibilityTestsResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
    return;
  }
  memset(_request_buffer.data(), 0, RunCompatibilityTestsRequest::PrimarySize);
  auto& _request = *reinterpret_cast<RunCompatibilityTestsRequest*>(_request_buffer.data());
  _request.hook_wait_time = std::move(hook_wait_time);
  _request_buffer.set_actual(sizeof(RunCompatibilityTestsRequest));
  ::fidl::DecodedMessage<RunCompatibilityTestsRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      Coordinator::InPlace::RunCompatibilityTests(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
}

Coordinator::UnownedResultOf::RunCompatibilityTests Coordinator::SyncClient::RunCompatibilityTests(::fidl::BytePart _request_buffer, int64_t hook_wait_time, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::RunCompatibilityTests(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(hook_wait_time), std::move(_response_buffer));
}

Coordinator::UnownedResultOf::RunCompatibilityTests Coordinator::Call::RunCompatibilityTests(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int64_t hook_wait_time, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::RunCompatibilityTests(std::move(_client_end), std::move(_request_buffer), std::move(hook_wait_time), std::move(_response_buffer));
}

::fidl::DecodeResult<Coordinator::RunCompatibilityTestsResponse> Coordinator::InPlace::RunCompatibilityTests(zx::unowned_channel _client_end, ::fidl::DecodedMessage<RunCompatibilityTestsRequest> params, ::fidl::BytePart response_buffer) {
  params.message()->_hdr = {};
  params.message()->_hdr.ordinal = kCoordinator_RunCompatibilityTests_Ordinal;
  auto _encode_request_result = ::fidl::Encode(std::move(params));
  if (_encode_request_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Coordinator::RunCompatibilityTestsResponse>::FromFailure(
        std::move(_encode_request_result));
  }
  auto _call_result = ::fidl::Call<RunCompatibilityTestsRequest, RunCompatibilityTestsResponse>(
    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
  if (_call_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Coordinator::RunCompatibilityTestsResponse>::FromFailure(
        std::move(_call_result));
  }
  return ::fidl::Decode(std::move(_call_result.message));
}


bool Coordinator::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
  if (msg->num_bytes < sizeof(fidl_message_header_t)) {
    zx_handle_close_many(msg->handles, msg->num_handles);
    txn->Close(ZX_ERR_INVALID_ARGS);
    return true;
  }
  fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
  switch (hdr->ordinal) {
    case kCoordinator_AddDevice_Ordinal:
    case kCoordinator_AddDevice_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<AddDeviceRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->AddDevice(std::move(message->rpc), std::move(message->props), std::move(message->name), std::move(message->protocol_id), std::move(message->driver_path), std::move(message->args), std::move(message->device_add_config), std::move(message->client_remote),
        Interface::AddDeviceCompleter::Sync(txn));
      return true;
    }
    case kCoordinator_AddDeviceInvisible_Ordinal:
    case kCoordinator_AddDeviceInvisible_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<AddDeviceInvisibleRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->AddDeviceInvisible(std::move(message->rpc), std::move(message->props), std::move(message->name), std::move(message->protocol_id), std::move(message->driver_path), std::move(message->args), std::move(message->client_remote),
        Interface::AddDeviceInvisibleCompleter::Sync(txn));
      return true;
    }
    case kCoordinator_ScheduleRemove_Ordinal:
    case kCoordinator_ScheduleRemove_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<ScheduleRemoveRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->ScheduleRemove(std::move(message->unbind_self),
        Interface::ScheduleRemoveCompleter::Sync(txn));
      return true;
    }
    case kCoordinator_ScheduleUnbindChildren_Ordinal:
    case kCoordinator_ScheduleUnbindChildren_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<ScheduleUnbindChildrenRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      impl->ScheduleUnbindChildren(
        Interface::ScheduleUnbindChildrenCompleter::Sync(txn));
      return true;
    }
    case kCoordinator_UnbindDone_Ordinal:
    case kCoordinator_UnbindDone_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<UnbindDoneRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      impl->UnbindDone(
        Interface::UnbindDoneCompleter::Sync(txn));
      return true;
    }
    case kCoordinator_RemoveDone_Ordinal:
    case kCoordinator_RemoveDone_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<RemoveDoneRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      impl->RemoveDone(
        Interface::RemoveDoneCompleter::Sync(txn));
      return true;
    }
    case kCoordinator_MakeVisible_Ordinal:
    case kCoordinator_MakeVisible_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<MakeVisibleRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      impl->MakeVisible(
        Interface::MakeVisibleCompleter::Sync(txn));
      return true;
    }
    case kCoordinator_BindDevice_Ordinal:
    case kCoordinator_BindDevice_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<BindDeviceRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->BindDevice(std::move(message->driver_path),
        Interface::BindDeviceCompleter::Sync(txn));
      return true;
    }
    case kCoordinator_GetTopologicalPath_Ordinal:
    case kCoordinator_GetTopologicalPath_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<GetTopologicalPathRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      impl->GetTopologicalPath(
        Interface::GetTopologicalPathCompleter::Sync(txn));
      return true;
    }
    case kCoordinator_LoadFirmware_Ordinal:
    case kCoordinator_LoadFirmware_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<LoadFirmwareRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->LoadFirmware(std::move(message->fw_path),
        Interface::LoadFirmwareCompleter::Sync(txn));
      return true;
    }
    case kCoordinator_GetMetadata_Ordinal:
    case kCoordinator_GetMetadata_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<GetMetadataRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->GetMetadata(std::move(message->key),
        Interface::GetMetadataCompleter::Sync(txn));
      return true;
    }
    case kCoordinator_GetMetadataSize_Ordinal:
    case kCoordinator_GetMetadataSize_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<GetMetadataSizeRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->GetMetadataSize(std::move(message->key),
        Interface::GetMetadataSizeCompleter::Sync(txn));
      return true;
    }
    case kCoordinator_AddMetadata_Ordinal:
    case kCoordinator_AddMetadata_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<AddMetadataRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->AddMetadata(std::move(message->key), std::move(message->data),
        Interface::AddMetadataCompleter::Sync(txn));
      return true;
    }
    case kCoordinator_PublishMetadata_Ordinal:
    case kCoordinator_PublishMetadata_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<PublishMetadataRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->PublishMetadata(std::move(message->device_path), std::move(message->key), std::move(message->data),
        Interface::PublishMetadataCompleter::Sync(txn));
      return true;
    }
    case kCoordinator_AddCompositeDevice_Ordinal:
    case kCoordinator_AddCompositeDevice_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<AddCompositeDeviceRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->AddCompositeDevice(std::move(message->name), std::move(message->props), std::move(message->components), std::move(message->coresident_device_index),
        Interface::AddCompositeDeviceCompleter::Sync(txn));
      return true;
    }
    case kCoordinator_DirectoryWatch_Ordinal:
    case kCoordinator_DirectoryWatch_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<DirectoryWatchRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->DirectoryWatch(std::move(message->mask), std::move(message->options), std::move(message->watcher),
        Interface::DirectoryWatchCompleter::Sync(txn));
      return true;
    }
    case kCoordinator_RunCompatibilityTests_Ordinal:
    case kCoordinator_RunCompatibilityTests_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<RunCompatibilityTestsRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->RunCompatibilityTests(std::move(message->hook_wait_time),
        Interface::RunCompatibilityTestsCompleter::Sync(txn));
      return true;
    }
    default: {
      return false;
    }
  }
}

bool Coordinator::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
  bool found = TryDispatch(impl, msg, txn);
  if (!found) {
    zx_handle_close_many(msg->handles, msg->num_handles);
    txn->Close(ZX_ERR_NOT_SUPPORTED);
  }
  return found;
}


void Coordinator::Interface::AddDeviceCompleterBase::Reply(Coordinator_AddDevice_Result result) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<AddDeviceResponse, ::fidl::MessageDirection::kSending>();
  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
  auto& _response = *reinterpret_cast<AddDeviceResponse*>(_write_bytes);
  _response._hdr.ordinal = kCoordinator_AddDevice_Ordinal;
  _response.result = std::move(result);
  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(AddDeviceResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<AddDeviceResponse>(std::move(_response_bytes)));
}
void Coordinator::Interface::AddDeviceCompleterBase::ReplySuccess(uint64_t local_device_id) {
  Coordinator_AddDevice_Response response;
  response.local_device_id = std::move(local_device_id);

  Reply(Coordinator_AddDevice_Result::WithResponse(std::move(response)));
}
void Coordinator::Interface::AddDeviceCompleterBase::ReplyError(int32_t error) {
  Reply(Coordinator_AddDevice_Result::WithErr(std::move(error)));
}

void Coordinator::Interface::AddDeviceCompleterBase::Reply(::fidl::BytePart _buffer, Coordinator_AddDevice_Result result) {
  if (_buffer.capacity() < AddDeviceResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  auto& _response = *reinterpret_cast<AddDeviceResponse*>(_buffer.data());
  _response._hdr.ordinal = kCoordinator_AddDevice_Ordinal;
  _response.result = std::move(result);
  _buffer.set_actual(sizeof(AddDeviceResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<AddDeviceResponse>(std::move(_buffer)));
}
void Coordinator::Interface::AddDeviceCompleterBase::ReplySuccess(::fidl::BytePart _buffer, uint64_t local_device_id) {
  Coordinator_AddDevice_Response response;
  response.local_device_id = std::move(local_device_id);

  Reply(std::move(_buffer), Coordinator_AddDevice_Result::WithResponse(std::move(response)));
}

void Coordinator::Interface::AddDeviceCompleterBase::Reply(::fidl::DecodedMessage<AddDeviceResponse> params) {
  params.message()->_hdr = {};
  params.message()->_hdr.ordinal = kCoordinator_AddDevice_Ordinal;
  CompleterBase::SendReply(std::move(params));
}


void Coordinator::Interface::AddDeviceInvisibleCompleterBase::Reply(Coordinator_AddDeviceInvisible_Result result) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<AddDeviceInvisibleResponse, ::fidl::MessageDirection::kSending>();
  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
  auto& _response = *reinterpret_cast<AddDeviceInvisibleResponse*>(_write_bytes);
  _response._hdr.ordinal = kCoordinator_AddDeviceInvisible_Ordinal;
  _response.result = std::move(result);
  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(AddDeviceInvisibleResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<AddDeviceInvisibleResponse>(std::move(_response_bytes)));
}
void Coordinator::Interface::AddDeviceInvisibleCompleterBase::ReplySuccess(uint64_t local_device_id) {
  Coordinator_AddDeviceInvisible_Response response;
  response.local_device_id = std::move(local_device_id);

  Reply(Coordinator_AddDeviceInvisible_Result::WithResponse(std::move(response)));
}
void Coordinator::Interface::AddDeviceInvisibleCompleterBase::ReplyError(int32_t error) {
  Reply(Coordinator_AddDeviceInvisible_Result::WithErr(std::move(error)));
}

void Coordinator::Interface::AddDeviceInvisibleCompleterBase::Reply(::fidl::BytePart _buffer, Coordinator_AddDeviceInvisible_Result result) {
  if (_buffer.capacity() < AddDeviceInvisibleResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  auto& _response = *reinterpret_cast<AddDeviceInvisibleResponse*>(_buffer.data());
  _response._hdr.ordinal = kCoordinator_AddDeviceInvisible_Ordinal;
  _response.result = std::move(result);
  _buffer.set_actual(sizeof(AddDeviceInvisibleResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<AddDeviceInvisibleResponse>(std::move(_buffer)));
}
void Coordinator::Interface::AddDeviceInvisibleCompleterBase::ReplySuccess(::fidl::BytePart _buffer, uint64_t local_device_id) {
  Coordinator_AddDeviceInvisible_Response response;
  response.local_device_id = std::move(local_device_id);

  Reply(std::move(_buffer), Coordinator_AddDeviceInvisible_Result::WithResponse(std::move(response)));
}

void Coordinator::Interface::AddDeviceInvisibleCompleterBase::Reply(::fidl::DecodedMessage<AddDeviceInvisibleResponse> params) {
  params.message()->_hdr = {};
  params.message()->_hdr.ordinal = kCoordinator_AddDeviceInvisible_Ordinal;
  CompleterBase::SendReply(std::move(params));
}


void Coordinator::Interface::UnbindDoneCompleterBase::Reply(Coordinator_UnbindDone_Result result) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<UnbindDoneResponse, ::fidl::MessageDirection::kSending>();
  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
  auto& _response = *reinterpret_cast<UnbindDoneResponse*>(_write_bytes);
  _response._hdr.ordinal = kCoordinator_UnbindDone_Ordinal;
  _response.result = std::move(result);
  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(UnbindDoneResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<UnbindDoneResponse>(std::move(_response_bytes)));
}
void Coordinator::Interface::UnbindDoneCompleterBase::ReplySuccess() {
  Coordinator_UnbindDone_Response response;

  Reply(Coordinator_UnbindDone_Result::WithResponse(std::move(response)));
}
void Coordinator::Interface::UnbindDoneCompleterBase::ReplyError(int32_t error) {
  Reply(Coordinator_UnbindDone_Result::WithErr(std::move(error)));
}

void Coordinator::Interface::UnbindDoneCompleterBase::Reply(::fidl::BytePart _buffer, Coordinator_UnbindDone_Result result) {
  if (_buffer.capacity() < UnbindDoneResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  auto& _response = *reinterpret_cast<UnbindDoneResponse*>(_buffer.data());
  _response._hdr.ordinal = kCoordinator_UnbindDone_Ordinal;
  _response.result = std::move(result);
  _buffer.set_actual(sizeof(UnbindDoneResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<UnbindDoneResponse>(std::move(_buffer)));
}
void Coordinator::Interface::UnbindDoneCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
  Coordinator_UnbindDone_Response response;

  Reply(std::move(_buffer), Coordinator_UnbindDone_Result::WithResponse(std::move(response)));
}

void Coordinator::Interface::UnbindDoneCompleterBase::Reply(::fidl::DecodedMessage<UnbindDoneResponse> params) {
  params.message()->_hdr = {};
  params.message()->_hdr.ordinal = kCoordinator_UnbindDone_Ordinal;
  CompleterBase::SendReply(std::move(params));
}


void Coordinator::Interface::RemoveDoneCompleterBase::Reply(Coordinator_RemoveDone_Result result) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RemoveDoneResponse, ::fidl::MessageDirection::kSending>();
  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
  auto& _response = *reinterpret_cast<RemoveDoneResponse*>(_write_bytes);
  _response._hdr.ordinal = kCoordinator_RemoveDone_Ordinal;
  _response.result = std::move(result);
  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(RemoveDoneResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<RemoveDoneResponse>(std::move(_response_bytes)));
}
void Coordinator::Interface::RemoveDoneCompleterBase::ReplySuccess() {
  Coordinator_RemoveDone_Response response;

  Reply(Coordinator_RemoveDone_Result::WithResponse(std::move(response)));
}
void Coordinator::Interface::RemoveDoneCompleterBase::ReplyError(int32_t error) {
  Reply(Coordinator_RemoveDone_Result::WithErr(std::move(error)));
}

void Coordinator::Interface::RemoveDoneCompleterBase::Reply(::fidl::BytePart _buffer, Coordinator_RemoveDone_Result result) {
  if (_buffer.capacity() < RemoveDoneResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  auto& _response = *reinterpret_cast<RemoveDoneResponse*>(_buffer.data());
  _response._hdr.ordinal = kCoordinator_RemoveDone_Ordinal;
  _response.result = std::move(result);
  _buffer.set_actual(sizeof(RemoveDoneResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<RemoveDoneResponse>(std::move(_buffer)));
}
void Coordinator::Interface::RemoveDoneCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
  Coordinator_RemoveDone_Response response;

  Reply(std::move(_buffer), Coordinator_RemoveDone_Result::WithResponse(std::move(response)));
}

void Coordinator::Interface::RemoveDoneCompleterBase::Reply(::fidl::DecodedMessage<RemoveDoneResponse> params) {
  params.message()->_hdr = {};
  params.message()->_hdr.ordinal = kCoordinator_RemoveDone_Ordinal;
  CompleterBase::SendReply(std::move(params));
}


void Coordinator::Interface::MakeVisibleCompleterBase::Reply(Coordinator_MakeVisible_Result result) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<MakeVisibleResponse, ::fidl::MessageDirection::kSending>();
  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
  auto& _response = *reinterpret_cast<MakeVisibleResponse*>(_write_bytes);
  _response._hdr.ordinal = kCoordinator_MakeVisible_Ordinal;
  _response.result = std::move(result);
  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(MakeVisibleResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<MakeVisibleResponse>(std::move(_response_bytes)));
}
void Coordinator::Interface::MakeVisibleCompleterBase::ReplySuccess() {
  Coordinator_MakeVisible_Response response;

  Reply(Coordinator_MakeVisible_Result::WithResponse(std::move(response)));
}
void Coordinator::Interface::MakeVisibleCompleterBase::ReplyError(int32_t error) {
  Reply(Coordinator_MakeVisible_Result::WithErr(std::move(error)));
}

void Coordinator::Interface::MakeVisibleCompleterBase::Reply(::fidl::BytePart _buffer, Coordinator_MakeVisible_Result result) {
  if (_buffer.capacity() < MakeVisibleResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  auto& _response = *reinterpret_cast<MakeVisibleResponse*>(_buffer.data());
  _response._hdr.ordinal = kCoordinator_MakeVisible_Ordinal;
  _response.result = std::move(result);
  _buffer.set_actual(sizeof(MakeVisibleResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<MakeVisibleResponse>(std::move(_buffer)));
}
void Coordinator::Interface::MakeVisibleCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
  Coordinator_MakeVisible_Response response;

  Reply(std::move(_buffer), Coordinator_MakeVisible_Result::WithResponse(std::move(response)));
}

void Coordinator::Interface::MakeVisibleCompleterBase::Reply(::fidl::DecodedMessage<MakeVisibleResponse> params) {
  params.message()->_hdr = {};
  params.message()->_hdr.ordinal = kCoordinator_MakeVisible_Ordinal;
  CompleterBase::SendReply(std::move(params));
}


void Coordinator::Interface::BindDeviceCompleterBase::Reply(Coordinator_BindDevice_Result result) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<BindDeviceResponse, ::fidl::MessageDirection::kSending>();
  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
  auto& _response = *reinterpret_cast<BindDeviceResponse*>(_write_bytes);
  _response._hdr.ordinal = kCoordinator_BindDevice_Ordinal;
  _response.result = std::move(result);
  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(BindDeviceResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<BindDeviceResponse>(std::move(_response_bytes)));
}
void Coordinator::Interface::BindDeviceCompleterBase::ReplySuccess() {
  Coordinator_BindDevice_Response response;

  Reply(Coordinator_BindDevice_Result::WithResponse(std::move(response)));
}
void Coordinator::Interface::BindDeviceCompleterBase::ReplyError(int32_t error) {
  Reply(Coordinator_BindDevice_Result::WithErr(std::move(error)));
}

void Coordinator::Interface::BindDeviceCompleterBase::Reply(::fidl::BytePart _buffer, Coordinator_BindDevice_Result result) {
  if (_buffer.capacity() < BindDeviceResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  auto& _response = *reinterpret_cast<BindDeviceResponse*>(_buffer.data());
  _response._hdr.ordinal = kCoordinator_BindDevice_Ordinal;
  _response.result = std::move(result);
  _buffer.set_actual(sizeof(BindDeviceResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<BindDeviceResponse>(std::move(_buffer)));
}
void Coordinator::Interface::BindDeviceCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
  Coordinator_BindDevice_Response response;

  Reply(std::move(_buffer), Coordinator_BindDevice_Result::WithResponse(std::move(response)));
}

void Coordinator::Interface::BindDeviceCompleterBase::Reply(::fidl::DecodedMessage<BindDeviceResponse> params) {
  params.message()->_hdr = {};
  params.message()->_hdr.ordinal = kCoordinator_BindDevice_Ordinal;
  CompleterBase::SendReply(std::move(params));
}


void Coordinator::Interface::GetTopologicalPathCompleterBase::Reply(Coordinator_GetTopologicalPath_Result result) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetTopologicalPathResponse, ::fidl::MessageDirection::kSending>();
  std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
  uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
  GetTopologicalPathResponse _response = {};
  _response._hdr.ordinal = kCoordinator_GetTopologicalPath_Ordinal;
  _response.result = std::move(result);
  auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
                                                                          _kWriteAllocSize));
  if (_linearize_result.status != ZX_OK) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  CompleterBase::SendReply(std::move(_linearize_result.message));
}
void Coordinator::Interface::GetTopologicalPathCompleterBase::ReplySuccess(::fidl::StringView path) {
  Coordinator_GetTopologicalPath_Response response;
  response.path = std::move(path);

  Reply(Coordinator_GetTopologicalPath_Result::WithResponse(std::move(response)));
}
void Coordinator::Interface::GetTopologicalPathCompleterBase::ReplyError(int32_t error) {
  Reply(Coordinator_GetTopologicalPath_Result::WithErr(std::move(error)));
}

void Coordinator::Interface::GetTopologicalPathCompleterBase::Reply(::fidl::BytePart _buffer, Coordinator_GetTopologicalPath_Result result) {
  if (_buffer.capacity() < GetTopologicalPathResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  GetTopologicalPathResponse _response = {};
  _response._hdr.ordinal = kCoordinator_GetTopologicalPath_Ordinal;
  _response.result = std::move(result);
  auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
  if (_linearize_result.status != ZX_OK) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  CompleterBase::SendReply(std::move(_linearize_result.message));
}
void Coordinator::Interface::GetTopologicalPathCompleterBase::ReplySuccess(::fidl::BytePart _buffer, ::fidl::StringView path) {
  Coordinator_GetTopologicalPath_Response response;
  response.path = std::move(path);

  Reply(std::move(_buffer), Coordinator_GetTopologicalPath_Result::WithResponse(std::move(response)));
}

void Coordinator::Interface::GetTopologicalPathCompleterBase::Reply(::fidl::DecodedMessage<GetTopologicalPathResponse> params) {
  params.message()->_hdr = {};
  params.message()->_hdr.ordinal = kCoordinator_GetTopologicalPath_Ordinal;
  CompleterBase::SendReply(std::move(params));
}


void Coordinator::Interface::LoadFirmwareCompleterBase::Reply(Coordinator_LoadFirmware_Result result) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LoadFirmwareResponse, ::fidl::MessageDirection::kSending>();
  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
  auto& _response = *reinterpret_cast<LoadFirmwareResponse*>(_write_bytes);
  _response._hdr.ordinal = kCoordinator_LoadFirmware_Ordinal;
  _response.result = std::move(result);
  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(LoadFirmwareResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<LoadFirmwareResponse>(std::move(_response_bytes)));
}
void Coordinator::Interface::LoadFirmwareCompleterBase::ReplySuccess(::zx::vmo vmo, uint64_t size) {
  Coordinator_LoadFirmware_Response response;
  response.vmo = std::move(vmo);
  response.size = std::move(size);

  Reply(Coordinator_LoadFirmware_Result::WithResponse(std::move(response)));
}
void Coordinator::Interface::LoadFirmwareCompleterBase::ReplyError(int32_t error) {
  Reply(Coordinator_LoadFirmware_Result::WithErr(std::move(error)));
}

void Coordinator::Interface::LoadFirmwareCompleterBase::Reply(::fidl::BytePart _buffer, Coordinator_LoadFirmware_Result result) {
  if (_buffer.capacity() < LoadFirmwareResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  auto& _response = *reinterpret_cast<LoadFirmwareResponse*>(_buffer.data());
  _response._hdr.ordinal = kCoordinator_LoadFirmware_Ordinal;
  _response.result = std::move(result);
  _buffer.set_actual(sizeof(LoadFirmwareResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<LoadFirmwareResponse>(std::move(_buffer)));
}
void Coordinator::Interface::LoadFirmwareCompleterBase::ReplySuccess(::fidl::BytePart _buffer, ::zx::vmo vmo, uint64_t size) {
  Coordinator_LoadFirmware_Response response;
  response.vmo = std::move(vmo);
  response.size = std::move(size);

  Reply(std::move(_buffer), Coordinator_LoadFirmware_Result::WithResponse(std::move(response)));
}

void Coordinator::Interface::LoadFirmwareCompleterBase::Reply(::fidl::DecodedMessage<LoadFirmwareResponse> params) {
  params.message()->_hdr = {};
  params.message()->_hdr.ordinal = kCoordinator_LoadFirmware_Ordinal;
  CompleterBase::SendReply(std::move(params));
}


void Coordinator::Interface::GetMetadataCompleterBase::Reply(Coordinator_GetMetadata_Result result) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetMetadataResponse, ::fidl::MessageDirection::kSending>();
  std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
  uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
  GetMetadataResponse _response = {};
  _response._hdr.ordinal = kCoordinator_GetMetadata_Ordinal;
  _response.result = std::move(result);
  auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
                                                                          _kWriteAllocSize));
  if (_linearize_result.status != ZX_OK) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  CompleterBase::SendReply(std::move(_linearize_result.message));
}
void Coordinator::Interface::GetMetadataCompleterBase::ReplySuccess(::fidl::VectorView<uint8_t> data) {
  Coordinator_GetMetadata_Response response;
  response.data = std::move(data);

  Reply(Coordinator_GetMetadata_Result::WithResponse(std::move(response)));
}
void Coordinator::Interface::GetMetadataCompleterBase::ReplyError(int32_t error) {
  Reply(Coordinator_GetMetadata_Result::WithErr(std::move(error)));
}

void Coordinator::Interface::GetMetadataCompleterBase::Reply(::fidl::BytePart _buffer, Coordinator_GetMetadata_Result result) {
  if (_buffer.capacity() < GetMetadataResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  GetMetadataResponse _response = {};
  _response._hdr.ordinal = kCoordinator_GetMetadata_Ordinal;
  _response.result = std::move(result);
  auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
  if (_linearize_result.status != ZX_OK) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  CompleterBase::SendReply(std::move(_linearize_result.message));
}
void Coordinator::Interface::GetMetadataCompleterBase::ReplySuccess(::fidl::BytePart _buffer, ::fidl::VectorView<uint8_t> data) {
  Coordinator_GetMetadata_Response response;
  response.data = std::move(data);

  Reply(std::move(_buffer), Coordinator_GetMetadata_Result::WithResponse(std::move(response)));
}

void Coordinator::Interface::GetMetadataCompleterBase::Reply(::fidl::DecodedMessage<GetMetadataResponse> params) {
  params.message()->_hdr = {};
  params.message()->_hdr.ordinal = kCoordinator_GetMetadata_Ordinal;
  CompleterBase::SendReply(std::move(params));
}


void Coordinator::Interface::GetMetadataSizeCompleterBase::Reply(Coordinator_GetMetadataSize_Result result) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetMetadataSizeResponse, ::fidl::MessageDirection::kSending>();
  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
  auto& _response = *reinterpret_cast<GetMetadataSizeResponse*>(_write_bytes);
  _response._hdr.ordinal = kCoordinator_GetMetadataSize_Ordinal;
  _response.result = std::move(result);
  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetMetadataSizeResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<GetMetadataSizeResponse>(std::move(_response_bytes)));
}
void Coordinator::Interface::GetMetadataSizeCompleterBase::ReplySuccess(uint64_t size) {
  Coordinator_GetMetadataSize_Response response;
  response.size = std::move(size);

  Reply(Coordinator_GetMetadataSize_Result::WithResponse(std::move(response)));
}
void Coordinator::Interface::GetMetadataSizeCompleterBase::ReplyError(int32_t error) {
  Reply(Coordinator_GetMetadataSize_Result::WithErr(std::move(error)));
}

void Coordinator::Interface::GetMetadataSizeCompleterBase::Reply(::fidl::BytePart _buffer, Coordinator_GetMetadataSize_Result result) {
  if (_buffer.capacity() < GetMetadataSizeResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  auto& _response = *reinterpret_cast<GetMetadataSizeResponse*>(_buffer.data());
  _response._hdr.ordinal = kCoordinator_GetMetadataSize_Ordinal;
  _response.result = std::move(result);
  _buffer.set_actual(sizeof(GetMetadataSizeResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<GetMetadataSizeResponse>(std::move(_buffer)));
}
void Coordinator::Interface::GetMetadataSizeCompleterBase::ReplySuccess(::fidl::BytePart _buffer, uint64_t size) {
  Coordinator_GetMetadataSize_Response response;
  response.size = std::move(size);

  Reply(std::move(_buffer), Coordinator_GetMetadataSize_Result::WithResponse(std::move(response)));
}

void Coordinator::Interface::GetMetadataSizeCompleterBase::Reply(::fidl::DecodedMessage<GetMetadataSizeResponse> params) {
  params.message()->_hdr = {};
  params.message()->_hdr.ordinal = kCoordinator_GetMetadataSize_Ordinal;
  CompleterBase::SendReply(std::move(params));
}


void Coordinator::Interface::AddMetadataCompleterBase::Reply(Coordinator_AddMetadata_Result result) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<AddMetadataResponse, ::fidl::MessageDirection::kSending>();
  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
  auto& _response = *reinterpret_cast<AddMetadataResponse*>(_write_bytes);
  _response._hdr.ordinal = kCoordinator_AddMetadata_Ordinal;
  _response.result = std::move(result);
  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(AddMetadataResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<AddMetadataResponse>(std::move(_response_bytes)));
}
void Coordinator::Interface::AddMetadataCompleterBase::ReplySuccess() {
  Coordinator_AddMetadata_Response response;

  Reply(Coordinator_AddMetadata_Result::WithResponse(std::move(response)));
}
void Coordinator::Interface::AddMetadataCompleterBase::ReplyError(int32_t error) {
  Reply(Coordinator_AddMetadata_Result::WithErr(std::move(error)));
}

void Coordinator::Interface::AddMetadataCompleterBase::Reply(::fidl::BytePart _buffer, Coordinator_AddMetadata_Result result) {
  if (_buffer.capacity() < AddMetadataResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  auto& _response = *reinterpret_cast<AddMetadataResponse*>(_buffer.data());
  _response._hdr.ordinal = kCoordinator_AddMetadata_Ordinal;
  _response.result = std::move(result);
  _buffer.set_actual(sizeof(AddMetadataResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<AddMetadataResponse>(std::move(_buffer)));
}
void Coordinator::Interface::AddMetadataCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
  Coordinator_AddMetadata_Response response;

  Reply(std::move(_buffer), Coordinator_AddMetadata_Result::WithResponse(std::move(response)));
}

void Coordinator::Interface::AddMetadataCompleterBase::Reply(::fidl::DecodedMessage<AddMetadataResponse> params) {
  params.message()->_hdr = {};
  params.message()->_hdr.ordinal = kCoordinator_AddMetadata_Ordinal;
  CompleterBase::SendReply(std::move(params));
}


void Coordinator::Interface::PublishMetadataCompleterBase::Reply(Coordinator_PublishMetadata_Result result) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<PublishMetadataResponse, ::fidl::MessageDirection::kSending>();
  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
  auto& _response = *reinterpret_cast<PublishMetadataResponse*>(_write_bytes);
  _response._hdr.ordinal = kCoordinator_PublishMetadata_Ordinal;
  _response.result = std::move(result);
  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(PublishMetadataResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<PublishMetadataResponse>(std::move(_response_bytes)));
}
void Coordinator::Interface::PublishMetadataCompleterBase::ReplySuccess() {
  Coordinator_PublishMetadata_Response response;

  Reply(Coordinator_PublishMetadata_Result::WithResponse(std::move(response)));
}
void Coordinator::Interface::PublishMetadataCompleterBase::ReplyError(int32_t error) {
  Reply(Coordinator_PublishMetadata_Result::WithErr(std::move(error)));
}

void Coordinator::Interface::PublishMetadataCompleterBase::Reply(::fidl::BytePart _buffer, Coordinator_PublishMetadata_Result result) {
  if (_buffer.capacity() < PublishMetadataResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  auto& _response = *reinterpret_cast<PublishMetadataResponse*>(_buffer.data());
  _response._hdr.ordinal = kCoordinator_PublishMetadata_Ordinal;
  _response.result = std::move(result);
  _buffer.set_actual(sizeof(PublishMetadataResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<PublishMetadataResponse>(std::move(_buffer)));
}
void Coordinator::Interface::PublishMetadataCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
  Coordinator_PublishMetadata_Response response;

  Reply(std::move(_buffer), Coordinator_PublishMetadata_Result::WithResponse(std::move(response)));
}

void Coordinator::Interface::PublishMetadataCompleterBase::Reply(::fidl::DecodedMessage<PublishMetadataResponse> params) {
  params.message()->_hdr = {};
  params.message()->_hdr.ordinal = kCoordinator_PublishMetadata_Ordinal;
  CompleterBase::SendReply(std::move(params));
}


void Coordinator::Interface::AddCompositeDeviceCompleterBase::Reply(Coordinator_AddCompositeDevice_Result result) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<AddCompositeDeviceResponse, ::fidl::MessageDirection::kSending>();
  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
  auto& _response = *reinterpret_cast<AddCompositeDeviceResponse*>(_write_bytes);
  _response._hdr.ordinal = kCoordinator_AddCompositeDevice_Ordinal;
  _response.result = std::move(result);
  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(AddCompositeDeviceResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<AddCompositeDeviceResponse>(std::move(_response_bytes)));
}
void Coordinator::Interface::AddCompositeDeviceCompleterBase::ReplySuccess() {
  Coordinator_AddCompositeDevice_Response response;

  Reply(Coordinator_AddCompositeDevice_Result::WithResponse(std::move(response)));
}
void Coordinator::Interface::AddCompositeDeviceCompleterBase::ReplyError(int32_t error) {
  Reply(Coordinator_AddCompositeDevice_Result::WithErr(std::move(error)));
}

void Coordinator::Interface::AddCompositeDeviceCompleterBase::Reply(::fidl::BytePart _buffer, Coordinator_AddCompositeDevice_Result result) {
  if (_buffer.capacity() < AddCompositeDeviceResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  auto& _response = *reinterpret_cast<AddCompositeDeviceResponse*>(_buffer.data());
  _response._hdr.ordinal = kCoordinator_AddCompositeDevice_Ordinal;
  _response.result = std::move(result);
  _buffer.set_actual(sizeof(AddCompositeDeviceResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<AddCompositeDeviceResponse>(std::move(_buffer)));
}
void Coordinator::Interface::AddCompositeDeviceCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
  Coordinator_AddCompositeDevice_Response response;

  Reply(std::move(_buffer), Coordinator_AddCompositeDevice_Result::WithResponse(std::move(response)));
}

void Coordinator::Interface::AddCompositeDeviceCompleterBase::Reply(::fidl::DecodedMessage<AddCompositeDeviceResponse> params) {
  params.message()->_hdr = {};
  params.message()->_hdr.ordinal = kCoordinator_AddCompositeDevice_Ordinal;
  CompleterBase::SendReply(std::move(params));
}


void Coordinator::Interface::DirectoryWatchCompleterBase::Reply(Coordinator_DirectoryWatch_Result result) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DirectoryWatchResponse, ::fidl::MessageDirection::kSending>();
  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
  auto& _response = *reinterpret_cast<DirectoryWatchResponse*>(_write_bytes);
  _response._hdr.ordinal = kCoordinator_DirectoryWatch_Ordinal;
  _response.result = std::move(result);
  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(DirectoryWatchResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<DirectoryWatchResponse>(std::move(_response_bytes)));
}
void Coordinator::Interface::DirectoryWatchCompleterBase::ReplySuccess() {
  Coordinator_DirectoryWatch_Response response;

  Reply(Coordinator_DirectoryWatch_Result::WithResponse(std::move(response)));
}
void Coordinator::Interface::DirectoryWatchCompleterBase::ReplyError(int32_t error) {
  Reply(Coordinator_DirectoryWatch_Result::WithErr(std::move(error)));
}

void Coordinator::Interface::DirectoryWatchCompleterBase::Reply(::fidl::BytePart _buffer, Coordinator_DirectoryWatch_Result result) {
  if (_buffer.capacity() < DirectoryWatchResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  auto& _response = *reinterpret_cast<DirectoryWatchResponse*>(_buffer.data());
  _response._hdr.ordinal = kCoordinator_DirectoryWatch_Ordinal;
  _response.result = std::move(result);
  _buffer.set_actual(sizeof(DirectoryWatchResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<DirectoryWatchResponse>(std::move(_buffer)));
}
void Coordinator::Interface::DirectoryWatchCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
  Coordinator_DirectoryWatch_Response response;

  Reply(std::move(_buffer), Coordinator_DirectoryWatch_Result::WithResponse(std::move(response)));
}

void Coordinator::Interface::DirectoryWatchCompleterBase::Reply(::fidl::DecodedMessage<DirectoryWatchResponse> params) {
  params.message()->_hdr = {};
  params.message()->_hdr.ordinal = kCoordinator_DirectoryWatch_Ordinal;
  CompleterBase::SendReply(std::move(params));
}


void Coordinator::Interface::RunCompatibilityTestsCompleterBase::Reply(Coordinator_RunCompatibilityTests_Result result) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RunCompatibilityTestsResponse, ::fidl::MessageDirection::kSending>();
  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
  auto& _response = *reinterpret_cast<RunCompatibilityTestsResponse*>(_write_bytes);
  _response._hdr.ordinal = kCoordinator_RunCompatibilityTests_Ordinal;
  _response.result = std::move(result);
  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(RunCompatibilityTestsResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<RunCompatibilityTestsResponse>(std::move(_response_bytes)));
}
void Coordinator::Interface::RunCompatibilityTestsCompleterBase::ReplySuccess() {
  Coordinator_RunCompatibilityTests_Response response;

  Reply(Coordinator_RunCompatibilityTests_Result::WithResponse(std::move(response)));
}
void Coordinator::Interface::RunCompatibilityTestsCompleterBase::ReplyError(int32_t error) {
  Reply(Coordinator_RunCompatibilityTests_Result::WithErr(std::move(error)));
}

void Coordinator::Interface::RunCompatibilityTestsCompleterBase::Reply(::fidl::BytePart _buffer, Coordinator_RunCompatibilityTests_Result result) {
  if (_buffer.capacity() < RunCompatibilityTestsResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  auto& _response = *reinterpret_cast<RunCompatibilityTestsResponse*>(_buffer.data());
  _response._hdr.ordinal = kCoordinator_RunCompatibilityTests_Ordinal;
  _response.result = std::move(result);
  _buffer.set_actual(sizeof(RunCompatibilityTestsResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<RunCompatibilityTestsResponse>(std::move(_buffer)));
}
void Coordinator::Interface::RunCompatibilityTestsCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
  Coordinator_RunCompatibilityTests_Response response;

  Reply(std::move(_buffer), Coordinator_RunCompatibilityTests_Result::WithResponse(std::move(response)));
}

void Coordinator::Interface::RunCompatibilityTestsCompleterBase::Reply(::fidl::DecodedMessage<RunCompatibilityTestsResponse> params) {
  params.message()->_hdr = {};
  params.message()->_hdr.ordinal = kCoordinator_RunCompatibilityTests_Ordinal;
  CompleterBase::SendReply(std::move(params));
}


}  // namespace manager
}  // namespace device
}  // namespace fuchsia
}  // namespace llcpp