zircon/system/fidl/fuchsia-hardware-input/gen/llcpp/fidl.cc

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

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

namespace llcpp {

namespace fuchsia {
namespace hardware {
namespace input {

namespace {

[[maybe_unused]]
constexpr uint64_t kDevice_GetBootProtocol_Ordinal = 0x47ac8ff500000000lu;
[[maybe_unused]]
constexpr uint64_t kDevice_GetBootProtocol_GenOrdinal = 0x54f14ad662c6899flu;
extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetBootProtocolRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetBootProtocolResponseTable;
[[maybe_unused]]
constexpr uint64_t kDevice_GetDeviceIds_Ordinal = 0x2213b60500000000lu;
[[maybe_unused]]
constexpr uint64_t kDevice_GetDeviceIds_GenOrdinal = 0x3b2d696caef3c3e0lu;
extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetDeviceIdsRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetDeviceIdsResponseTable;
[[maybe_unused]]
constexpr uint64_t kDevice_GetReportDescSize_Ordinal = 0x312dbbe100000000lu;
[[maybe_unused]]
constexpr uint64_t kDevice_GetReportDescSize_GenOrdinal = 0x2fba99f2b2c6cd2flu;
extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetReportDescSizeRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetReportDescSizeResponseTable;
[[maybe_unused]]
constexpr uint64_t kDevice_GetReportDesc_Ordinal = 0x6ae0c2f200000000lu;
[[maybe_unused]]
constexpr uint64_t kDevice_GetReportDesc_GenOrdinal = 0x7fe4aff57d9019f8lu;
extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetReportDescRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetReportDescResponseTable;
[[maybe_unused]]
constexpr uint64_t kDevice_GetNumReports_Ordinal = 0x79b0ee200000000lu;
[[maybe_unused]]
constexpr uint64_t kDevice_GetNumReports_GenOrdinal = 0x57de20184ed5ba42lu;
extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetNumReportsRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetNumReportsResponseTable;
[[maybe_unused]]
constexpr uint64_t kDevice_GetReportIds_Ordinal = 0x74f7d94f00000000lu;
[[maybe_unused]]
constexpr uint64_t kDevice_GetReportIds_GenOrdinal = 0x620319ad9bb99853lu;
extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetReportIdsRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetReportIdsResponseTable;
[[maybe_unused]]
constexpr uint64_t kDevice_GetReportSize_Ordinal = 0x22e76cac00000000lu;
[[maybe_unused]]
constexpr uint64_t kDevice_GetReportSize_GenOrdinal = 0x436d9de68d4e8b14lu;
extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetReportSizeRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetReportSizeResponseTable;
[[maybe_unused]]
constexpr uint64_t kDevice_GetMaxInputReportSize_Ordinal = 0x4e9ab77400000000lu;
[[maybe_unused]]
constexpr uint64_t kDevice_GetMaxInputReportSize_GenOrdinal = 0x1c794da7454e1b4elu;
extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetMaxInputReportSizeRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetMaxInputReportSizeResponseTable;
[[maybe_unused]]
constexpr uint64_t kDevice_GetReports_Ordinal = 0x172821a100000000lu;
[[maybe_unused]]
constexpr uint64_t kDevice_GetReports_GenOrdinal = 0x620f664991c7c95dlu;
extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetReportsRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetReportsResponseTable;
[[maybe_unused]]
constexpr uint64_t kDevice_GetReportsEvent_Ordinal = 0x6682043100000000lu;
[[maybe_unused]]
constexpr uint64_t kDevice_GetReportsEvent_GenOrdinal = 0x6198970f9308041clu;
extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetReportsEventRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetReportsEventResponseTable;
[[maybe_unused]]
constexpr uint64_t kDevice_GetReport_Ordinal = 0x2a267cd000000000lu;
[[maybe_unused]]
constexpr uint64_t kDevice_GetReport_GenOrdinal = 0x5b2a44555defd970lu;
extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetReportRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetReportResponseTable;
[[maybe_unused]]
constexpr uint64_t kDevice_SetReport_Ordinal = 0x14ff63cb00000000lu;
[[maybe_unused]]
constexpr uint64_t kDevice_SetReport_GenOrdinal = 0x51cc85eb4e769eelu;
extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceSetReportRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceSetReportResponseTable;
[[maybe_unused]]
constexpr uint64_t kDevice_SetTraceId_Ordinal = 0x67de25bb00000000lu;
[[maybe_unused]]
constexpr uint64_t kDevice_SetTraceId_GenOrdinal = 0x7fe8815219c66700lu;
extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceSetTraceIdRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceSetTraceIdResponseTable;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

template <>
Device::ResultOf::GetReportSize_Impl<Device::GetReportSizeResponse>::GetReportSize_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetReportSizeRequest, ::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, GetReportSizeRequest::PrimarySize);
  auto& _request = *reinterpret_cast<GetReportSizeRequest*>(_write_bytes);
  _request.type = std::move(type);
  _request.id = std::move(id);
  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetReportSizeRequest));
  ::fidl::DecodedMessage<GetReportSizeRequest> _decoded_request(std::move(_request_bytes));
  Super::SetResult(
      Device::InPlace::GetReportSize(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
}

Device::ResultOf::GetReportSize Device::SyncClient::GetReportSize(::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id) {
    return ResultOf::GetReportSize(::zx::unowned_channel(this->channel_), std::move(type), std::move(id));
}

Device::ResultOf::GetReportSize Device::Call::GetReportSize(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id) {
  return ResultOf::GetReportSize(std::move(_client_end), std::move(type), std::move(id));
}

template <>
Device::UnownedResultOf::GetReportSize_Impl<Device::GetReportSizeResponse>::GetReportSize_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id, ::fidl::BytePart _response_buffer) {
  if (_request_buffer.capacity() < GetReportSizeRequest::PrimarySize) {
    Super::SetFailure(::fidl::DecodeResult<GetReportSizeResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
    return;
  }
  memset(_request_buffer.data(), 0, GetReportSizeRequest::PrimarySize);
  auto& _request = *reinterpret_cast<GetReportSizeRequest*>(_request_buffer.data());
  _request.type = std::move(type);
  _request.id = std::move(id);
  _request_buffer.set_actual(sizeof(GetReportSizeRequest));
  ::fidl::DecodedMessage<GetReportSizeRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      Device::InPlace::GetReportSize(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
}

Device::UnownedResultOf::GetReportSize Device::SyncClient::GetReportSize(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::GetReportSize(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(type), std::move(id), std::move(_response_buffer));
}

Device::UnownedResultOf::GetReportSize Device::Call::GetReportSize(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::GetReportSize(std::move(_client_end), std::move(_request_buffer), std::move(type), std::move(id), std::move(_response_buffer));
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

template <>
Device::ResultOf::GetReport_Impl<Device::GetReportResponse>::GetReport_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetReportRequest, ::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, GetReportRequest::PrimarySize);
  auto& _request = *reinterpret_cast<GetReportRequest*>(_write_bytes);
  _request.type = std::move(type);
  _request.id = std::move(id);
  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetReportRequest));
  ::fidl::DecodedMessage<GetReportRequest> _decoded_request(std::move(_request_bytes));
  Super::SetResult(
      Device::InPlace::GetReport(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
}

Device::ResultOf::GetReport Device::SyncClient::GetReport(::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id) {
    return ResultOf::GetReport(::zx::unowned_channel(this->channel_), std::move(type), std::move(id));
}

Device::ResultOf::GetReport Device::Call::GetReport(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id) {
  return ResultOf::GetReport(std::move(_client_end), std::move(type), std::move(id));
}

template <>
Device::UnownedResultOf::GetReport_Impl<Device::GetReportResponse>::GetReport_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id, ::fidl::BytePart _response_buffer) {
  if (_request_buffer.capacity() < GetReportRequest::PrimarySize) {
    Super::SetFailure(::fidl::DecodeResult<GetReportResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
    return;
  }
  memset(_request_buffer.data(), 0, GetReportRequest::PrimarySize);
  auto& _request = *reinterpret_cast<GetReportRequest*>(_request_buffer.data());
  _request.type = std::move(type);
  _request.id = std::move(id);
  _request_buffer.set_actual(sizeof(GetReportRequest));
  ::fidl::DecodedMessage<GetReportRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      Device::InPlace::GetReport(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
}

Device::UnownedResultOf::GetReport Device::SyncClient::GetReport(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::GetReport(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(type), std::move(id), std::move(_response_buffer));
}

Device::UnownedResultOf::GetReport Device::Call::GetReport(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::GetReport(std::move(_client_end), std::move(_request_buffer), std::move(type), std::move(id), std::move(_response_buffer));
}

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

template <>
Device::ResultOf::SetReport_Impl<Device::SetReportResponse>::SetReport_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id, ::fidl::VectorView<uint8_t> report) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetReportRequest, ::fidl::MessageDirection::kSending>();
  std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
  auto& _write_bytes_array = *_write_bytes_boxed;
  SetReportRequest _request = {};
  _request.type = std::move(type);
  _request.id = std::move(id);
  _request.report = std::move(report);
  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<SetReportRequest> _decoded_request = std::move(_linearize_result.message);
  Super::SetResult(
      Device::InPlace::SetReport(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
}

Device::ResultOf::SetReport Device::SyncClient::SetReport(::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id, ::fidl::VectorView<uint8_t> report) {
    return ResultOf::SetReport(::zx::unowned_channel(this->channel_), std::move(type), std::move(id), std::move(report));
}

Device::ResultOf::SetReport Device::Call::SetReport(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id, ::fidl::VectorView<uint8_t> report) {
  return ResultOf::SetReport(std::move(_client_end), std::move(type), std::move(id), std::move(report));
}

template <>
Device::UnownedResultOf::SetReport_Impl<Device::SetReportResponse>::SetReport_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id, ::fidl::VectorView<uint8_t> report, ::fidl::BytePart _response_buffer) {
  if (_request_buffer.capacity() < SetReportRequest::PrimarySize) {
    Super::SetFailure(::fidl::DecodeResult<SetReportResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
    return;
  }
  SetReportRequest _request = {};
  _request.type = std::move(type);
  _request.id = std::move(id);
  _request.report = std::move(report);
  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<SetReportRequest> _decoded_request = std::move(_linearize_result.message);
  Super::SetResult(
      Device::InPlace::SetReport(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
}

Device::UnownedResultOf::SetReport Device::SyncClient::SetReport(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id, ::fidl::VectorView<uint8_t> report, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::SetReport(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(type), std::move(id), std::move(report), std::move(_response_buffer));
}

Device::UnownedResultOf::SetReport Device::Call::SetReport(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id, ::fidl::VectorView<uint8_t> report, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::SetReport(std::move(_client_end), std::move(_request_buffer), std::move(type), std::move(id), std::move(report), std::move(_response_buffer));
}

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


Device::ResultOf::SetTraceId_Impl::SetTraceId_Impl(::zx::unowned_channel _client_end, uint32_t id) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetTraceIdRequest, ::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, SetTraceIdRequest::PrimarySize);
  auto& _request = *reinterpret_cast<SetTraceIdRequest*>(_write_bytes);
  _request.id = std::move(id);
  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetTraceIdRequest));
  ::fidl::DecodedMessage<SetTraceIdRequest> _decoded_request(std::move(_request_bytes));
  Super::operator=(
      Device::InPlace::SetTraceId(std::move(_client_end), std::move(_decoded_request)));
}

Device::ResultOf::SetTraceId Device::SyncClient::SetTraceId(uint32_t id) {
    return ResultOf::SetTraceId(::zx::unowned_channel(this->channel_), std::move(id));
}

Device::ResultOf::SetTraceId Device::Call::SetTraceId(::zx::unowned_channel _client_end, uint32_t id) {
  return ResultOf::SetTraceId(std::move(_client_end), std::move(id));
}


Device::UnownedResultOf::SetTraceId_Impl::SetTraceId_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t id) {
  if (_request_buffer.capacity() < SetTraceIdRequest::PrimarySize) {
    Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
    Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
    return;
  }
  memset(_request_buffer.data(), 0, SetTraceIdRequest::PrimarySize);
  auto& _request = *reinterpret_cast<SetTraceIdRequest*>(_request_buffer.data());
  _request.id = std::move(id);
  _request_buffer.set_actual(sizeof(SetTraceIdRequest));
  ::fidl::DecodedMessage<SetTraceIdRequest> _decoded_request(std::move(_request_buffer));
  Super::operator=(
      Device::InPlace::SetTraceId(std::move(_client_end), std::move(_decoded_request)));
}

Device::UnownedResultOf::SetTraceId Device::SyncClient::SetTraceId(::fidl::BytePart _request_buffer, uint32_t id) {
  return UnownedResultOf::SetTraceId(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(id));
}

Device::UnownedResultOf::SetTraceId Device::Call::SetTraceId(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t id) {
  return UnownedResultOf::SetTraceId(std::move(_client_end), std::move(_request_buffer), std::move(id));
}

::fidl::internal::StatusAndError Device::InPlace::SetTraceId(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetTraceIdRequest> params) {
  Device::SetTransactionHeaderFor::SetTraceIdRequest(params);
  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 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_GetBootProtocol_Ordinal:
    case kDevice_GetBootProtocol_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<GetBootProtocolRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      impl->GetBootProtocol(
          Interface::GetBootProtocolCompleter::Sync(txn));
      return true;
    }
    case kDevice_GetDeviceIds_Ordinal:
    case kDevice_GetDeviceIds_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<GetDeviceIdsRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      impl->GetDeviceIds(
          Interface::GetDeviceIdsCompleter::Sync(txn));
      return true;
    }
    case kDevice_GetReportDescSize_Ordinal:
    case kDevice_GetReportDescSize_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<GetReportDescSizeRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      impl->GetReportDescSize(
          Interface::GetReportDescSizeCompleter::Sync(txn));
      return true;
    }
    case kDevice_GetReportDesc_Ordinal:
    case kDevice_GetReportDesc_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<GetReportDescRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      impl->GetReportDesc(
          Interface::GetReportDescCompleter::Sync(txn));
      return true;
    }
    case kDevice_GetNumReports_Ordinal:
    case kDevice_GetNumReports_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<GetNumReportsRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      impl->GetNumReports(
          Interface::GetNumReportsCompleter::Sync(txn));
      return true;
    }
    case kDevice_GetReportIds_Ordinal:
    case kDevice_GetReportIds_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<GetReportIdsRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      impl->GetReportIds(
          Interface::GetReportIdsCompleter::Sync(txn));
      return true;
    }
    case kDevice_GetReportSize_Ordinal:
    case kDevice_GetReportSize_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<GetReportSizeRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->GetReportSize(std::move(message->type), std::move(message->id),
          Interface::GetReportSizeCompleter::Sync(txn));
      return true;
    }
    case kDevice_GetMaxInputReportSize_Ordinal:
    case kDevice_GetMaxInputReportSize_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<GetMaxInputReportSizeRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      impl->GetMaxInputReportSize(
          Interface::GetMaxInputReportSizeCompleter::Sync(txn));
      return true;
    }
    case kDevice_GetReports_Ordinal:
    case kDevice_GetReports_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<GetReportsRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      impl->GetReports(
          Interface::GetReportsCompleter::Sync(txn));
      return true;
    }
    case kDevice_GetReportsEvent_Ordinal:
    case kDevice_GetReportsEvent_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<GetReportsEventRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      impl->GetReportsEvent(
          Interface::GetReportsEventCompleter::Sync(txn));
      return true;
    }
    case kDevice_GetReport_Ordinal:
    case kDevice_GetReport_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<GetReportRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->GetReport(std::move(message->type), std::move(message->id),
          Interface::GetReportCompleter::Sync(txn));
      return true;
    }
    case kDevice_SetReport_Ordinal:
    case kDevice_SetReport_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<SetReportRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->SetReport(std::move(message->type), std::move(message->id), std::move(message->report),
          Interface::SetReportCompleter::Sync(txn));
      return true;
    }
    case kDevice_SetTraceId_Ordinal:
    case kDevice_SetTraceId_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<SetTraceIdRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->SetTraceId(std::move(message->id),
          Interface::SetTraceIdCompleter::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::GetBootProtocolCompleterBase::Reply(::llcpp::fuchsia::hardware::input::BootProtocol protocol) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetBootProtocolResponse, ::fidl::MessageDirection::kSending>();
  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
  auto& _response = *reinterpret_cast<GetBootProtocolResponse*>(_write_bytes);
  Device::SetTransactionHeaderFor::GetBootProtocolResponse(
      ::fidl::DecodedMessage<GetBootProtocolResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              GetBootProtocolResponse::PrimarySize,
              GetBootProtocolResponse::PrimarySize)));
  _response.protocol = std::move(protocol);
  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetBootProtocolResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<GetBootProtocolResponse>(std::move(_response_bytes)));
}

void Device::Interface::GetBootProtocolCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::input::BootProtocol protocol) {
  if (_buffer.capacity() < GetBootProtocolResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  auto& _response = *reinterpret_cast<GetBootProtocolResponse*>(_buffer.data());
  Device::SetTransactionHeaderFor::GetBootProtocolResponse(
      ::fidl::DecodedMessage<GetBootProtocolResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              GetBootProtocolResponse::PrimarySize,
              GetBootProtocolResponse::PrimarySize)));
  _response.protocol = std::move(protocol);
  _buffer.set_actual(sizeof(GetBootProtocolResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<GetBootProtocolResponse>(std::move(_buffer)));
}

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


void Device::Interface::GetDeviceIdsCompleterBase::Reply(::llcpp::fuchsia::hardware::input::DeviceIds ids) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetDeviceIdsResponse, ::fidl::MessageDirection::kSending>();
  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
  auto& _response = *reinterpret_cast<GetDeviceIdsResponse*>(_write_bytes);
  Device::SetTransactionHeaderFor::GetDeviceIdsResponse(
      ::fidl::DecodedMessage<GetDeviceIdsResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              GetDeviceIdsResponse::PrimarySize,
              GetDeviceIdsResponse::PrimarySize)));
  _response.ids = std::move(ids);
  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetDeviceIdsResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<GetDeviceIdsResponse>(std::move(_response_bytes)));
}

void Device::Interface::GetDeviceIdsCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::input::DeviceIds ids) {
  if (_buffer.capacity() < GetDeviceIdsResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  auto& _response = *reinterpret_cast<GetDeviceIdsResponse*>(_buffer.data());
  Device::SetTransactionHeaderFor::GetDeviceIdsResponse(
      ::fidl::DecodedMessage<GetDeviceIdsResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              GetDeviceIdsResponse::PrimarySize,
              GetDeviceIdsResponse::PrimarySize)));
  _response.ids = std::move(ids);
  _buffer.set_actual(sizeof(GetDeviceIdsResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<GetDeviceIdsResponse>(std::move(_buffer)));
}

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


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

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

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


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


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

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

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


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


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

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

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


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

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

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


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


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

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

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


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


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

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

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



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

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

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

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

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

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

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

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

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

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

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

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

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

}  // namespace input
}  // namespace hardware
}  // namespace fuchsia
}  // namespace llcpp