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

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

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

namespace llcpp {

namespace fuchsia {
namespace hardware {
namespace pty {

namespace {

[[maybe_unused]]
constexpr uint64_t kDevice_Clone_Ordinal = 0x17fe6a4c00000000lu;
[[maybe_unused]]
constexpr uint64_t kDevice_Clone_GenOrdinal = 0x5a61678f293ce16flu;
extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceCloneRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceCloneResponseTable;
[[maybe_unused]]
constexpr uint64_t kDevice_Close_Ordinal = 0x52b9568700000000lu;
[[maybe_unused]]
constexpr uint64_t kDevice_Close_GenOrdinal = 0x5309c5bd1c33dc44lu;
extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceCloseRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceCloseResponseTable;
[[maybe_unused]]
constexpr uint64_t kDevice_Describe_Ordinal = 0x1f62df5e00000000lu;
[[maybe_unused]]
constexpr uint64_t kDevice_Describe_GenOrdinal = 0xffcec215078dea0lu;
extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceDescribeRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceDescribeResponseTable;
[[maybe_unused]]
constexpr uint64_t kDevice_OnOpen_Ordinal = 0x4700a7bd00000000lu;
[[maybe_unused]]
constexpr uint64_t kDevice_OnOpen_GenOrdinal = 0x7fc7bbb1dbfd1972lu;
extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceOnOpenRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceOnOpenEventTable;
[[maybe_unused]]
constexpr uint64_t kDevice_Sync_Ordinal = 0x62423faa00000000lu;
[[maybe_unused]]
constexpr uint64_t kDevice_Sync_GenOrdinal = 0x189d88326c18b519lu;
extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceSyncRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceSyncResponseTable;
[[maybe_unused]]
constexpr uint64_t kDevice_GetAttr_Ordinal = 0x4585e7c800000000lu;
[[maybe_unused]]
constexpr uint64_t kDevice_GetAttr_GenOrdinal = 0x78985e216314dafdlu;
extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceGetAttrRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceGetAttrResponseTable;
[[maybe_unused]]
constexpr uint64_t kDevice_SetAttr_Ordinal = 0xbd5559a00000000lu;
[[maybe_unused]]
constexpr uint64_t kDevice_SetAttr_GenOrdinal = 0x4186c0f40d938f46lu;
extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceSetAttrRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceSetAttrResponseTable;
[[maybe_unused]]
constexpr uint64_t kDevice_NodeGetFlags_Ordinal = 0x3c24c22300000000lu;
[[maybe_unused]]
constexpr uint64_t kDevice_NodeGetFlags_GenOrdinal = 0x5b88fffb8eda3aa1lu;
extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceNodeGetFlagsRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceNodeGetFlagsResponseTable;
[[maybe_unused]]
constexpr uint64_t kDevice_NodeSetFlags_Ordinal = 0x46940c1600000000lu;
[[maybe_unused]]
constexpr uint64_t kDevice_NodeSetFlags_GenOrdinal = 0x5295b76c71fde733lu;
extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceNodeSetFlagsRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceNodeSetFlagsResponseTable;
[[maybe_unused]]
constexpr uint64_t kDevice_Read_Ordinal = 0x25f7418400000000lu;
[[maybe_unused]]
constexpr uint64_t kDevice_Read_GenOrdinal = 0x29b2b7074c95208clu;
extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceReadRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceReadResponseTable;
[[maybe_unused]]
constexpr uint64_t kDevice_ReadAt_Ordinal = 0x7c724dc400000000lu;
[[maybe_unused]]
constexpr uint64_t kDevice_ReadAt_GenOrdinal = 0x6527ee3fbc9c5749lu;
extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceReadAtRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceReadAtResponseTable;
[[maybe_unused]]
constexpr uint64_t kDevice_Write_Ordinal = 0x512e7a000000000lu;
[[maybe_unused]]
constexpr uint64_t kDevice_Write_GenOrdinal = 0x3b6432f57914225blu;
extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceWriteRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceWriteResponseTable;
[[maybe_unused]]
constexpr uint64_t kDevice_WriteAt_Ordinal = 0x3e5522e500000000lu;
[[maybe_unused]]
constexpr uint64_t kDevice_WriteAt_GenOrdinal = 0x4b29e1582ab379e4lu;
extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceWriteAtRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceWriteAtResponseTable;
[[maybe_unused]]
constexpr uint64_t kDevice_Seek_Ordinal = 0x782a774500000000lu;
[[maybe_unused]]
constexpr uint64_t kDevice_Seek_GenOrdinal = 0x324968e9b8a0e394lu;
extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceSeekRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceSeekResponseTable;
[[maybe_unused]]
constexpr uint64_t kDevice_Truncate_Ordinal = 0x42ab3a3a00000000lu;
[[maybe_unused]]
constexpr uint64_t kDevice_Truncate_GenOrdinal = 0x5ec8f337359a2ddblu;
extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceTruncateRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceTruncateResponseTable;
[[maybe_unused]]
constexpr uint64_t kDevice_GetFlags_Ordinal = 0x6416a3f600000000lu;
[[maybe_unused]]
constexpr uint64_t kDevice_GetFlags_GenOrdinal = 0x200be82ca523ab96lu;
extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceGetFlagsRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceGetFlagsResponseTable;
[[maybe_unused]]
constexpr uint64_t kDevice_SetFlags_Ordinal = 0x3f23cc7600000000lu;
[[maybe_unused]]
constexpr uint64_t kDevice_SetFlags_GenOrdinal = 0x713f375258671141lu;
extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceSetFlagsRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceSetFlagsResponseTable;
[[maybe_unused]]
constexpr uint64_t kDevice_GetBuffer_Ordinal = 0x74c3097300000000lu;
[[maybe_unused]]
constexpr uint64_t kDevice_GetBuffer_GenOrdinal = 0x4b93b8486666d951lu;
extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceGetBufferRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceGetBufferResponseTable;
[[maybe_unused]]
constexpr uint64_t kDevice_OpenClient_Ordinal = 0x5ce2427f00000000lu;
[[maybe_unused]]
constexpr uint64_t kDevice_OpenClient_GenOrdinal = 0x78f040fe6a1ebb3lu;
extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceOpenClientRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceOpenClientResponseTable;
[[maybe_unused]]
constexpr uint64_t kDevice_ClrSetFeature_Ordinal = 0x5b74b23900000000lu;
[[maybe_unused]]
constexpr uint64_t kDevice_ClrSetFeature_GenOrdinal = 0x6367986e6053a15elu;
extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceClrSetFeatureRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceClrSetFeatureResponseTable;
[[maybe_unused]]
constexpr uint64_t kDevice_GetWindowSize_Ordinal = 0x6b4f1d8300000000lu;
[[maybe_unused]]
constexpr uint64_t kDevice_GetWindowSize_GenOrdinal = 0x747bed0460f5f9f7lu;
extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceGetWindowSizeRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceGetWindowSizeResponseTable;
[[maybe_unused]]
constexpr uint64_t kDevice_MakeActive_Ordinal = 0x9648f9700000000lu;
[[maybe_unused]]
constexpr uint64_t kDevice_MakeActive_GenOrdinal = 0x2763944f30ee2a62lu;
extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceMakeActiveRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceMakeActiveResponseTable;
[[maybe_unused]]
constexpr uint64_t kDevice_ReadEvents_Ordinal = 0x65e3e0bd00000000lu;
[[maybe_unused]]
constexpr uint64_t kDevice_ReadEvents_GenOrdinal = 0xede96f3e3258f62lu;
extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceReadEventsRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceReadEventsResponseTable;
[[maybe_unused]]
constexpr uint64_t kDevice_SetWindowSize_Ordinal = 0x3c0c556700000000lu;
[[maybe_unused]]
constexpr uint64_t kDevice_SetWindowSize_GenOrdinal = 0x17d1cb37377e7928lu;
extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceSetWindowSizeRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceSetWindowSizeResponseTable;

}  // namespace

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

Device::ResultOf::Clone Device::SyncClient::Clone(uint32_t flags, ::zx::channel object) {
    return ResultOf::Clone(::zx::unowned_channel(this->channel_), std::move(flags), std::move(object));
}

Device::ResultOf::Clone Device::Call::Clone(::zx::unowned_channel _client_end, uint32_t flags, ::zx::channel object) {
  return ResultOf::Clone(std::move(_client_end), std::move(flags), std::move(object));
}


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

Device::UnownedResultOf::Clone Device::SyncClient::Clone(::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object) {
  return UnownedResultOf::Clone(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(flags), std::move(object));
}

Device::UnownedResultOf::Clone Device::Call::Clone(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object) {
  return UnownedResultOf::Clone(std::move(_client_end), std::move(_request_buffer), std::move(flags), std::move(object));
}

::fidl::internal::StatusAndError Device::InPlace::Clone(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CloneRequest> params) {
  Device::SetTransactionHeaderFor::CloneRequest(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);
  }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

template <>
Device::ResultOf::SetAttr_Impl<Device::SetAttrResponse>::SetAttr_Impl(::zx::unowned_channel _client_end, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetAttrRequest, ::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, SetAttrRequest::PrimarySize);
  auto& _request = *reinterpret_cast<SetAttrRequest*>(_write_bytes);
  _request.flags = std::move(flags);
  _request.attributes = std::move(attributes);
  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetAttrRequest));
  ::fidl::DecodedMessage<SetAttrRequest> _decoded_request(std::move(_request_bytes));
  Super::SetResult(
      Device::InPlace::SetAttr(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
}

Device::ResultOf::SetAttr Device::SyncClient::SetAttr(uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes) {
    return ResultOf::SetAttr(::zx::unowned_channel(this->channel_), std::move(flags), std::move(attributes));
}

Device::ResultOf::SetAttr Device::Call::SetAttr(::zx::unowned_channel _client_end, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes) {
  return ResultOf::SetAttr(std::move(_client_end), std::move(flags), std::move(attributes));
}

template <>
Device::UnownedResultOf::SetAttr_Impl<Device::SetAttrResponse>::SetAttr_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer) {
  if (_request_buffer.capacity() < SetAttrRequest::PrimarySize) {
    Super::SetFailure(::fidl::DecodeResult<SetAttrResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
    return;
  }
  memset(_request_buffer.data(), 0, SetAttrRequest::PrimarySize);
  auto& _request = *reinterpret_cast<SetAttrRequest*>(_request_buffer.data());
  _request.flags = std::move(flags);
  _request.attributes = std::move(attributes);
  _request_buffer.set_actual(sizeof(SetAttrRequest));
  ::fidl::DecodedMessage<SetAttrRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      Device::InPlace::SetAttr(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
}

Device::UnownedResultOf::SetAttr Device::SyncClient::SetAttr(::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::SetAttr(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(flags), std::move(attributes), std::move(_response_buffer));
}

Device::UnownedResultOf::SetAttr Device::Call::SetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::SetAttr(std::move(_client_end), std::move(_request_buffer), std::move(flags), std::move(attributes), std::move(_response_buffer));
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

template <>
Device::ResultOf::Read_Impl<Device::ReadResponse>::Read_Impl(::zx::unowned_channel _client_end, uint64_t count) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ReadRequest, ::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, ReadRequest::PrimarySize);
  auto& _request = *reinterpret_cast<ReadRequest*>(_write_bytes);
  _request.count = std::move(count);
  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ReadRequest));
  ::fidl::DecodedMessage<ReadRequest> _decoded_request(std::move(_request_bytes));
  Super::SetResult(
      Device::InPlace::Read(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
}

Device::ResultOf::Read Device::SyncClient::Read(uint64_t count) {
    return ResultOf::Read(::zx::unowned_channel(this->channel_), std::move(count));
}

Device::ResultOf::Read Device::Call::Read(::zx::unowned_channel _client_end, uint64_t count) {
  return ResultOf::Read(std::move(_client_end), std::move(count));
}

template <>
Device::UnownedResultOf::Read_Impl<Device::ReadResponse>::Read_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t count, ::fidl::BytePart _response_buffer) {
  if (_request_buffer.capacity() < ReadRequest::PrimarySize) {
    Super::SetFailure(::fidl::DecodeResult<ReadResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
    return;
  }
  memset(_request_buffer.data(), 0, ReadRequest::PrimarySize);
  auto& _request = *reinterpret_cast<ReadRequest*>(_request_buffer.data());
  _request.count = std::move(count);
  _request_buffer.set_actual(sizeof(ReadRequest));
  ::fidl::DecodedMessage<ReadRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      Device::InPlace::Read(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
}

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

Device::UnownedResultOf::Read Device::Call::Read(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t count, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::Read(std::move(_client_end), std::move(_request_buffer), std::move(count), std::move(_response_buffer));
}

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

template <>
Device::ResultOf::ReadAt_Impl<Device::ReadAtResponse>::ReadAt_Impl(::zx::unowned_channel _client_end, uint64_t count, uint64_t offset) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ReadAtRequest, ::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, ReadAtRequest::PrimarySize);
  auto& _request = *reinterpret_cast<ReadAtRequest*>(_write_bytes);
  _request.count = std::move(count);
  _request.offset = std::move(offset);
  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ReadAtRequest));
  ::fidl::DecodedMessage<ReadAtRequest> _decoded_request(std::move(_request_bytes));
  Super::SetResult(
      Device::InPlace::ReadAt(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
}

Device::ResultOf::ReadAt Device::SyncClient::ReadAt(uint64_t count, uint64_t offset) {
    return ResultOf::ReadAt(::zx::unowned_channel(this->channel_), std::move(count), std::move(offset));
}

Device::ResultOf::ReadAt Device::Call::ReadAt(::zx::unowned_channel _client_end, uint64_t count, uint64_t offset) {
  return ResultOf::ReadAt(std::move(_client_end), std::move(count), std::move(offset));
}

template <>
Device::UnownedResultOf::ReadAt_Impl<Device::ReadAtResponse>::ReadAt_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t count, uint64_t offset, ::fidl::BytePart _response_buffer) {
  if (_request_buffer.capacity() < ReadAtRequest::PrimarySize) {
    Super::SetFailure(::fidl::DecodeResult<ReadAtResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
    return;
  }
  memset(_request_buffer.data(), 0, ReadAtRequest::PrimarySize);
  auto& _request = *reinterpret_cast<ReadAtRequest*>(_request_buffer.data());
  _request.count = std::move(count);
  _request.offset = std::move(offset);
  _request_buffer.set_actual(sizeof(ReadAtRequest));
  ::fidl::DecodedMessage<ReadAtRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      Device::InPlace::ReadAt(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
}

Device::UnownedResultOf::ReadAt Device::SyncClient::ReadAt(::fidl::BytePart _request_buffer, uint64_t count, uint64_t offset, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::ReadAt(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(count), std::move(offset), std::move(_response_buffer));
}

Device::UnownedResultOf::ReadAt Device::Call::ReadAt(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t count, uint64_t offset, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::ReadAt(std::move(_client_end), std::move(_request_buffer), std::move(count), std::move(offset), std::move(_response_buffer));
}

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

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

Device::ResultOf::Write Device::SyncClient::Write(::fidl::VectorView<uint8_t> data) {
    return ResultOf::Write(::zx::unowned_channel(this->channel_), std::move(data));
}

Device::ResultOf::Write Device::Call::Write(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> data) {
  return ResultOf::Write(std::move(_client_end), std::move(data));
}

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

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

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

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

template <>
Device::ResultOf::WriteAt_Impl<Device::WriteAtResponse>::WriteAt_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> data, uint64_t offset) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WriteAtRequest, ::fidl::MessageDirection::kSending>();
  std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
  auto& _write_bytes_array = *_write_bytes_boxed;
  WriteAtRequest _request = {};
  _request.data = std::move(data);
  _request.offset = std::move(offset);
  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<WriteAtRequest> _decoded_request = std::move(_linearize_result.message);
  Super::SetResult(
      Device::InPlace::WriteAt(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
}

Device::ResultOf::WriteAt Device::SyncClient::WriteAt(::fidl::VectorView<uint8_t> data, uint64_t offset) {
    return ResultOf::WriteAt(::zx::unowned_channel(this->channel_), std::move(data), std::move(offset));
}

Device::ResultOf::WriteAt Device::Call::WriteAt(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> data, uint64_t offset) {
  return ResultOf::WriteAt(std::move(_client_end), std::move(data), std::move(offset));
}

template <>
Device::UnownedResultOf::WriteAt_Impl<Device::WriteAtResponse>::WriteAt_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> data, uint64_t offset, ::fidl::BytePart _response_buffer) {
  if (_request_buffer.capacity() < WriteAtRequest::PrimarySize) {
    Super::SetFailure(::fidl::DecodeResult<WriteAtResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
    return;
  }
  WriteAtRequest _request = {};
  _request.data = std::move(data);
  _request.offset = std::move(offset);
  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<WriteAtRequest> _decoded_request = std::move(_linearize_result.message);
  Super::SetResult(
      Device::InPlace::WriteAt(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
}

Device::UnownedResultOf::WriteAt Device::SyncClient::WriteAt(::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> data, uint64_t offset, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::WriteAt(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(data), std::move(offset), std::move(_response_buffer));
}

Device::UnownedResultOf::WriteAt Device::Call::WriteAt(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> data, uint64_t offset, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::WriteAt(std::move(_client_end), std::move(_request_buffer), std::move(data), std::move(offset), std::move(_response_buffer));
}

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

template <>
Device::ResultOf::Seek_Impl<Device::SeekResponse>::Seek_Impl(::zx::unowned_channel _client_end, int64_t offset, ::llcpp::fuchsia::io::SeekOrigin start) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SeekRequest, ::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, SeekRequest::PrimarySize);
  auto& _request = *reinterpret_cast<SeekRequest*>(_write_bytes);
  _request.offset = std::move(offset);
  _request.start = std::move(start);
  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SeekRequest));
  ::fidl::DecodedMessage<SeekRequest> _decoded_request(std::move(_request_bytes));
  Super::SetResult(
      Device::InPlace::Seek(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
}

Device::ResultOf::Seek Device::SyncClient::Seek(int64_t offset, ::llcpp::fuchsia::io::SeekOrigin start) {
    return ResultOf::Seek(::zx::unowned_channel(this->channel_), std::move(offset), std::move(start));
}

Device::ResultOf::Seek Device::Call::Seek(::zx::unowned_channel _client_end, int64_t offset, ::llcpp::fuchsia::io::SeekOrigin start) {
  return ResultOf::Seek(std::move(_client_end), std::move(offset), std::move(start));
}

template <>
Device::UnownedResultOf::Seek_Impl<Device::SeekResponse>::Seek_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int64_t offset, ::llcpp::fuchsia::io::SeekOrigin start, ::fidl::BytePart _response_buffer) {
  if (_request_buffer.capacity() < SeekRequest::PrimarySize) {
    Super::SetFailure(::fidl::DecodeResult<SeekResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
    return;
  }
  memset(_request_buffer.data(), 0, SeekRequest::PrimarySize);
  auto& _request = *reinterpret_cast<SeekRequest*>(_request_buffer.data());
  _request.offset = std::move(offset);
  _request.start = std::move(start);
  _request_buffer.set_actual(sizeof(SeekRequest));
  ::fidl::DecodedMessage<SeekRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      Device::InPlace::Seek(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
}

Device::UnownedResultOf::Seek Device::SyncClient::Seek(::fidl::BytePart _request_buffer, int64_t offset, ::llcpp::fuchsia::io::SeekOrigin start, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::Seek(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(offset), std::move(start), std::move(_response_buffer));
}

Device::UnownedResultOf::Seek Device::Call::Seek(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int64_t offset, ::llcpp::fuchsia::io::SeekOrigin start, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::Seek(std::move(_client_end), std::move(_request_buffer), std::move(offset), std::move(start), std::move(_response_buffer));
}

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

template <>
Device::ResultOf::Truncate_Impl<Device::TruncateResponse>::Truncate_Impl(::zx::unowned_channel _client_end, uint64_t length) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<TruncateRequest, ::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, TruncateRequest::PrimarySize);
  auto& _request = *reinterpret_cast<TruncateRequest*>(_write_bytes);
  _request.length = std::move(length);
  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(TruncateRequest));
  ::fidl::DecodedMessage<TruncateRequest> _decoded_request(std::move(_request_bytes));
  Super::SetResult(
      Device::InPlace::Truncate(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
}

Device::ResultOf::Truncate Device::SyncClient::Truncate(uint64_t length) {
    return ResultOf::Truncate(::zx::unowned_channel(this->channel_), std::move(length));
}

Device::ResultOf::Truncate Device::Call::Truncate(::zx::unowned_channel _client_end, uint64_t length) {
  return ResultOf::Truncate(std::move(_client_end), std::move(length));
}

template <>
Device::UnownedResultOf::Truncate_Impl<Device::TruncateResponse>::Truncate_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t length, ::fidl::BytePart _response_buffer) {
  if (_request_buffer.capacity() < TruncateRequest::PrimarySize) {
    Super::SetFailure(::fidl::DecodeResult<TruncateResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
    return;
  }
  memset(_request_buffer.data(), 0, TruncateRequest::PrimarySize);
  auto& _request = *reinterpret_cast<TruncateRequest*>(_request_buffer.data());
  _request.length = std::move(length);
  _request_buffer.set_actual(sizeof(TruncateRequest));
  ::fidl::DecodedMessage<TruncateRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      Device::InPlace::Truncate(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
}

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

Device::UnownedResultOf::Truncate Device::Call::Truncate(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t length, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::Truncate(std::move(_client_end), std::move(_request_buffer), std::move(length), std::move(_response_buffer));
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

template <>
Device::ResultOf::OpenClient_Impl<Device::OpenClientResponse>::OpenClient_Impl(::zx::unowned_channel _client_end, uint32_t id, ::zx::channel client) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<OpenClientRequest, ::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, OpenClientRequest::PrimarySize);
  auto& _request = *reinterpret_cast<OpenClientRequest*>(_write_bytes);
  _request.id = std::move(id);
  _request.client = std::move(client);
  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(OpenClientRequest));
  ::fidl::DecodedMessage<OpenClientRequest> _decoded_request(std::move(_request_bytes));
  Super::SetResult(
      Device::InPlace::OpenClient(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
}

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

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

template <>
Device::UnownedResultOf::OpenClient_Impl<Device::OpenClientResponse>::OpenClient_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t id, ::zx::channel client, ::fidl::BytePart _response_buffer) {
  if (_request_buffer.capacity() < OpenClientRequest::PrimarySize) {
    Super::SetFailure(::fidl::DecodeResult<OpenClientResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
    return;
  }
  memset(_request_buffer.data(), 0, OpenClientRequest::PrimarySize);
  auto& _request = *reinterpret_cast<OpenClientRequest*>(_request_buffer.data());
  _request.id = std::move(id);
  _request.client = std::move(client);
  _request_buffer.set_actual(sizeof(OpenClientRequest));
  ::fidl::DecodedMessage<OpenClientRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      Device::InPlace::OpenClient(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
}

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

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

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

template <>
Device::ResultOf::ClrSetFeature_Impl<Device::ClrSetFeatureResponse>::ClrSetFeature_Impl(::zx::unowned_channel _client_end, uint32_t clr, uint32_t set) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ClrSetFeatureRequest, ::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, ClrSetFeatureRequest::PrimarySize);
  auto& _request = *reinterpret_cast<ClrSetFeatureRequest*>(_write_bytes);
  _request.clr = std::move(clr);
  _request.set = std::move(set);
  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ClrSetFeatureRequest));
  ::fidl::DecodedMessage<ClrSetFeatureRequest> _decoded_request(std::move(_request_bytes));
  Super::SetResult(
      Device::InPlace::ClrSetFeature(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
}

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

Device::ResultOf::ClrSetFeature Device::Call::ClrSetFeature(::zx::unowned_channel _client_end, uint32_t clr, uint32_t set) {
  return ResultOf::ClrSetFeature(std::move(_client_end), std::move(clr), std::move(set));
}

template <>
Device::UnownedResultOf::ClrSetFeature_Impl<Device::ClrSetFeatureResponse>::ClrSetFeature_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t clr, uint32_t set, ::fidl::BytePart _response_buffer) {
  if (_request_buffer.capacity() < ClrSetFeatureRequest::PrimarySize) {
    Super::SetFailure(::fidl::DecodeResult<ClrSetFeatureResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
    return;
  }
  memset(_request_buffer.data(), 0, ClrSetFeatureRequest::PrimarySize);
  auto& _request = *reinterpret_cast<ClrSetFeatureRequest*>(_request_buffer.data());
  _request.clr = std::move(clr);
  _request.set = std::move(set);
  _request_buffer.set_actual(sizeof(ClrSetFeatureRequest));
  ::fidl::DecodedMessage<ClrSetFeatureRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      Device::InPlace::ClrSetFeature(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
}

Device::UnownedResultOf::ClrSetFeature Device::SyncClient::ClrSetFeature(::fidl::BytePart _request_buffer, uint32_t clr, uint32_t set, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::ClrSetFeature(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(clr), std::move(set), std::move(_response_buffer));
}

Device::UnownedResultOf::ClrSetFeature Device::Call::ClrSetFeature(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t clr, uint32_t set, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::ClrSetFeature(std::move(_client_end), std::move(_request_buffer), std::move(clr), std::move(set), std::move(_response_buffer));
}

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

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

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

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

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

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

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

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

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

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

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

template <>
Device::UnownedResultOf::MakeActive_Impl<Device::MakeActiveResponse>::MakeActive_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t client_pty_id, ::fidl::BytePart _response_buffer) {
  if (_request_buffer.capacity() < MakeActiveRequest::PrimarySize) {
    Super::SetFailure(::fidl::DecodeResult<MakeActiveResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
    return;
  }
  memset(_request_buffer.data(), 0, MakeActiveRequest::PrimarySize);
  auto& _request = *reinterpret_cast<MakeActiveRequest*>(_request_buffer.data());
  _request.client_pty_id = std::move(client_pty_id);
  _request_buffer.set_actual(sizeof(MakeActiveRequest));
  ::fidl::DecodedMessage<MakeActiveRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      Device::InPlace::MakeActive(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
}

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

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

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

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

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

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

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

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

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

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

template <>
Device::ResultOf::SetWindowSize_Impl<Device::SetWindowSizeResponse>::SetWindowSize_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::pty::WindowSize size) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetWindowSizeRequest, ::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, SetWindowSizeRequest::PrimarySize);
  auto& _request = *reinterpret_cast<SetWindowSizeRequest*>(_write_bytes);
  _request.size = std::move(size);
  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetWindowSizeRequest));
  ::fidl::DecodedMessage<SetWindowSizeRequest> _decoded_request(std::move(_request_bytes));
  Super::SetResult(
      Device::InPlace::SetWindowSize(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
}

Device::ResultOf::SetWindowSize Device::SyncClient::SetWindowSize(::llcpp::fuchsia::hardware::pty::WindowSize size) {
    return ResultOf::SetWindowSize(::zx::unowned_channel(this->channel_), std::move(size));
}

Device::ResultOf::SetWindowSize Device::Call::SetWindowSize(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::pty::WindowSize size) {
  return ResultOf::SetWindowSize(std::move(_client_end), std::move(size));
}

template <>
Device::UnownedResultOf::SetWindowSize_Impl<Device::SetWindowSizeResponse>::SetWindowSize_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::pty::WindowSize size, ::fidl::BytePart _response_buffer) {
  if (_request_buffer.capacity() < SetWindowSizeRequest::PrimarySize) {
    Super::SetFailure(::fidl::DecodeResult<SetWindowSizeResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
    return;
  }
  memset(_request_buffer.data(), 0, SetWindowSizeRequest::PrimarySize);
  auto& _request = *reinterpret_cast<SetWindowSizeRequest*>(_request_buffer.data());
  _request.size = std::move(size);
  _request_buffer.set_actual(sizeof(SetWindowSizeRequest));
  ::fidl::DecodedMessage<SetWindowSizeRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      Device::InPlace::SetWindowSize(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
}

Device::UnownedResultOf::SetWindowSize Device::SyncClient::SetWindowSize(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::pty::WindowSize size, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::SetWindowSize(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(size), std::move(_response_buffer));
}

Device::UnownedResultOf::SetWindowSize Device::Call::SetWindowSize(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::pty::WindowSize size, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::SetWindowSize(std::move(_client_end), std::move(_request_buffer), std::move(size), std::move(_response_buffer));
}

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

zx_status_t Device::SyncClient::HandleEvents(Device::EventHandlers handlers) {
  return Device::Call::HandleEvents(::zx::unowned_channel(channel_), std::move(handlers));
}

zx_status_t Device::Call::HandleEvents(::zx::unowned_channel client_end, Device::EventHandlers handlers) {
  zx_status_t status = client_end->wait_one(ZX_CHANNEL_READABLE | ZX_CHANNEL_PEER_CLOSED,
                                            ::zx::time::infinite(),
                                            nullptr);
  if (status != ZX_OK) {
    return status;
  }
  constexpr uint32_t kReadAllocSize = ([]() constexpr {
    uint32_t x = 0;
    if (::fidl::internal::ClampedMessageSize<OnOpenResponse, ::fidl::MessageDirection::kReceiving>() >= x) {
      x = ::fidl::internal::ClampedMessageSize<OnOpenResponse, ::fidl::MessageDirection::kReceiving>();
    }
    return x;
  })();
  constexpr uint32_t kHandleAllocSize = ([]() constexpr {
    uint32_t x = 0;
    if (OnOpenResponse::MaxNumHandles >= x) {
      x = OnOpenResponse::MaxNumHandles;
    }
    if (x > ZX_CHANNEL_MAX_MSG_HANDLES) {
      x = ZX_CHANNEL_MAX_MSG_HANDLES;
    }
    return x;
  })();
  ::fidl::internal::ByteStorage<kReadAllocSize> read_storage;
  uint8_t* read_bytes = read_storage.buffer().data();
  zx_handle_t read_handles[kHandleAllocSize];
  uint32_t actual_bytes;
  uint32_t actual_handles;
  status = client_end->read(ZX_CHANNEL_READ_MAY_DISCARD,
                            read_bytes, read_handles,
                            kReadAllocSize, kHandleAllocSize,
                            &actual_bytes, &actual_handles);
  if (status == ZX_ERR_BUFFER_TOO_SMALL) {
    // Message size is unexpectedly larger than calculated.
    // This can only be due to a newer version of the protocol defining a new event,
    // whose size exceeds the maximum of known events in the current protocol.
    return handlers.unknown();
  }
  if (status != ZX_OK) {
    return status;
  }
  if (actual_bytes < sizeof(fidl_message_header_t)) {
    zx_handle_close_many(read_handles, actual_handles);
    return ZX_ERR_INVALID_ARGS;
  }
  auto msg = fidl_msg_t {
      .bytes = read_bytes,
      .handles = read_handles,
      .num_bytes = actual_bytes,
      .num_handles = actual_handles
  };
  fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg.bytes);
  status = fidl_validate_txn_header(hdr);
  if (status != ZX_OK) {
    return status;
  }
  switch (hdr->ordinal) {
    case kDevice_OnOpen_Ordinal:
    case kDevice_OnOpen_GenOrdinal:
    {
      constexpr uint32_t kTransformerDestSize = ::fidl::internal::ClampedMessageSize<OnOpenResponse, ::fidl::MessageDirection::kReceiving>();
      ::fidl::internal::ByteStorage<kTransformerDestSize> transformer_dest_storage(::fidl::internal::DelayAllocation);
      auto result = ::fidl::DecodeAs<OnOpenResponse>(&msg);
      if (result.status != ZX_OK) {
        return result.status;
      }
      auto message = result.message.message();
      return handlers.on_open(std::move(message->s), std::move(message->info));
    }
    default:
      zx_handle_close_many(read_handles, actual_handles);
      return handlers.unknown();
  }
}

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_Clone_Ordinal:
    case kDevice_Clone_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<CloneRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->Clone(std::move(message->flags), std::move(message->object),
          Interface::CloneCompleter::Sync(txn));
      return true;
    }
    case kDevice_Close_Ordinal:
    case kDevice_Close_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<CloseRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      impl->Close(
          Interface::CloseCompleter::Sync(txn));
      return true;
    }
    case kDevice_Describe_Ordinal:
    case kDevice_Describe_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<DescribeRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      impl->Describe(
          Interface::DescribeCompleter::Sync(txn));
      return true;
    }
    case kDevice_Sync_Ordinal:
    case kDevice_Sync_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<SyncRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      impl->Sync(
          Interface::SyncCompleter::Sync(txn));
      return true;
    }
    case kDevice_GetAttr_Ordinal:
    case kDevice_GetAttr_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<GetAttrRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      impl->GetAttr(
          Interface::GetAttrCompleter::Sync(txn));
      return true;
    }
    case kDevice_SetAttr_Ordinal:
    case kDevice_SetAttr_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<SetAttrRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->SetAttr(std::move(message->flags), std::move(message->attributes),
          Interface::SetAttrCompleter::Sync(txn));
      return true;
    }
    case kDevice_NodeGetFlags_Ordinal:
    case kDevice_NodeGetFlags_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<NodeGetFlagsRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      impl->NodeGetFlags(
          Interface::NodeGetFlagsCompleter::Sync(txn));
      return true;
    }
    case kDevice_NodeSetFlags_Ordinal:
    case kDevice_NodeSetFlags_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<NodeSetFlagsRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->NodeSetFlags(std::move(message->flags),
          Interface::NodeSetFlagsCompleter::Sync(txn));
      return true;
    }
    case kDevice_Read_Ordinal:
    case kDevice_Read_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<ReadRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->Read(std::move(message->count),
          Interface::ReadCompleter::Sync(txn));
      return true;
    }
    case kDevice_ReadAt_Ordinal:
    case kDevice_ReadAt_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<ReadAtRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->ReadAt(std::move(message->count), std::move(message->offset),
          Interface::ReadAtCompleter::Sync(txn));
      return true;
    }
    case kDevice_Write_Ordinal:
    case kDevice_Write_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<WriteRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->Write(std::move(message->data),
          Interface::WriteCompleter::Sync(txn));
      return true;
    }
    case kDevice_WriteAt_Ordinal:
    case kDevice_WriteAt_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<WriteAtRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->WriteAt(std::move(message->data), std::move(message->offset),
          Interface::WriteAtCompleter::Sync(txn));
      return true;
    }
    case kDevice_Seek_Ordinal:
    case kDevice_Seek_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<SeekRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->Seek(std::move(message->offset), std::move(message->start),
          Interface::SeekCompleter::Sync(txn));
      return true;
    }
    case kDevice_Truncate_Ordinal:
    case kDevice_Truncate_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<TruncateRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->Truncate(std::move(message->length),
          Interface::TruncateCompleter::Sync(txn));
      return true;
    }
    case kDevice_GetFlags_Ordinal:
    case kDevice_GetFlags_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<GetFlagsRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      impl->GetFlags(
          Interface::GetFlagsCompleter::Sync(txn));
      return true;
    }
    case kDevice_SetFlags_Ordinal:
    case kDevice_SetFlags_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<SetFlagsRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->SetFlags(std::move(message->flags),
          Interface::SetFlagsCompleter::Sync(txn));
      return true;
    }
    case kDevice_GetBuffer_Ordinal:
    case kDevice_GetBuffer_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<GetBufferRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->GetBuffer(std::move(message->flags),
          Interface::GetBufferCompleter::Sync(txn));
      return true;
    }
    case kDevice_OpenClient_Ordinal:
    case kDevice_OpenClient_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<OpenClientRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->OpenClient(std::move(message->id), std::move(message->client),
          Interface::OpenClientCompleter::Sync(txn));
      return true;
    }
    case kDevice_ClrSetFeature_Ordinal:
    case kDevice_ClrSetFeature_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<ClrSetFeatureRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->ClrSetFeature(std::move(message->clr), std::move(message->set),
          Interface::ClrSetFeatureCompleter::Sync(txn));
      return true;
    }
    case kDevice_GetWindowSize_Ordinal:
    case kDevice_GetWindowSize_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<GetWindowSizeRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      impl->GetWindowSize(
          Interface::GetWindowSizeCompleter::Sync(txn));
      return true;
    }
    case kDevice_MakeActive_Ordinal:
    case kDevice_MakeActive_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<MakeActiveRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->MakeActive(std::move(message->client_pty_id),
          Interface::MakeActiveCompleter::Sync(txn));
      return true;
    }
    case kDevice_ReadEvents_Ordinal:
    case kDevice_ReadEvents_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<ReadEventsRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      impl->ReadEvents(
          Interface::ReadEventsCompleter::Sync(txn));
      return true;
    }
    case kDevice_SetWindowSize_Ordinal:
    case kDevice_SetWindowSize_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<SetWindowSizeRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->SetWindowSize(std::move(message->size),
          Interface::SetWindowSizeCompleter::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::CloseCompleterBase::Reply(int32_t s) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloseResponse, ::fidl::MessageDirection::kSending>();
  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
  auto& _response = *reinterpret_cast<CloseResponse*>(_write_bytes);
  Device::SetTransactionHeaderFor::CloseResponse(
      ::fidl::DecodedMessage<CloseResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              CloseResponse::PrimarySize,
              CloseResponse::PrimarySize)));
  _response.s = std::move(s);
  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloseResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<CloseResponse>(std::move(_response_bytes)));
}

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

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


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


zx_status_t Device::SendOnOpenEvent(::zx::unowned_channel _chan, int32_t s, ::llcpp::fuchsia::io::NodeInfo info) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<OnOpenResponse, ::fidl::MessageDirection::kSending>();
  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
  OnOpenResponse _response = {};
  Device::SetTransactionHeaderFor::OnOpenResponse(
      ::fidl::DecodedMessage<OnOpenResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              OnOpenResponse::PrimarySize,
              OnOpenResponse::PrimarySize)));
  _response.s = std::move(s);
  _response.info = std::move(info);
  auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
                                                                          _kWriteAllocSize));
  if (_linearize_result.status != ZX_OK) {
    return _linearize_result.status;
  }
  return ::fidl::Write(::zx::unowned_channel(_chan), std::move(_linearize_result.message));
}

zx_status_t Device::SendOnOpenEvent(::zx::unowned_channel _chan, ::fidl::BytePart _buffer, int32_t s, ::llcpp::fuchsia::io::NodeInfo info) {
  if (_buffer.capacity() < OnOpenResponse::PrimarySize) {
    return ZX_ERR_BUFFER_TOO_SMALL;
  }
  OnOpenResponse _response = {};
  Device::SetTransactionHeaderFor::OnOpenResponse(
      ::fidl::DecodedMessage<OnOpenResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              OnOpenResponse::PrimarySize,
              OnOpenResponse::PrimarySize)));
  _response.s = std::move(s);
  _response.info = std::move(info);
  auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
  if (_linearize_result.status != ZX_OK) {
    return _linearize_result.status;
  }
  return ::fidl::Write(::zx::unowned_channel(_chan), std::move(_linearize_result.message));
}

zx_status_t Device::SendOnOpenEvent(::zx::unowned_channel _chan, ::fidl::DecodedMessage<OnOpenResponse> params) {
  Device::SetTransactionHeaderFor::OnOpenResponse(params);
  return ::fidl::Write(::zx::unowned_channel(_chan), std::move(params));
}


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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


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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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



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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

}  // namespace pty
}  // namespace hardware
}  // namespace fuchsia
}  // namespace llcpp