zircon/system/fidl/fuchsia-hardware-usb-device/gen/llcpp/fidl.cc

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

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

namespace llcpp {

namespace fuchsia {
namespace hardware {
namespace usb {
namespace device {

namespace {

[[maybe_unused]]
constexpr uint64_t kDevice_GetDeviceSpeed_Ordinal = 0x7a0548ed00000000lu;
[[maybe_unused]]
constexpr uint64_t kDevice_GetDeviceSpeed_GenOrdinal = 0x623cd7927fb449delu;
extern "C" const fidl_type_t v1_fuchsia_hardware_usb_device_DeviceGetDeviceSpeedRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_usb_device_DeviceGetDeviceSpeedResponseTable;
[[maybe_unused]]
constexpr uint64_t kDevice_GetDeviceDescriptor_Ordinal = 0x16be426a00000000lu;
[[maybe_unused]]
constexpr uint64_t kDevice_GetDeviceDescriptor_GenOrdinal = 0x5f761371f4b9f34alu;
extern "C" const fidl_type_t v1_fuchsia_hardware_usb_device_DeviceGetDeviceDescriptorRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_usb_device_DeviceGetDeviceDescriptorResponseTable;
[[maybe_unused]]
constexpr uint64_t kDevice_GetConfigurationDescriptorSize_Ordinal = 0x2ae4152200000000lu;
[[maybe_unused]]
constexpr uint64_t kDevice_GetConfigurationDescriptorSize_GenOrdinal = 0x65912d7d5e3a07c8lu;
extern "C" const fidl_type_t v1_fuchsia_hardware_usb_device_DeviceGetConfigurationDescriptorSizeRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_usb_device_DeviceGetConfigurationDescriptorSizeResponseTable;
[[maybe_unused]]
constexpr uint64_t kDevice_GetConfigurationDescriptor_Ordinal = 0x67de3f8000000000lu;
[[maybe_unused]]
constexpr uint64_t kDevice_GetConfigurationDescriptor_GenOrdinal = 0x1859a4e4421d2036lu;
extern "C" const fidl_type_t v1_fuchsia_hardware_usb_device_DeviceGetConfigurationDescriptorRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_usb_device_DeviceGetConfigurationDescriptorResponseTable;
[[maybe_unused]]
constexpr uint64_t kDevice_GetStringDescriptor_Ordinal = 0x6bb5f7d600000000lu;
[[maybe_unused]]
constexpr uint64_t kDevice_GetStringDescriptor_GenOrdinal = 0x5ff601b3b6891337lu;
extern "C" const fidl_type_t v1_fuchsia_hardware_usb_device_DeviceGetStringDescriptorRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_usb_device_DeviceGetStringDescriptorResponseTable;
[[maybe_unused]]
constexpr uint64_t kDevice_SetInterface_Ordinal = 0x6fbe7e7700000000lu;
[[maybe_unused]]
constexpr uint64_t kDevice_SetInterface_GenOrdinal = 0x45348c50850b641dlu;
extern "C" const fidl_type_t v1_fuchsia_hardware_usb_device_DeviceSetInterfaceRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_usb_device_DeviceSetInterfaceResponseTable;
[[maybe_unused]]
constexpr uint64_t kDevice_GetDeviceId_Ordinal = 0x629986ec00000000lu;
[[maybe_unused]]
constexpr uint64_t kDevice_GetDeviceId_GenOrdinal = 0x34a73eef491c2ce0lu;
extern "C" const fidl_type_t v1_fuchsia_hardware_usb_device_DeviceGetDeviceIdRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_usb_device_DeviceGetDeviceIdResponseTable;
[[maybe_unused]]
constexpr uint64_t kDevice_GetHubDeviceId_Ordinal = 0x1508505f00000000lu;
[[maybe_unused]]
constexpr uint64_t kDevice_GetHubDeviceId_GenOrdinal = 0xce263c86f7bbbcdlu;
extern "C" const fidl_type_t v1_fuchsia_hardware_usb_device_DeviceGetHubDeviceIdRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_usb_device_DeviceGetHubDeviceIdResponseTable;
[[maybe_unused]]
constexpr uint64_t kDevice_GetConfiguration_Ordinal = 0x6115919400000000lu;
[[maybe_unused]]
constexpr uint64_t kDevice_GetConfiguration_GenOrdinal = 0x73f644382a2335fdlu;
extern "C" const fidl_type_t v1_fuchsia_hardware_usb_device_DeviceGetConfigurationRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_usb_device_DeviceGetConfigurationResponseTable;
[[maybe_unused]]
constexpr uint64_t kDevice_SetConfiguration_Ordinal = 0x43137b500000000lu;
[[maybe_unused]]
constexpr uint64_t kDevice_SetConfiguration_GenOrdinal = 0x12bf6e43b045ee9dlu;
extern "C" const fidl_type_t v1_fuchsia_hardware_usb_device_DeviceSetConfigurationRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_usb_device_DeviceSetConfigurationResponseTable;

}  // namespace
template <>
Device::ResultOf::GetDeviceSpeed_Impl<Device::GetDeviceSpeedResponse>::GetDeviceSpeed_Impl(::zx::unowned_channel _client_end) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetDeviceSpeedRequest, ::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, GetDeviceSpeedRequest::PrimarySize);
  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetDeviceSpeedRequest));
  ::fidl::DecodedMessage<GetDeviceSpeedRequest> _decoded_request(std::move(_request_bytes));
  Super::SetResult(
      Device::InPlace::GetDeviceSpeed(std::move(_client_end), Super::response_buffer()));
}

Device::ResultOf::GetDeviceSpeed Device::SyncClient::GetDeviceSpeed() {
    return ResultOf::GetDeviceSpeed(::zx::unowned_channel(this->channel_));
}

Device::ResultOf::GetDeviceSpeed Device::Call::GetDeviceSpeed(::zx::unowned_channel _client_end) {
  return ResultOf::GetDeviceSpeed(std::move(_client_end));
}

template <>
Device::UnownedResultOf::GetDeviceSpeed_Impl<Device::GetDeviceSpeedResponse>::GetDeviceSpeed_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetDeviceSpeedRequest)] = {};
  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
  memset(_request_buffer.data(), 0, GetDeviceSpeedRequest::PrimarySize);
  _request_buffer.set_actual(sizeof(GetDeviceSpeedRequest));
  ::fidl::DecodedMessage<GetDeviceSpeedRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      Device::InPlace::GetDeviceSpeed(std::move(_client_end), std::move(_response_buffer)));
}

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

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

::fidl::DecodeResult<Device::GetDeviceSpeedResponse> Device::InPlace::GetDeviceSpeed(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
  constexpr uint32_t _write_num_bytes = sizeof(GetDeviceSpeedRequest);
  ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
  ::fidl::BytePart _request_buffer = _write_bytes.view();
  _request_buffer.set_actual(_write_num_bytes);
  ::fidl::DecodedMessage<GetDeviceSpeedRequest> params(std::move(_request_buffer));
  Device::SetTransactionHeaderFor::GetDeviceSpeedRequest(params);
  auto _encode_request_result = ::fidl::Encode(std::move(params));
  if (_encode_request_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Device::GetDeviceSpeedResponse>::FromFailure(
        std::move(_encode_request_result));
  }
  auto _call_result = ::fidl::Call<GetDeviceSpeedRequest, GetDeviceSpeedResponse>(
    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
  if (_call_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Device::GetDeviceSpeedResponse>::FromFailure(
        std::move(_call_result));
  }
  return ::fidl::Decode(std::move(_call_result.message));
}

template <>
Device::ResultOf::GetDeviceDescriptor_Impl<Device::GetDeviceDescriptorResponse>::GetDeviceDescriptor_Impl(::zx::unowned_channel _client_end) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetDeviceDescriptorRequest, ::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, GetDeviceDescriptorRequest::PrimarySize);
  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetDeviceDescriptorRequest));
  ::fidl::DecodedMessage<GetDeviceDescriptorRequest> _decoded_request(std::move(_request_bytes));
  Super::SetResult(
      Device::InPlace::GetDeviceDescriptor(std::move(_client_end), Super::response_buffer()));
}

Device::ResultOf::GetDeviceDescriptor Device::SyncClient::GetDeviceDescriptor() {
    return ResultOf::GetDeviceDescriptor(::zx::unowned_channel(this->channel_));
}

Device::ResultOf::GetDeviceDescriptor Device::Call::GetDeviceDescriptor(::zx::unowned_channel _client_end) {
  return ResultOf::GetDeviceDescriptor(std::move(_client_end));
}

template <>
Device::UnownedResultOf::GetDeviceDescriptor_Impl<Device::GetDeviceDescriptorResponse>::GetDeviceDescriptor_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetDeviceDescriptorRequest)] = {};
  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
  memset(_request_buffer.data(), 0, GetDeviceDescriptorRequest::PrimarySize);
  _request_buffer.set_actual(sizeof(GetDeviceDescriptorRequest));
  ::fidl::DecodedMessage<GetDeviceDescriptorRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      Device::InPlace::GetDeviceDescriptor(std::move(_client_end), std::move(_response_buffer)));
}

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

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

::fidl::DecodeResult<Device::GetDeviceDescriptorResponse> Device::InPlace::GetDeviceDescriptor(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
  constexpr uint32_t _write_num_bytes = sizeof(GetDeviceDescriptorRequest);
  ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
  ::fidl::BytePart _request_buffer = _write_bytes.view();
  _request_buffer.set_actual(_write_num_bytes);
  ::fidl::DecodedMessage<GetDeviceDescriptorRequest> params(std::move(_request_buffer));
  Device::SetTransactionHeaderFor::GetDeviceDescriptorRequest(params);
  auto _encode_request_result = ::fidl::Encode(std::move(params));
  if (_encode_request_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Device::GetDeviceDescriptorResponse>::FromFailure(
        std::move(_encode_request_result));
  }
  auto _call_result = ::fidl::Call<GetDeviceDescriptorRequest, GetDeviceDescriptorResponse>(
    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
  if (_call_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Device::GetDeviceDescriptorResponse>::FromFailure(
        std::move(_call_result));
  }
  return ::fidl::Decode(std::move(_call_result.message));
}

template <>
Device::ResultOf::GetConfigurationDescriptorSize_Impl<Device::GetConfigurationDescriptorSizeResponse>::GetConfigurationDescriptorSize_Impl(::zx::unowned_channel _client_end, uint8_t config) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetConfigurationDescriptorSizeRequest, ::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, GetConfigurationDescriptorSizeRequest::PrimarySize);
  auto& _request = *reinterpret_cast<GetConfigurationDescriptorSizeRequest*>(_write_bytes);
  _request.config = std::move(config);
  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetConfigurationDescriptorSizeRequest));
  ::fidl::DecodedMessage<GetConfigurationDescriptorSizeRequest> _decoded_request(std::move(_request_bytes));
  Super::SetResult(
      Device::InPlace::GetConfigurationDescriptorSize(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
}

Device::ResultOf::GetConfigurationDescriptorSize Device::SyncClient::GetConfigurationDescriptorSize(uint8_t config) {
    return ResultOf::GetConfigurationDescriptorSize(::zx::unowned_channel(this->channel_), std::move(config));
}

Device::ResultOf::GetConfigurationDescriptorSize Device::Call::GetConfigurationDescriptorSize(::zx::unowned_channel _client_end, uint8_t config) {
  return ResultOf::GetConfigurationDescriptorSize(std::move(_client_end), std::move(config));
}

template <>
Device::UnownedResultOf::GetConfigurationDescriptorSize_Impl<Device::GetConfigurationDescriptorSizeResponse>::GetConfigurationDescriptorSize_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint8_t config, ::fidl::BytePart _response_buffer) {
  if (_request_buffer.capacity() < GetConfigurationDescriptorSizeRequest::PrimarySize) {
    Super::SetFailure(::fidl::DecodeResult<GetConfigurationDescriptorSizeResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
    return;
  }
  memset(_request_buffer.data(), 0, GetConfigurationDescriptorSizeRequest::PrimarySize);
  auto& _request = *reinterpret_cast<GetConfigurationDescriptorSizeRequest*>(_request_buffer.data());
  _request.config = std::move(config);
  _request_buffer.set_actual(sizeof(GetConfigurationDescriptorSizeRequest));
  ::fidl::DecodedMessage<GetConfigurationDescriptorSizeRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      Device::InPlace::GetConfigurationDescriptorSize(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
}

Device::UnownedResultOf::GetConfigurationDescriptorSize Device::SyncClient::GetConfigurationDescriptorSize(::fidl::BytePart _request_buffer, uint8_t config, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::GetConfigurationDescriptorSize(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(config), std::move(_response_buffer));
}

Device::UnownedResultOf::GetConfigurationDescriptorSize Device::Call::GetConfigurationDescriptorSize(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint8_t config, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::GetConfigurationDescriptorSize(std::move(_client_end), std::move(_request_buffer), std::move(config), std::move(_response_buffer));
}

::fidl::DecodeResult<Device::GetConfigurationDescriptorSizeResponse> Device::InPlace::GetConfigurationDescriptorSize(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetConfigurationDescriptorSizeRequest> params, ::fidl::BytePart response_buffer) {
  Device::SetTransactionHeaderFor::GetConfigurationDescriptorSizeRequest(params);
  auto _encode_request_result = ::fidl::Encode(std::move(params));
  if (_encode_request_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Device::GetConfigurationDescriptorSizeResponse>::FromFailure(
        std::move(_encode_request_result));
  }
  auto _call_result = ::fidl::Call<GetConfigurationDescriptorSizeRequest, GetConfigurationDescriptorSizeResponse>(
    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
  if (_call_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Device::GetConfigurationDescriptorSizeResponse>::FromFailure(
        std::move(_call_result));
  }
  return ::fidl::Decode(std::move(_call_result.message));
}

template <>
Device::ResultOf::GetConfigurationDescriptor_Impl<Device::GetConfigurationDescriptorResponse>::GetConfigurationDescriptor_Impl(::zx::unowned_channel _client_end, uint8_t config) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetConfigurationDescriptorRequest, ::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, GetConfigurationDescriptorRequest::PrimarySize);
  auto& _request = *reinterpret_cast<GetConfigurationDescriptorRequest*>(_write_bytes);
  _request.config = std::move(config);
  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetConfigurationDescriptorRequest));
  ::fidl::DecodedMessage<GetConfigurationDescriptorRequest> _decoded_request(std::move(_request_bytes));
  Super::SetResult(
      Device::InPlace::GetConfigurationDescriptor(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
}

Device::ResultOf::GetConfigurationDescriptor Device::SyncClient::GetConfigurationDescriptor(uint8_t config) {
    return ResultOf::GetConfigurationDescriptor(::zx::unowned_channel(this->channel_), std::move(config));
}

Device::ResultOf::GetConfigurationDescriptor Device::Call::GetConfigurationDescriptor(::zx::unowned_channel _client_end, uint8_t config) {
  return ResultOf::GetConfigurationDescriptor(std::move(_client_end), std::move(config));
}

template <>
Device::UnownedResultOf::GetConfigurationDescriptor_Impl<Device::GetConfigurationDescriptorResponse>::GetConfigurationDescriptor_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint8_t config, ::fidl::BytePart _response_buffer) {
  if (_request_buffer.capacity() < GetConfigurationDescriptorRequest::PrimarySize) {
    Super::SetFailure(::fidl::DecodeResult<GetConfigurationDescriptorResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
    return;
  }
  memset(_request_buffer.data(), 0, GetConfigurationDescriptorRequest::PrimarySize);
  auto& _request = *reinterpret_cast<GetConfigurationDescriptorRequest*>(_request_buffer.data());
  _request.config = std::move(config);
  _request_buffer.set_actual(sizeof(GetConfigurationDescriptorRequest));
  ::fidl::DecodedMessage<GetConfigurationDescriptorRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      Device::InPlace::GetConfigurationDescriptor(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
}

Device::UnownedResultOf::GetConfigurationDescriptor Device::SyncClient::GetConfigurationDescriptor(::fidl::BytePart _request_buffer, uint8_t config, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::GetConfigurationDescriptor(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(config), std::move(_response_buffer));
}

Device::UnownedResultOf::GetConfigurationDescriptor Device::Call::GetConfigurationDescriptor(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint8_t config, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::GetConfigurationDescriptor(std::move(_client_end), std::move(_request_buffer), std::move(config), std::move(_response_buffer));
}

::fidl::DecodeResult<Device::GetConfigurationDescriptorResponse> Device::InPlace::GetConfigurationDescriptor(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetConfigurationDescriptorRequest> params, ::fidl::BytePart response_buffer) {
  Device::SetTransactionHeaderFor::GetConfigurationDescriptorRequest(params);
  auto _encode_request_result = ::fidl::Encode(std::move(params));
  if (_encode_request_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Device::GetConfigurationDescriptorResponse>::FromFailure(
        std::move(_encode_request_result));
  }
  auto _call_result = ::fidl::Call<GetConfigurationDescriptorRequest, GetConfigurationDescriptorResponse>(
    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
  if (_call_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Device::GetConfigurationDescriptorResponse>::FromFailure(
        std::move(_call_result));
  }
  return ::fidl::Decode(std::move(_call_result.message));
}

template <>
Device::ResultOf::GetStringDescriptor_Impl<Device::GetStringDescriptorResponse>::GetStringDescriptor_Impl(::zx::unowned_channel _client_end, uint8_t desc_id, uint16_t lang_id) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetStringDescriptorRequest, ::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, GetStringDescriptorRequest::PrimarySize);
  auto& _request = *reinterpret_cast<GetStringDescriptorRequest*>(_write_bytes);
  _request.desc_id = std::move(desc_id);
  _request.lang_id = std::move(lang_id);
  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetStringDescriptorRequest));
  ::fidl::DecodedMessage<GetStringDescriptorRequest> _decoded_request(std::move(_request_bytes));
  Super::SetResult(
      Device::InPlace::GetStringDescriptor(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
}

Device::ResultOf::GetStringDescriptor Device::SyncClient::GetStringDescriptor(uint8_t desc_id, uint16_t lang_id) {
    return ResultOf::GetStringDescriptor(::zx::unowned_channel(this->channel_), std::move(desc_id), std::move(lang_id));
}

Device::ResultOf::GetStringDescriptor Device::Call::GetStringDescriptor(::zx::unowned_channel _client_end, uint8_t desc_id, uint16_t lang_id) {
  return ResultOf::GetStringDescriptor(std::move(_client_end), std::move(desc_id), std::move(lang_id));
}

template <>
Device::UnownedResultOf::GetStringDescriptor_Impl<Device::GetStringDescriptorResponse>::GetStringDescriptor_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint8_t desc_id, uint16_t lang_id, ::fidl::BytePart _response_buffer) {
  if (_request_buffer.capacity() < GetStringDescriptorRequest::PrimarySize) {
    Super::SetFailure(::fidl::DecodeResult<GetStringDescriptorResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
    return;
  }
  memset(_request_buffer.data(), 0, GetStringDescriptorRequest::PrimarySize);
  auto& _request = *reinterpret_cast<GetStringDescriptorRequest*>(_request_buffer.data());
  _request.desc_id = std::move(desc_id);
  _request.lang_id = std::move(lang_id);
  _request_buffer.set_actual(sizeof(GetStringDescriptorRequest));
  ::fidl::DecodedMessage<GetStringDescriptorRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      Device::InPlace::GetStringDescriptor(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
}

Device::UnownedResultOf::GetStringDescriptor Device::SyncClient::GetStringDescriptor(::fidl::BytePart _request_buffer, uint8_t desc_id, uint16_t lang_id, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::GetStringDescriptor(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(desc_id), std::move(lang_id), std::move(_response_buffer));
}

Device::UnownedResultOf::GetStringDescriptor Device::Call::GetStringDescriptor(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint8_t desc_id, uint16_t lang_id, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::GetStringDescriptor(std::move(_client_end), std::move(_request_buffer), std::move(desc_id), std::move(lang_id), std::move(_response_buffer));
}

::fidl::DecodeResult<Device::GetStringDescriptorResponse> Device::InPlace::GetStringDescriptor(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetStringDescriptorRequest> params, ::fidl::BytePart response_buffer) {
  Device::SetTransactionHeaderFor::GetStringDescriptorRequest(params);
  auto _encode_request_result = ::fidl::Encode(std::move(params));
  if (_encode_request_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Device::GetStringDescriptorResponse>::FromFailure(
        std::move(_encode_request_result));
  }
  auto _call_result = ::fidl::Call<GetStringDescriptorRequest, GetStringDescriptorResponse>(
    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
  if (_call_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Device::GetStringDescriptorResponse>::FromFailure(
        std::move(_call_result));
  }
  return ::fidl::Decode(std::move(_call_result.message));
}

template <>
Device::ResultOf::SetInterface_Impl<Device::SetInterfaceResponse>::SetInterface_Impl(::zx::unowned_channel _client_end, uint8_t interface_number, uint8_t alt_setting) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetInterfaceRequest, ::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, SetInterfaceRequest::PrimarySize);
  auto& _request = *reinterpret_cast<SetInterfaceRequest*>(_write_bytes);
  _request.interface_number = std::move(interface_number);
  _request.alt_setting = std::move(alt_setting);
  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetInterfaceRequest));
  ::fidl::DecodedMessage<SetInterfaceRequest> _decoded_request(std::move(_request_bytes));
  Super::SetResult(
      Device::InPlace::SetInterface(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
}

Device::ResultOf::SetInterface Device::SyncClient::SetInterface(uint8_t interface_number, uint8_t alt_setting) {
    return ResultOf::SetInterface(::zx::unowned_channel(this->channel_), std::move(interface_number), std::move(alt_setting));
}

Device::ResultOf::SetInterface Device::Call::SetInterface(::zx::unowned_channel _client_end, uint8_t interface_number, uint8_t alt_setting) {
  return ResultOf::SetInterface(std::move(_client_end), std::move(interface_number), std::move(alt_setting));
}

template <>
Device::UnownedResultOf::SetInterface_Impl<Device::SetInterfaceResponse>::SetInterface_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint8_t interface_number, uint8_t alt_setting, ::fidl::BytePart _response_buffer) {
  if (_request_buffer.capacity() < SetInterfaceRequest::PrimarySize) {
    Super::SetFailure(::fidl::DecodeResult<SetInterfaceResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
    return;
  }
  memset(_request_buffer.data(), 0, SetInterfaceRequest::PrimarySize);
  auto& _request = *reinterpret_cast<SetInterfaceRequest*>(_request_buffer.data());
  _request.interface_number = std::move(interface_number);
  _request.alt_setting = std::move(alt_setting);
  _request_buffer.set_actual(sizeof(SetInterfaceRequest));
  ::fidl::DecodedMessage<SetInterfaceRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      Device::InPlace::SetInterface(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
}

Device::UnownedResultOf::SetInterface Device::SyncClient::SetInterface(::fidl::BytePart _request_buffer, uint8_t interface_number, uint8_t alt_setting, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::SetInterface(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(interface_number), std::move(alt_setting), std::move(_response_buffer));
}

Device::UnownedResultOf::SetInterface Device::Call::SetInterface(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint8_t interface_number, uint8_t alt_setting, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::SetInterface(std::move(_client_end), std::move(_request_buffer), std::move(interface_number), std::move(alt_setting), std::move(_response_buffer));
}

::fidl::DecodeResult<Device::SetInterfaceResponse> Device::InPlace::SetInterface(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetInterfaceRequest> params, ::fidl::BytePart response_buffer) {
  Device::SetTransactionHeaderFor::SetInterfaceRequest(params);
  auto _encode_request_result = ::fidl::Encode(std::move(params));
  if (_encode_request_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Device::SetInterfaceResponse>::FromFailure(
        std::move(_encode_request_result));
  }
  auto _call_result = ::fidl::Call<SetInterfaceRequest, SetInterfaceResponse>(
    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
  if (_call_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Device::SetInterfaceResponse>::FromFailure(
        std::move(_call_result));
  }
  return ::fidl::Decode(std::move(_call_result.message));
}

template <>
Device::ResultOf::GetDeviceId_Impl<Device::GetDeviceIdResponse>::GetDeviceId_Impl(::zx::unowned_channel _client_end) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetDeviceIdRequest, ::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, GetDeviceIdRequest::PrimarySize);
  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetDeviceIdRequest));
  ::fidl::DecodedMessage<GetDeviceIdRequest> _decoded_request(std::move(_request_bytes));
  Super::SetResult(
      Device::InPlace::GetDeviceId(std::move(_client_end), Super::response_buffer()));
}

Device::ResultOf::GetDeviceId Device::SyncClient::GetDeviceId() {
    return ResultOf::GetDeviceId(::zx::unowned_channel(this->channel_));
}

Device::ResultOf::GetDeviceId Device::Call::GetDeviceId(::zx::unowned_channel _client_end) {
  return ResultOf::GetDeviceId(std::move(_client_end));
}

template <>
Device::UnownedResultOf::GetDeviceId_Impl<Device::GetDeviceIdResponse>::GetDeviceId_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetDeviceIdRequest)] = {};
  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
  memset(_request_buffer.data(), 0, GetDeviceIdRequest::PrimarySize);
  _request_buffer.set_actual(sizeof(GetDeviceIdRequest));
  ::fidl::DecodedMessage<GetDeviceIdRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      Device::InPlace::GetDeviceId(std::move(_client_end), std::move(_response_buffer)));
}

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

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

::fidl::DecodeResult<Device::GetDeviceIdResponse> Device::InPlace::GetDeviceId(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
  constexpr uint32_t _write_num_bytes = sizeof(GetDeviceIdRequest);
  ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
  ::fidl::BytePart _request_buffer = _write_bytes.view();
  _request_buffer.set_actual(_write_num_bytes);
  ::fidl::DecodedMessage<GetDeviceIdRequest> params(std::move(_request_buffer));
  Device::SetTransactionHeaderFor::GetDeviceIdRequest(params);
  auto _encode_request_result = ::fidl::Encode(std::move(params));
  if (_encode_request_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Device::GetDeviceIdResponse>::FromFailure(
        std::move(_encode_request_result));
  }
  auto _call_result = ::fidl::Call<GetDeviceIdRequest, GetDeviceIdResponse>(
    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
  if (_call_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Device::GetDeviceIdResponse>::FromFailure(
        std::move(_call_result));
  }
  return ::fidl::Decode(std::move(_call_result.message));
}

template <>
Device::ResultOf::GetHubDeviceId_Impl<Device::GetHubDeviceIdResponse>::GetHubDeviceId_Impl(::zx::unowned_channel _client_end) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetHubDeviceIdRequest, ::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, GetHubDeviceIdRequest::PrimarySize);
  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetHubDeviceIdRequest));
  ::fidl::DecodedMessage<GetHubDeviceIdRequest> _decoded_request(std::move(_request_bytes));
  Super::SetResult(
      Device::InPlace::GetHubDeviceId(std::move(_client_end), Super::response_buffer()));
}

Device::ResultOf::GetHubDeviceId Device::SyncClient::GetHubDeviceId() {
    return ResultOf::GetHubDeviceId(::zx::unowned_channel(this->channel_));
}

Device::ResultOf::GetHubDeviceId Device::Call::GetHubDeviceId(::zx::unowned_channel _client_end) {
  return ResultOf::GetHubDeviceId(std::move(_client_end));
}

template <>
Device::UnownedResultOf::GetHubDeviceId_Impl<Device::GetHubDeviceIdResponse>::GetHubDeviceId_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetHubDeviceIdRequest)] = {};
  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
  memset(_request_buffer.data(), 0, GetHubDeviceIdRequest::PrimarySize);
  _request_buffer.set_actual(sizeof(GetHubDeviceIdRequest));
  ::fidl::DecodedMessage<GetHubDeviceIdRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      Device::InPlace::GetHubDeviceId(std::move(_client_end), std::move(_response_buffer)));
}

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

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

::fidl::DecodeResult<Device::GetHubDeviceIdResponse> Device::InPlace::GetHubDeviceId(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
  constexpr uint32_t _write_num_bytes = sizeof(GetHubDeviceIdRequest);
  ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
  ::fidl::BytePart _request_buffer = _write_bytes.view();
  _request_buffer.set_actual(_write_num_bytes);
  ::fidl::DecodedMessage<GetHubDeviceIdRequest> params(std::move(_request_buffer));
  Device::SetTransactionHeaderFor::GetHubDeviceIdRequest(params);
  auto _encode_request_result = ::fidl::Encode(std::move(params));
  if (_encode_request_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Device::GetHubDeviceIdResponse>::FromFailure(
        std::move(_encode_request_result));
  }
  auto _call_result = ::fidl::Call<GetHubDeviceIdRequest, GetHubDeviceIdResponse>(
    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
  if (_call_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Device::GetHubDeviceIdResponse>::FromFailure(
        std::move(_call_result));
  }
  return ::fidl::Decode(std::move(_call_result.message));
}

template <>
Device::ResultOf::GetConfiguration_Impl<Device::GetConfigurationResponse>::GetConfiguration_Impl(::zx::unowned_channel _client_end) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetConfigurationRequest, ::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, GetConfigurationRequest::PrimarySize);
  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetConfigurationRequest));
  ::fidl::DecodedMessage<GetConfigurationRequest> _decoded_request(std::move(_request_bytes));
  Super::SetResult(
      Device::InPlace::GetConfiguration(std::move(_client_end), Super::response_buffer()));
}

Device::ResultOf::GetConfiguration Device::SyncClient::GetConfiguration() {
    return ResultOf::GetConfiguration(::zx::unowned_channel(this->channel_));
}

Device::ResultOf::GetConfiguration Device::Call::GetConfiguration(::zx::unowned_channel _client_end) {
  return ResultOf::GetConfiguration(std::move(_client_end));
}

template <>
Device::UnownedResultOf::GetConfiguration_Impl<Device::GetConfigurationResponse>::GetConfiguration_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetConfigurationRequest)] = {};
  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
  memset(_request_buffer.data(), 0, GetConfigurationRequest::PrimarySize);
  _request_buffer.set_actual(sizeof(GetConfigurationRequest));
  ::fidl::DecodedMessage<GetConfigurationRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      Device::InPlace::GetConfiguration(std::move(_client_end), std::move(_response_buffer)));
}

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

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

::fidl::DecodeResult<Device::GetConfigurationResponse> Device::InPlace::GetConfiguration(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
  constexpr uint32_t _write_num_bytes = sizeof(GetConfigurationRequest);
  ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
  ::fidl::BytePart _request_buffer = _write_bytes.view();
  _request_buffer.set_actual(_write_num_bytes);
  ::fidl::DecodedMessage<GetConfigurationRequest> params(std::move(_request_buffer));
  Device::SetTransactionHeaderFor::GetConfigurationRequest(params);
  auto _encode_request_result = ::fidl::Encode(std::move(params));
  if (_encode_request_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Device::GetConfigurationResponse>::FromFailure(
        std::move(_encode_request_result));
  }
  auto _call_result = ::fidl::Call<GetConfigurationRequest, GetConfigurationResponse>(
    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
  if (_call_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Device::GetConfigurationResponse>::FromFailure(
        std::move(_call_result));
  }
  return ::fidl::Decode(std::move(_call_result.message));
}

template <>
Device::ResultOf::SetConfiguration_Impl<Device::SetConfigurationResponse>::SetConfiguration_Impl(::zx::unowned_channel _client_end, uint8_t configuration) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetConfigurationRequest, ::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, SetConfigurationRequest::PrimarySize);
  auto& _request = *reinterpret_cast<SetConfigurationRequest*>(_write_bytes);
  _request.configuration = std::move(configuration);
  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetConfigurationRequest));
  ::fidl::DecodedMessage<SetConfigurationRequest> _decoded_request(std::move(_request_bytes));
  Super::SetResult(
      Device::InPlace::SetConfiguration(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
}

Device::ResultOf::SetConfiguration Device::SyncClient::SetConfiguration(uint8_t configuration) {
    return ResultOf::SetConfiguration(::zx::unowned_channel(this->channel_), std::move(configuration));
}

Device::ResultOf::SetConfiguration Device::Call::SetConfiguration(::zx::unowned_channel _client_end, uint8_t configuration) {
  return ResultOf::SetConfiguration(std::move(_client_end), std::move(configuration));
}

template <>
Device::UnownedResultOf::SetConfiguration_Impl<Device::SetConfigurationResponse>::SetConfiguration_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint8_t configuration, ::fidl::BytePart _response_buffer) {
  if (_request_buffer.capacity() < SetConfigurationRequest::PrimarySize) {
    Super::SetFailure(::fidl::DecodeResult<SetConfigurationResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
    return;
  }
  memset(_request_buffer.data(), 0, SetConfigurationRequest::PrimarySize);
  auto& _request = *reinterpret_cast<SetConfigurationRequest*>(_request_buffer.data());
  _request.configuration = std::move(configuration);
  _request_buffer.set_actual(sizeof(SetConfigurationRequest));
  ::fidl::DecodedMessage<SetConfigurationRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      Device::InPlace::SetConfiguration(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
}

Device::UnownedResultOf::SetConfiguration Device::SyncClient::SetConfiguration(::fidl::BytePart _request_buffer, uint8_t configuration, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::SetConfiguration(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(configuration), std::move(_response_buffer));
}

Device::UnownedResultOf::SetConfiguration Device::Call::SetConfiguration(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint8_t configuration, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::SetConfiguration(std::move(_client_end), std::move(_request_buffer), std::move(configuration), std::move(_response_buffer));
}

::fidl::DecodeResult<Device::SetConfigurationResponse> Device::InPlace::SetConfiguration(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetConfigurationRequest> params, ::fidl::BytePart response_buffer) {
  Device::SetTransactionHeaderFor::SetConfigurationRequest(params);
  auto _encode_request_result = ::fidl::Encode(std::move(params));
  if (_encode_request_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Device::SetConfigurationResponse>::FromFailure(
        std::move(_encode_request_result));
  }
  auto _call_result = ::fidl::Call<SetConfigurationRequest, SetConfigurationResponse>(
    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
  if (_call_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Device::SetConfigurationResponse>::FromFailure(
        std::move(_call_result));
  }
  return ::fidl::Decode(std::move(_call_result.message));
}


bool Device::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);
  zx_status_t status = fidl_validate_txn_header(hdr);
  if (status != ZX_OK) {
    txn->Close(status);
    return true;
  }
  switch (hdr->ordinal) {
    case kDevice_GetDeviceSpeed_Ordinal:
    case kDevice_GetDeviceSpeed_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<GetDeviceSpeedRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      impl->GetDeviceSpeed(
          Interface::GetDeviceSpeedCompleter::Sync(txn));
      return true;
    }
    case kDevice_GetDeviceDescriptor_Ordinal:
    case kDevice_GetDeviceDescriptor_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<GetDeviceDescriptorRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      impl->GetDeviceDescriptor(
          Interface::GetDeviceDescriptorCompleter::Sync(txn));
      return true;
    }
    case kDevice_GetConfigurationDescriptorSize_Ordinal:
    case kDevice_GetConfigurationDescriptorSize_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<GetConfigurationDescriptorSizeRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->GetConfigurationDescriptorSize(std::move(message->config),
          Interface::GetConfigurationDescriptorSizeCompleter::Sync(txn));
      return true;
    }
    case kDevice_GetConfigurationDescriptor_Ordinal:
    case kDevice_GetConfigurationDescriptor_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<GetConfigurationDescriptorRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->GetConfigurationDescriptor(std::move(message->config),
          Interface::GetConfigurationDescriptorCompleter::Sync(txn));
      return true;
    }
    case kDevice_GetStringDescriptor_Ordinal:
    case kDevice_GetStringDescriptor_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<GetStringDescriptorRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->GetStringDescriptor(std::move(message->desc_id), std::move(message->lang_id),
          Interface::GetStringDescriptorCompleter::Sync(txn));
      return true;
    }
    case kDevice_SetInterface_Ordinal:
    case kDevice_SetInterface_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<SetInterfaceRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->SetInterface(std::move(message->interface_number), std::move(message->alt_setting),
          Interface::SetInterfaceCompleter::Sync(txn));
      return true;
    }
    case kDevice_GetDeviceId_Ordinal:
    case kDevice_GetDeviceId_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<GetDeviceIdRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      impl->GetDeviceId(
          Interface::GetDeviceIdCompleter::Sync(txn));
      return true;
    }
    case kDevice_GetHubDeviceId_Ordinal:
    case kDevice_GetHubDeviceId_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<GetHubDeviceIdRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      impl->GetHubDeviceId(
          Interface::GetHubDeviceIdCompleter::Sync(txn));
      return true;
    }
    case kDevice_GetConfiguration_Ordinal:
    case kDevice_GetConfiguration_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<GetConfigurationRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      impl->GetConfiguration(
          Interface::GetConfigurationCompleter::Sync(txn));
      return true;
    }
    case kDevice_SetConfiguration_Ordinal:
    case kDevice_SetConfiguration_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<SetConfigurationRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->SetConfiguration(std::move(message->configuration),
          Interface::SetConfigurationCompleter::Sync(txn));
      return true;
    }
    default: {
      return false;
    }
  }
}

bool Device::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 Device::Interface::GetDeviceSpeedCompleterBase::Reply(uint32_t speed) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetDeviceSpeedResponse, ::fidl::MessageDirection::kSending>();
  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
  auto& _response = *reinterpret_cast<GetDeviceSpeedResponse*>(_write_bytes);
  Device::SetTransactionHeaderFor::GetDeviceSpeedResponse(
      ::fidl::DecodedMessage<GetDeviceSpeedResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              GetDeviceSpeedResponse::PrimarySize,
              GetDeviceSpeedResponse::PrimarySize)));
  _response.speed = std::move(speed);
  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetDeviceSpeedResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<GetDeviceSpeedResponse>(std::move(_response_bytes)));
}

void Device::Interface::GetDeviceSpeedCompleterBase::Reply(::fidl::BytePart _buffer, uint32_t speed) {
  if (_buffer.capacity() < GetDeviceSpeedResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  auto& _response = *reinterpret_cast<GetDeviceSpeedResponse*>(_buffer.data());
  Device::SetTransactionHeaderFor::GetDeviceSpeedResponse(
      ::fidl::DecodedMessage<GetDeviceSpeedResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              GetDeviceSpeedResponse::PrimarySize,
              GetDeviceSpeedResponse::PrimarySize)));
  _response.speed = std::move(speed);
  _buffer.set_actual(sizeof(GetDeviceSpeedResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<GetDeviceSpeedResponse>(std::move(_buffer)));
}

void Device::Interface::GetDeviceSpeedCompleterBase::Reply(::fidl::DecodedMessage<GetDeviceSpeedResponse> params) {
  Device::SetTransactionHeaderFor::GetDeviceSpeedResponse(params);
  CompleterBase::SendReply(std::move(params));
}


void Device::Interface::GetDeviceDescriptorCompleterBase::Reply(::fidl::Array<uint8_t, 18> desc) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetDeviceDescriptorResponse, ::fidl::MessageDirection::kSending>();
  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
  auto& _response = *reinterpret_cast<GetDeviceDescriptorResponse*>(_write_bytes);
  Device::SetTransactionHeaderFor::GetDeviceDescriptorResponse(
      ::fidl::DecodedMessage<GetDeviceDescriptorResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              GetDeviceDescriptorResponse::PrimarySize,
              GetDeviceDescriptorResponse::PrimarySize)));
  _response.desc = std::move(desc);
  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetDeviceDescriptorResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<GetDeviceDescriptorResponse>(std::move(_response_bytes)));
}

void Device::Interface::GetDeviceDescriptorCompleterBase::Reply(::fidl::BytePart _buffer, ::fidl::Array<uint8_t, 18> desc) {
  if (_buffer.capacity() < GetDeviceDescriptorResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  auto& _response = *reinterpret_cast<GetDeviceDescriptorResponse*>(_buffer.data());
  Device::SetTransactionHeaderFor::GetDeviceDescriptorResponse(
      ::fidl::DecodedMessage<GetDeviceDescriptorResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              GetDeviceDescriptorResponse::PrimarySize,
              GetDeviceDescriptorResponse::PrimarySize)));
  _response.desc = std::move(desc);
  _buffer.set_actual(sizeof(GetDeviceDescriptorResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<GetDeviceDescriptorResponse>(std::move(_buffer)));
}

void Device::Interface::GetDeviceDescriptorCompleterBase::Reply(::fidl::DecodedMessage<GetDeviceDescriptorResponse> params) {
  Device::SetTransactionHeaderFor::GetDeviceDescriptorResponse(params);
  CompleterBase::SendReply(std::move(params));
}


void Device::Interface::GetConfigurationDescriptorSizeCompleterBase::Reply(int32_t s, uint16_t size) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetConfigurationDescriptorSizeResponse, ::fidl::MessageDirection::kSending>();
  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
  auto& _response = *reinterpret_cast<GetConfigurationDescriptorSizeResponse*>(_write_bytes);
  Device::SetTransactionHeaderFor::GetConfigurationDescriptorSizeResponse(
      ::fidl::DecodedMessage<GetConfigurationDescriptorSizeResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              GetConfigurationDescriptorSizeResponse::PrimarySize,
              GetConfigurationDescriptorSizeResponse::PrimarySize)));
  _response.s = std::move(s);
  _response.size = std::move(size);
  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetConfigurationDescriptorSizeResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<GetConfigurationDescriptorSizeResponse>(std::move(_response_bytes)));
}

void Device::Interface::GetConfigurationDescriptorSizeCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, uint16_t size) {
  if (_buffer.capacity() < GetConfigurationDescriptorSizeResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  auto& _response = *reinterpret_cast<GetConfigurationDescriptorSizeResponse*>(_buffer.data());
  Device::SetTransactionHeaderFor::GetConfigurationDescriptorSizeResponse(
      ::fidl::DecodedMessage<GetConfigurationDescriptorSizeResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              GetConfigurationDescriptorSizeResponse::PrimarySize,
              GetConfigurationDescriptorSizeResponse::PrimarySize)));
  _response.s = std::move(s);
  _response.size = std::move(size);
  _buffer.set_actual(sizeof(GetConfigurationDescriptorSizeResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<GetConfigurationDescriptorSizeResponse>(std::move(_buffer)));
}

void Device::Interface::GetConfigurationDescriptorSizeCompleterBase::Reply(::fidl::DecodedMessage<GetConfigurationDescriptorSizeResponse> params) {
  Device::SetTransactionHeaderFor::GetConfigurationDescriptorSizeResponse(params);
  CompleterBase::SendReply(std::move(params));
}


void Device::Interface::GetConfigurationDescriptorCompleterBase::Reply(int32_t s, ::fidl::VectorView<uint8_t> desc) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetConfigurationDescriptorResponse, ::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();
  GetConfigurationDescriptorResponse _response = {};
  Device::SetTransactionHeaderFor::GetConfigurationDescriptorResponse(
      ::fidl::DecodedMessage<GetConfigurationDescriptorResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              GetConfigurationDescriptorResponse::PrimarySize,
              GetConfigurationDescriptorResponse::PrimarySize)));
  _response.s = std::move(s);
  _response.desc = std::move(desc);
  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 Device::Interface::GetConfigurationDescriptorCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, ::fidl::VectorView<uint8_t> desc) {
  if (_buffer.capacity() < GetConfigurationDescriptorResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  GetConfigurationDescriptorResponse _response = {};
  Device::SetTransactionHeaderFor::GetConfigurationDescriptorResponse(
      ::fidl::DecodedMessage<GetConfigurationDescriptorResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              GetConfigurationDescriptorResponse::PrimarySize,
              GetConfigurationDescriptorResponse::PrimarySize)));
  _response.s = std::move(s);
  _response.desc = std::move(desc);
  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 Device::Interface::GetConfigurationDescriptorCompleterBase::Reply(::fidl::DecodedMessage<GetConfigurationDescriptorResponse> params) {
  Device::SetTransactionHeaderFor::GetConfigurationDescriptorResponse(params);
  CompleterBase::SendReply(std::move(params));
}


void Device::Interface::GetStringDescriptorCompleterBase::Reply(int32_t s, ::fidl::StringView desc, uint16_t actual_lang_id) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetStringDescriptorResponse, ::fidl::MessageDirection::kSending>();
  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
  GetStringDescriptorResponse _response = {};
  Device::SetTransactionHeaderFor::GetStringDescriptorResponse(
      ::fidl::DecodedMessage<GetStringDescriptorResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              GetStringDescriptorResponse::PrimarySize,
              GetStringDescriptorResponse::PrimarySize)));
  _response.s = std::move(s);
  _response.desc = std::move(desc);
  _response.actual_lang_id = std::move(actual_lang_id);
  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 Device::Interface::GetStringDescriptorCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, ::fidl::StringView desc, uint16_t actual_lang_id) {
  if (_buffer.capacity() < GetStringDescriptorResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  GetStringDescriptorResponse _response = {};
  Device::SetTransactionHeaderFor::GetStringDescriptorResponse(
      ::fidl::DecodedMessage<GetStringDescriptorResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              GetStringDescriptorResponse::PrimarySize,
              GetStringDescriptorResponse::PrimarySize)));
  _response.s = std::move(s);
  _response.desc = std::move(desc);
  _response.actual_lang_id = std::move(actual_lang_id);
  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 Device::Interface::GetStringDescriptorCompleterBase::Reply(::fidl::DecodedMessage<GetStringDescriptorResponse> params) {
  Device::SetTransactionHeaderFor::GetStringDescriptorResponse(params);
  CompleterBase::SendReply(std::move(params));
}


void Device::Interface::SetInterfaceCompleterBase::Reply(int32_t s) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetInterfaceResponse, ::fidl::MessageDirection::kSending>();
  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
  auto& _response = *reinterpret_cast<SetInterfaceResponse*>(_write_bytes);
  Device::SetTransactionHeaderFor::SetInterfaceResponse(
      ::fidl::DecodedMessage<SetInterfaceResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              SetInterfaceResponse::PrimarySize,
              SetInterfaceResponse::PrimarySize)));
  _response.s = std::move(s);
  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetInterfaceResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<SetInterfaceResponse>(std::move(_response_bytes)));
}

void Device::Interface::SetInterfaceCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
  if (_buffer.capacity() < SetInterfaceResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  auto& _response = *reinterpret_cast<SetInterfaceResponse*>(_buffer.data());
  Device::SetTransactionHeaderFor::SetInterfaceResponse(
      ::fidl::DecodedMessage<SetInterfaceResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              SetInterfaceResponse::PrimarySize,
              SetInterfaceResponse::PrimarySize)));
  _response.s = std::move(s);
  _buffer.set_actual(sizeof(SetInterfaceResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<SetInterfaceResponse>(std::move(_buffer)));
}

void Device::Interface::SetInterfaceCompleterBase::Reply(::fidl::DecodedMessage<SetInterfaceResponse> params) {
  Device::SetTransactionHeaderFor::SetInterfaceResponse(params);
  CompleterBase::SendReply(std::move(params));
}


void Device::Interface::GetDeviceIdCompleterBase::Reply(uint32_t device_id) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetDeviceIdResponse, ::fidl::MessageDirection::kSending>();
  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
  auto& _response = *reinterpret_cast<GetDeviceIdResponse*>(_write_bytes);
  Device::SetTransactionHeaderFor::GetDeviceIdResponse(
      ::fidl::DecodedMessage<GetDeviceIdResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              GetDeviceIdResponse::PrimarySize,
              GetDeviceIdResponse::PrimarySize)));
  _response.device_id = std::move(device_id);
  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetDeviceIdResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<GetDeviceIdResponse>(std::move(_response_bytes)));
}

void Device::Interface::GetDeviceIdCompleterBase::Reply(::fidl::BytePart _buffer, uint32_t device_id) {
  if (_buffer.capacity() < GetDeviceIdResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  auto& _response = *reinterpret_cast<GetDeviceIdResponse*>(_buffer.data());
  Device::SetTransactionHeaderFor::GetDeviceIdResponse(
      ::fidl::DecodedMessage<GetDeviceIdResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              GetDeviceIdResponse::PrimarySize,
              GetDeviceIdResponse::PrimarySize)));
  _response.device_id = std::move(device_id);
  _buffer.set_actual(sizeof(GetDeviceIdResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<GetDeviceIdResponse>(std::move(_buffer)));
}

void Device::Interface::GetDeviceIdCompleterBase::Reply(::fidl::DecodedMessage<GetDeviceIdResponse> params) {
  Device::SetTransactionHeaderFor::GetDeviceIdResponse(params);
  CompleterBase::SendReply(std::move(params));
}


void Device::Interface::GetHubDeviceIdCompleterBase::Reply(uint32_t hub_device_id) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetHubDeviceIdResponse, ::fidl::MessageDirection::kSending>();
  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
  auto& _response = *reinterpret_cast<GetHubDeviceIdResponse*>(_write_bytes);
  Device::SetTransactionHeaderFor::GetHubDeviceIdResponse(
      ::fidl::DecodedMessage<GetHubDeviceIdResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              GetHubDeviceIdResponse::PrimarySize,
              GetHubDeviceIdResponse::PrimarySize)));
  _response.hub_device_id = std::move(hub_device_id);
  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetHubDeviceIdResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<GetHubDeviceIdResponse>(std::move(_response_bytes)));
}

void Device::Interface::GetHubDeviceIdCompleterBase::Reply(::fidl::BytePart _buffer, uint32_t hub_device_id) {
  if (_buffer.capacity() < GetHubDeviceIdResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  auto& _response = *reinterpret_cast<GetHubDeviceIdResponse*>(_buffer.data());
  Device::SetTransactionHeaderFor::GetHubDeviceIdResponse(
      ::fidl::DecodedMessage<GetHubDeviceIdResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              GetHubDeviceIdResponse::PrimarySize,
              GetHubDeviceIdResponse::PrimarySize)));
  _response.hub_device_id = std::move(hub_device_id);
  _buffer.set_actual(sizeof(GetHubDeviceIdResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<GetHubDeviceIdResponse>(std::move(_buffer)));
}

void Device::Interface::GetHubDeviceIdCompleterBase::Reply(::fidl::DecodedMessage<GetHubDeviceIdResponse> params) {
  Device::SetTransactionHeaderFor::GetHubDeviceIdResponse(params);
  CompleterBase::SendReply(std::move(params));
}


void Device::Interface::GetConfigurationCompleterBase::Reply(uint8_t configuration) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetConfigurationResponse, ::fidl::MessageDirection::kSending>();
  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
  auto& _response = *reinterpret_cast<GetConfigurationResponse*>(_write_bytes);
  Device::SetTransactionHeaderFor::GetConfigurationResponse(
      ::fidl::DecodedMessage<GetConfigurationResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              GetConfigurationResponse::PrimarySize,
              GetConfigurationResponse::PrimarySize)));
  _response.configuration = std::move(configuration);
  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetConfigurationResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<GetConfigurationResponse>(std::move(_response_bytes)));
}

void Device::Interface::GetConfigurationCompleterBase::Reply(::fidl::BytePart _buffer, uint8_t configuration) {
  if (_buffer.capacity() < GetConfigurationResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  auto& _response = *reinterpret_cast<GetConfigurationResponse*>(_buffer.data());
  Device::SetTransactionHeaderFor::GetConfigurationResponse(
      ::fidl::DecodedMessage<GetConfigurationResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              GetConfigurationResponse::PrimarySize,
              GetConfigurationResponse::PrimarySize)));
  _response.configuration = std::move(configuration);
  _buffer.set_actual(sizeof(GetConfigurationResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<GetConfigurationResponse>(std::move(_buffer)));
}

void Device::Interface::GetConfigurationCompleterBase::Reply(::fidl::DecodedMessage<GetConfigurationResponse> params) {
  Device::SetTransactionHeaderFor::GetConfigurationResponse(params);
  CompleterBase::SendReply(std::move(params));
}


void Device::Interface::SetConfigurationCompleterBase::Reply(int32_t s) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetConfigurationResponse, ::fidl::MessageDirection::kSending>();
  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
  auto& _response = *reinterpret_cast<SetConfigurationResponse*>(_write_bytes);
  Device::SetTransactionHeaderFor::SetConfigurationResponse(
      ::fidl::DecodedMessage<SetConfigurationResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              SetConfigurationResponse::PrimarySize,
              SetConfigurationResponse::PrimarySize)));
  _response.s = std::move(s);
  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetConfigurationResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<SetConfigurationResponse>(std::move(_response_bytes)));
}

void Device::Interface::SetConfigurationCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
  if (_buffer.capacity() < SetConfigurationResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  auto& _response = *reinterpret_cast<SetConfigurationResponse*>(_buffer.data());
  Device::SetTransactionHeaderFor::SetConfigurationResponse(
      ::fidl::DecodedMessage<SetConfigurationResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              SetConfigurationResponse::PrimarySize,
              SetConfigurationResponse::PrimarySize)));
  _response.s = std::move(s);
  _buffer.set_actual(sizeof(SetConfigurationResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<SetConfigurationResponse>(std::move(_buffer)));
}

void Device::Interface::SetConfigurationCompleterBase::Reply(::fidl::DecodedMessage<SetConfigurationResponse> params) {
  Device::SetTransactionHeaderFor::SetConfigurationResponse(params);
  CompleterBase::SendReply(std::move(params));
}



void Device::SetTransactionHeaderFor::GetDeviceSpeedRequest(const ::fidl::DecodedMessage<Device::GetDeviceSpeedRequest>& _msg) {
  fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetDeviceSpeed_GenOrdinal);
  _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
}
void Device::SetTransactionHeaderFor::GetDeviceSpeedResponse(const ::fidl::DecodedMessage<Device::GetDeviceSpeedResponse>& _msg) {
  fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetDeviceSpeed_GenOrdinal);
  _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
}

void Device::SetTransactionHeaderFor::GetDeviceDescriptorRequest(const ::fidl::DecodedMessage<Device::GetDeviceDescriptorRequest>& _msg) {
  fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetDeviceDescriptor_GenOrdinal);
  _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
}
void Device::SetTransactionHeaderFor::GetDeviceDescriptorResponse(const ::fidl::DecodedMessage<Device::GetDeviceDescriptorResponse>& _msg) {
  fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetDeviceDescriptor_GenOrdinal);
  _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
}

void Device::SetTransactionHeaderFor::GetConfigurationDescriptorSizeRequest(const ::fidl::DecodedMessage<Device::GetConfigurationDescriptorSizeRequest>& _msg) {
  fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetConfigurationDescriptorSize_GenOrdinal);
  _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
}
void Device::SetTransactionHeaderFor::GetConfigurationDescriptorSizeResponse(const ::fidl::DecodedMessage<Device::GetConfigurationDescriptorSizeResponse>& _msg) {
  fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetConfigurationDescriptorSize_GenOrdinal);
  _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
}

void Device::SetTransactionHeaderFor::GetConfigurationDescriptorRequest(const ::fidl::DecodedMessage<Device::GetConfigurationDescriptorRequest>& _msg) {
  fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetConfigurationDescriptor_GenOrdinal);
  _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
}
void Device::SetTransactionHeaderFor::GetConfigurationDescriptorResponse(const ::fidl::DecodedMessage<Device::GetConfigurationDescriptorResponse>& _msg) {
  fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetConfigurationDescriptor_GenOrdinal);
  _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
}

void Device::SetTransactionHeaderFor::GetStringDescriptorRequest(const ::fidl::DecodedMessage<Device::GetStringDescriptorRequest>& _msg) {
  fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetStringDescriptor_GenOrdinal);
  _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
}
void Device::SetTransactionHeaderFor::GetStringDescriptorResponse(const ::fidl::DecodedMessage<Device::GetStringDescriptorResponse>& _msg) {
  fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetStringDescriptor_GenOrdinal);
  _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
}

void Device::SetTransactionHeaderFor::SetInterfaceRequest(const ::fidl::DecodedMessage<Device::SetInterfaceRequest>& _msg) {
  fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_SetInterface_GenOrdinal);
  _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
}
void Device::SetTransactionHeaderFor::SetInterfaceResponse(const ::fidl::DecodedMessage<Device::SetInterfaceResponse>& _msg) {
  fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_SetInterface_GenOrdinal);
  _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
}

void Device::SetTransactionHeaderFor::GetDeviceIdRequest(const ::fidl::DecodedMessage<Device::GetDeviceIdRequest>& _msg) {
  fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetDeviceId_GenOrdinal);
  _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
}
void Device::SetTransactionHeaderFor::GetDeviceIdResponse(const ::fidl::DecodedMessage<Device::GetDeviceIdResponse>& _msg) {
  fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetDeviceId_GenOrdinal);
  _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
}

void Device::SetTransactionHeaderFor::GetHubDeviceIdRequest(const ::fidl::DecodedMessage<Device::GetHubDeviceIdRequest>& _msg) {
  fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetHubDeviceId_GenOrdinal);
  _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
}
void Device::SetTransactionHeaderFor::GetHubDeviceIdResponse(const ::fidl::DecodedMessage<Device::GetHubDeviceIdResponse>& _msg) {
  fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetHubDeviceId_GenOrdinal);
  _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
}

void Device::SetTransactionHeaderFor::GetConfigurationRequest(const ::fidl::DecodedMessage<Device::GetConfigurationRequest>& _msg) {
  fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetConfiguration_GenOrdinal);
  _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
}
void Device::SetTransactionHeaderFor::GetConfigurationResponse(const ::fidl::DecodedMessage<Device::GetConfigurationResponse>& _msg) {
  fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetConfiguration_GenOrdinal);
  _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
}

void Device::SetTransactionHeaderFor::SetConfigurationRequest(const ::fidl::DecodedMessage<Device::SetConfigurationRequest>& _msg) {
  fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_SetConfiguration_GenOrdinal);
  _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
}
void Device::SetTransactionHeaderFor::SetConfigurationResponse(const ::fidl::DecodedMessage<Device::SetConfigurationResponse>& _msg) {
  fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_SetConfiguration_GenOrdinal);
  _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
}

}  // namespace device
}  // namespace usb
}  // namespace hardware
}  // namespace fuchsia
}  // namespace llcpp