zircon/system/fidl/fuchsia-hardware-block-volume/gen/llcpp/fidl.cc

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

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

namespace llcpp {

namespace fuchsia {
namespace hardware {
namespace block {
namespace volume {

namespace {

[[maybe_unused]]
constexpr uint64_t kVolume_GetInfo_Ordinal = 0x7279049800000000lu;
[[maybe_unused]]
constexpr uint64_t kVolume_GetInfo_GenOrdinal = 0x79df1a5cdb6cc6a3lu;
extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeGetInfoRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeGetInfoResponseTable;
[[maybe_unused]]
constexpr uint64_t kVolume_GetStats_Ordinal = 0x73b9275400000000lu;
[[maybe_unused]]
constexpr uint64_t kVolume_GetStats_GenOrdinal = 0x53d9542a778385aelu;
extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeGetStatsRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeGetStatsResponseTable;
[[maybe_unused]]
constexpr uint64_t kVolume_GetFifo_Ordinal = 0x63616dbe00000000lu;
[[maybe_unused]]
constexpr uint64_t kVolume_GetFifo_GenOrdinal = 0x507ea563fb50747elu;
extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeGetFifoRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeGetFifoResponseTable;
[[maybe_unused]]
constexpr uint64_t kVolume_AttachVmo_Ordinal = 0x72df2e6600000000lu;
[[maybe_unused]]
constexpr uint64_t kVolume_AttachVmo_GenOrdinal = 0x7e726e5993add9b7lu;
extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeAttachVmoRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeAttachVmoResponseTable;
[[maybe_unused]]
constexpr uint64_t kVolume_CloseFifo_Ordinal = 0x6b4a461300000000lu;
[[maybe_unused]]
constexpr uint64_t kVolume_CloseFifo_GenOrdinal = 0x4dc09acdfa2a2a65lu;
extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeCloseFifoRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeCloseFifoResponseTable;
[[maybe_unused]]
constexpr uint64_t kVolume_RebindDevice_Ordinal = 0x2c1ffdb000000000lu;
[[maybe_unused]]
constexpr uint64_t kVolume_RebindDevice_GenOrdinal = 0x5d728cbd5312c9aelu;
extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeRebindDeviceRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeRebindDeviceResponseTable;
[[maybe_unused]]
constexpr uint64_t kVolume_GetTypeGuid_Ordinal = 0x40d3186c00000000lu;
[[maybe_unused]]
constexpr uint64_t kVolume_GetTypeGuid_GenOrdinal = 0x111843d737a9b847lu;
extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeGetTypeGuidRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeGetTypeGuidResponseTable;
[[maybe_unused]]
constexpr uint64_t kVolume_GetInstanceGuid_Ordinal = 0x69f426600000000lu;
[[maybe_unused]]
constexpr uint64_t kVolume_GetInstanceGuid_GenOrdinal = 0x14a5a573b275d435lu;
extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeGetInstanceGuidRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeGetInstanceGuidResponseTable;
[[maybe_unused]]
constexpr uint64_t kVolume_GetName_Ordinal = 0x39b49c4000000000lu;
[[maybe_unused]]
constexpr uint64_t kVolume_GetName_GenOrdinal = 0x7e3c6f0b0937fc02lu;
extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeGetNameRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeGetNameResponseTable;
[[maybe_unused]]
constexpr uint64_t kVolume_Query_Ordinal = 0x40fc59f400000000lu;
[[maybe_unused]]
constexpr uint64_t kVolume_Query_GenOrdinal = 0x5e1ac5124112e9aclu;
extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeQueryRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeQueryResponseTable;
[[maybe_unused]]
constexpr uint64_t kVolume_QuerySlices_Ordinal = 0x62b0f14900000000lu;
[[maybe_unused]]
constexpr uint64_t kVolume_QuerySlices_GenOrdinal = 0x589a96828a3e2aa1lu;
extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeQuerySlicesRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeQuerySlicesResponseTable;
[[maybe_unused]]
constexpr uint64_t kVolume_Extend_Ordinal = 0xa64d1b00000000lu;
[[maybe_unused]]
constexpr uint64_t kVolume_Extend_GenOrdinal = 0xdddf872f5039d37lu;
extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeExtendRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeExtendResponseTable;
[[maybe_unused]]
constexpr uint64_t kVolume_Shrink_Ordinal = 0x761d12600000000lu;
[[maybe_unused]]
constexpr uint64_t kVolume_Shrink_GenOrdinal = 0x27ab5ed4f6fdcd29lu;
extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeShrinkRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeShrinkResponseTable;
[[maybe_unused]]
constexpr uint64_t kVolume_Destroy_Ordinal = 0x196549ea00000000lu;
[[maybe_unused]]
constexpr uint64_t kVolume_Destroy_GenOrdinal = 0x732bf4bea39b5e87lu;
extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeDestroyRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeDestroyResponseTable;

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

Volume::ResultOf::GetInfo Volume::SyncClient::GetInfo() {
    return ResultOf::GetInfo(::zx::unowned_channel(this->channel_));
}

Volume::ResultOf::GetInfo Volume::Call::GetInfo(::zx::unowned_channel _client_end) {
  return ResultOf::GetInfo(std::move(_client_end));
}

template <>
Volume::UnownedResultOf::GetInfo_Impl<Volume::GetInfoResponse>::GetInfo_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetInfoRequest)] = {};
  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
  memset(_request_buffer.data(), 0, GetInfoRequest::PrimarySize);
  _request_buffer.set_actual(sizeof(GetInfoRequest));
  ::fidl::DecodedMessage<GetInfoRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      Volume::InPlace::GetInfo(std::move(_client_end), std::move(_response_buffer)));
}

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

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

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

template <>
Volume::ResultOf::GetStats_Impl<Volume::GetStatsResponse>::GetStats_Impl(::zx::unowned_channel _client_end, bool clear) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetStatsRequest, ::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, GetStatsRequest::PrimarySize);
  auto& _request = *reinterpret_cast<GetStatsRequest*>(_write_bytes);
  _request.clear = std::move(clear);
  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetStatsRequest));
  ::fidl::DecodedMessage<GetStatsRequest> _decoded_request(std::move(_request_bytes));
  Super::SetResult(
      Volume::InPlace::GetStats(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
}

Volume::ResultOf::GetStats Volume::SyncClient::GetStats(bool clear) {
    return ResultOf::GetStats(::zx::unowned_channel(this->channel_), std::move(clear));
}

Volume::ResultOf::GetStats Volume::Call::GetStats(::zx::unowned_channel _client_end, bool clear) {
  return ResultOf::GetStats(std::move(_client_end), std::move(clear));
}

template <>
Volume::UnownedResultOf::GetStats_Impl<Volume::GetStatsResponse>::GetStats_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool clear, ::fidl::BytePart _response_buffer) {
  if (_request_buffer.capacity() < GetStatsRequest::PrimarySize) {
    Super::SetFailure(::fidl::DecodeResult<GetStatsResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
    return;
  }
  memset(_request_buffer.data(), 0, GetStatsRequest::PrimarySize);
  auto& _request = *reinterpret_cast<GetStatsRequest*>(_request_buffer.data());
  _request.clear = std::move(clear);
  _request_buffer.set_actual(sizeof(GetStatsRequest));
  ::fidl::DecodedMessage<GetStatsRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      Volume::InPlace::GetStats(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
}

Volume::UnownedResultOf::GetStats Volume::SyncClient::GetStats(::fidl::BytePart _request_buffer, bool clear, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::GetStats(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(clear), std::move(_response_buffer));
}

Volume::UnownedResultOf::GetStats Volume::Call::GetStats(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool clear, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::GetStats(std::move(_client_end), std::move(_request_buffer), std::move(clear), std::move(_response_buffer));
}

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

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

Volume::ResultOf::GetFifo Volume::SyncClient::GetFifo() {
    return ResultOf::GetFifo(::zx::unowned_channel(this->channel_));
}

Volume::ResultOf::GetFifo Volume::Call::GetFifo(::zx::unowned_channel _client_end) {
  return ResultOf::GetFifo(std::move(_client_end));
}

template <>
Volume::UnownedResultOf::GetFifo_Impl<Volume::GetFifoResponse>::GetFifo_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetFifoRequest)] = {};
  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
  memset(_request_buffer.data(), 0, GetFifoRequest::PrimarySize);
  _request_buffer.set_actual(sizeof(GetFifoRequest));
  ::fidl::DecodedMessage<GetFifoRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      Volume::InPlace::GetFifo(std::move(_client_end), std::move(_response_buffer)));
}

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

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

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

template <>
Volume::ResultOf::AttachVmo_Impl<Volume::AttachVmoResponse>::AttachVmo_Impl(::zx::unowned_channel _client_end, ::zx::vmo vmo) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<AttachVmoRequest, ::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, AttachVmoRequest::PrimarySize);
  auto& _request = *reinterpret_cast<AttachVmoRequest*>(_write_bytes);
  _request.vmo = std::move(vmo);
  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(AttachVmoRequest));
  ::fidl::DecodedMessage<AttachVmoRequest> _decoded_request(std::move(_request_bytes));
  Super::SetResult(
      Volume::InPlace::AttachVmo(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
}

Volume::ResultOf::AttachVmo Volume::SyncClient::AttachVmo(::zx::vmo vmo) {
    return ResultOf::AttachVmo(::zx::unowned_channel(this->channel_), std::move(vmo));
}

Volume::ResultOf::AttachVmo Volume::Call::AttachVmo(::zx::unowned_channel _client_end, ::zx::vmo vmo) {
  return ResultOf::AttachVmo(std::move(_client_end), std::move(vmo));
}

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

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

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

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

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

Volume::ResultOf::CloseFifo Volume::SyncClient::CloseFifo() {
    return ResultOf::CloseFifo(::zx::unowned_channel(this->channel_));
}

Volume::ResultOf::CloseFifo Volume::Call::CloseFifo(::zx::unowned_channel _client_end) {
  return ResultOf::CloseFifo(std::move(_client_end));
}

template <>
Volume::UnownedResultOf::CloseFifo_Impl<Volume::CloseFifoResponse>::CloseFifo_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(CloseFifoRequest)] = {};
  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
  memset(_request_buffer.data(), 0, CloseFifoRequest::PrimarySize);
  _request_buffer.set_actual(sizeof(CloseFifoRequest));
  ::fidl::DecodedMessage<CloseFifoRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      Volume::InPlace::CloseFifo(std::move(_client_end), std::move(_response_buffer)));
}

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

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

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

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

Volume::ResultOf::RebindDevice Volume::SyncClient::RebindDevice() {
    return ResultOf::RebindDevice(::zx::unowned_channel(this->channel_));
}

Volume::ResultOf::RebindDevice Volume::Call::RebindDevice(::zx::unowned_channel _client_end) {
  return ResultOf::RebindDevice(std::move(_client_end));
}

template <>
Volume::UnownedResultOf::RebindDevice_Impl<Volume::RebindDeviceResponse>::RebindDevice_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(RebindDeviceRequest)] = {};
  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
  memset(_request_buffer.data(), 0, RebindDeviceRequest::PrimarySize);
  _request_buffer.set_actual(sizeof(RebindDeviceRequest));
  ::fidl::DecodedMessage<RebindDeviceRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      Volume::InPlace::RebindDevice(std::move(_client_end), std::move(_response_buffer)));
}

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

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

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

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

Volume::ResultOf::GetTypeGuid Volume::SyncClient::GetTypeGuid() {
    return ResultOf::GetTypeGuid(::zx::unowned_channel(this->channel_));
}

Volume::ResultOf::GetTypeGuid Volume::Call::GetTypeGuid(::zx::unowned_channel _client_end) {
  return ResultOf::GetTypeGuid(std::move(_client_end));
}

template <>
Volume::UnownedResultOf::GetTypeGuid_Impl<Volume::GetTypeGuidResponse>::GetTypeGuid_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetTypeGuidRequest)] = {};
  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
  memset(_request_buffer.data(), 0, GetTypeGuidRequest::PrimarySize);
  _request_buffer.set_actual(sizeof(GetTypeGuidRequest));
  ::fidl::DecodedMessage<GetTypeGuidRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      Volume::InPlace::GetTypeGuid(std::move(_client_end), std::move(_response_buffer)));
}

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

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

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

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

Volume::ResultOf::GetInstanceGuid Volume::SyncClient::GetInstanceGuid() {
    return ResultOf::GetInstanceGuid(::zx::unowned_channel(this->channel_));
}

Volume::ResultOf::GetInstanceGuid Volume::Call::GetInstanceGuid(::zx::unowned_channel _client_end) {
  return ResultOf::GetInstanceGuid(std::move(_client_end));
}

template <>
Volume::UnownedResultOf::GetInstanceGuid_Impl<Volume::GetInstanceGuidResponse>::GetInstanceGuid_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetInstanceGuidRequest)] = {};
  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
  memset(_request_buffer.data(), 0, GetInstanceGuidRequest::PrimarySize);
  _request_buffer.set_actual(sizeof(GetInstanceGuidRequest));
  ::fidl::DecodedMessage<GetInstanceGuidRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      Volume::InPlace::GetInstanceGuid(std::move(_client_end), std::move(_response_buffer)));
}

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

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

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

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

Volume::ResultOf::GetName Volume::SyncClient::GetName() {
    return ResultOf::GetName(::zx::unowned_channel(this->channel_));
}

Volume::ResultOf::GetName Volume::Call::GetName(::zx::unowned_channel _client_end) {
  return ResultOf::GetName(std::move(_client_end));
}

template <>
Volume::UnownedResultOf::GetName_Impl<Volume::GetNameResponse>::GetName_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetNameRequest)] = {};
  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
  memset(_request_buffer.data(), 0, GetNameRequest::PrimarySize);
  _request_buffer.set_actual(sizeof(GetNameRequest));
  ::fidl::DecodedMessage<GetNameRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      Volume::InPlace::GetName(std::move(_client_end), std::move(_response_buffer)));
}

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

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

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

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

Volume::ResultOf::Query Volume::SyncClient::Query() {
    return ResultOf::Query(::zx::unowned_channel(this->channel_));
}

Volume::ResultOf::Query Volume::Call::Query(::zx::unowned_channel _client_end) {
  return ResultOf::Query(std::move(_client_end));
}

template <>
Volume::UnownedResultOf::Query_Impl<Volume::QueryResponse>::Query_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(QueryRequest)] = {};
  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
  memset(_request_buffer.data(), 0, QueryRequest::PrimarySize);
  _request_buffer.set_actual(sizeof(QueryRequest));
  ::fidl::DecodedMessage<QueryRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      Volume::InPlace::Query(std::move(_client_end), std::move(_response_buffer)));
}

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

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

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

template <>
Volume::ResultOf::QuerySlices_Impl<Volume::QuerySlicesResponse>::QuerySlices_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<uint64_t> start_slices) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<QuerySlicesRequest, ::fidl::MessageDirection::kSending>();
  ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
  auto& _write_bytes_array = _write_bytes_inlined;
  QuerySlicesRequest _request = {};
  _request.start_slices = std::move(start_slices);
  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<QuerySlicesRequest> _decoded_request = std::move(_linearize_result.message);
  Super::SetResult(
      Volume::InPlace::QuerySlices(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
}

Volume::ResultOf::QuerySlices Volume::SyncClient::QuerySlices(::fidl::VectorView<uint64_t> start_slices) {
    return ResultOf::QuerySlices(::zx::unowned_channel(this->channel_), std::move(start_slices));
}

Volume::ResultOf::QuerySlices Volume::Call::QuerySlices(::zx::unowned_channel _client_end, ::fidl::VectorView<uint64_t> start_slices) {
  return ResultOf::QuerySlices(std::move(_client_end), std::move(start_slices));
}

template <>
Volume::UnownedResultOf::QuerySlices_Impl<Volume::QuerySlicesResponse>::QuerySlices_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint64_t> start_slices, ::fidl::BytePart _response_buffer) {
  if (_request_buffer.capacity() < QuerySlicesRequest::PrimarySize) {
    Super::SetFailure(::fidl::DecodeResult<QuerySlicesResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
    return;
  }
  QuerySlicesRequest _request = {};
  _request.start_slices = std::move(start_slices);
  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<QuerySlicesRequest> _decoded_request = std::move(_linearize_result.message);
  Super::SetResult(
      Volume::InPlace::QuerySlices(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
}

Volume::UnownedResultOf::QuerySlices Volume::SyncClient::QuerySlices(::fidl::BytePart _request_buffer, ::fidl::VectorView<uint64_t> start_slices, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::QuerySlices(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(start_slices), std::move(_response_buffer));
}

Volume::UnownedResultOf::QuerySlices Volume::Call::QuerySlices(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint64_t> start_slices, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::QuerySlices(std::move(_client_end), std::move(_request_buffer), std::move(start_slices), std::move(_response_buffer));
}

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

template <>
Volume::ResultOf::Extend_Impl<Volume::ExtendResponse>::Extend_Impl(::zx::unowned_channel _client_end, uint64_t start_slice, uint64_t slice_count) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ExtendRequest, ::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, ExtendRequest::PrimarySize);
  auto& _request = *reinterpret_cast<ExtendRequest*>(_write_bytes);
  _request.start_slice = std::move(start_slice);
  _request.slice_count = std::move(slice_count);
  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ExtendRequest));
  ::fidl::DecodedMessage<ExtendRequest> _decoded_request(std::move(_request_bytes));
  Super::SetResult(
      Volume::InPlace::Extend(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
}

Volume::ResultOf::Extend Volume::SyncClient::Extend(uint64_t start_slice, uint64_t slice_count) {
    return ResultOf::Extend(::zx::unowned_channel(this->channel_), std::move(start_slice), std::move(slice_count));
}

Volume::ResultOf::Extend Volume::Call::Extend(::zx::unowned_channel _client_end, uint64_t start_slice, uint64_t slice_count) {
  return ResultOf::Extend(std::move(_client_end), std::move(start_slice), std::move(slice_count));
}

template <>
Volume::UnownedResultOf::Extend_Impl<Volume::ExtendResponse>::Extend_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t start_slice, uint64_t slice_count, ::fidl::BytePart _response_buffer) {
  if (_request_buffer.capacity() < ExtendRequest::PrimarySize) {
    Super::SetFailure(::fidl::DecodeResult<ExtendResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
    return;
  }
  memset(_request_buffer.data(), 0, ExtendRequest::PrimarySize);
  auto& _request = *reinterpret_cast<ExtendRequest*>(_request_buffer.data());
  _request.start_slice = std::move(start_slice);
  _request.slice_count = std::move(slice_count);
  _request_buffer.set_actual(sizeof(ExtendRequest));
  ::fidl::DecodedMessage<ExtendRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      Volume::InPlace::Extend(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
}

Volume::UnownedResultOf::Extend Volume::SyncClient::Extend(::fidl::BytePart _request_buffer, uint64_t start_slice, uint64_t slice_count, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::Extend(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(start_slice), std::move(slice_count), std::move(_response_buffer));
}

Volume::UnownedResultOf::Extend Volume::Call::Extend(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t start_slice, uint64_t slice_count, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::Extend(std::move(_client_end), std::move(_request_buffer), std::move(start_slice), std::move(slice_count), std::move(_response_buffer));
}

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

template <>
Volume::ResultOf::Shrink_Impl<Volume::ShrinkResponse>::Shrink_Impl(::zx::unowned_channel _client_end, uint64_t start_slice, uint64_t slice_count) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ShrinkRequest, ::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, ShrinkRequest::PrimarySize);
  auto& _request = *reinterpret_cast<ShrinkRequest*>(_write_bytes);
  _request.start_slice = std::move(start_slice);
  _request.slice_count = std::move(slice_count);
  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ShrinkRequest));
  ::fidl::DecodedMessage<ShrinkRequest> _decoded_request(std::move(_request_bytes));
  Super::SetResult(
      Volume::InPlace::Shrink(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
}

Volume::ResultOf::Shrink Volume::SyncClient::Shrink(uint64_t start_slice, uint64_t slice_count) {
    return ResultOf::Shrink(::zx::unowned_channel(this->channel_), std::move(start_slice), std::move(slice_count));
}

Volume::ResultOf::Shrink Volume::Call::Shrink(::zx::unowned_channel _client_end, uint64_t start_slice, uint64_t slice_count) {
  return ResultOf::Shrink(std::move(_client_end), std::move(start_slice), std::move(slice_count));
}

template <>
Volume::UnownedResultOf::Shrink_Impl<Volume::ShrinkResponse>::Shrink_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t start_slice, uint64_t slice_count, ::fidl::BytePart _response_buffer) {
  if (_request_buffer.capacity() < ShrinkRequest::PrimarySize) {
    Super::SetFailure(::fidl::DecodeResult<ShrinkResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
    return;
  }
  memset(_request_buffer.data(), 0, ShrinkRequest::PrimarySize);
  auto& _request = *reinterpret_cast<ShrinkRequest*>(_request_buffer.data());
  _request.start_slice = std::move(start_slice);
  _request.slice_count = std::move(slice_count);
  _request_buffer.set_actual(sizeof(ShrinkRequest));
  ::fidl::DecodedMessage<ShrinkRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      Volume::InPlace::Shrink(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
}

Volume::UnownedResultOf::Shrink Volume::SyncClient::Shrink(::fidl::BytePart _request_buffer, uint64_t start_slice, uint64_t slice_count, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::Shrink(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(start_slice), std::move(slice_count), std::move(_response_buffer));
}

Volume::UnownedResultOf::Shrink Volume::Call::Shrink(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t start_slice, uint64_t slice_count, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::Shrink(std::move(_client_end), std::move(_request_buffer), std::move(start_slice), std::move(slice_count), std::move(_response_buffer));
}

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

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

Volume::ResultOf::Destroy Volume::SyncClient::Destroy() {
    return ResultOf::Destroy(::zx::unowned_channel(this->channel_));
}

Volume::ResultOf::Destroy Volume::Call::Destroy(::zx::unowned_channel _client_end) {
  return ResultOf::Destroy(std::move(_client_end));
}

template <>
Volume::UnownedResultOf::Destroy_Impl<Volume::DestroyResponse>::Destroy_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(DestroyRequest)] = {};
  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
  memset(_request_buffer.data(), 0, DestroyRequest::PrimarySize);
  _request_buffer.set_actual(sizeof(DestroyRequest));
  ::fidl::DecodedMessage<DestroyRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      Volume::InPlace::Destroy(std::move(_client_end), std::move(_response_buffer)));
}

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

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

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


bool Volume::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 kVolume_GetInfo_Ordinal:
    case kVolume_GetInfo_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<GetInfoRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      impl->GetInfo(
          Interface::GetInfoCompleter::Sync(txn));
      return true;
    }
    case kVolume_GetStats_Ordinal:
    case kVolume_GetStats_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<GetStatsRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->GetStats(std::move(message->clear),
          Interface::GetStatsCompleter::Sync(txn));
      return true;
    }
    case kVolume_GetFifo_Ordinal:
    case kVolume_GetFifo_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<GetFifoRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      impl->GetFifo(
          Interface::GetFifoCompleter::Sync(txn));
      return true;
    }
    case kVolume_AttachVmo_Ordinal:
    case kVolume_AttachVmo_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<AttachVmoRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->AttachVmo(std::move(message->vmo),
          Interface::AttachVmoCompleter::Sync(txn));
      return true;
    }
    case kVolume_CloseFifo_Ordinal:
    case kVolume_CloseFifo_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<CloseFifoRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      impl->CloseFifo(
          Interface::CloseFifoCompleter::Sync(txn));
      return true;
    }
    case kVolume_RebindDevice_Ordinal:
    case kVolume_RebindDevice_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<RebindDeviceRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      impl->RebindDevice(
          Interface::RebindDeviceCompleter::Sync(txn));
      return true;
    }
    case kVolume_GetTypeGuid_Ordinal:
    case kVolume_GetTypeGuid_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<GetTypeGuidRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      impl->GetTypeGuid(
          Interface::GetTypeGuidCompleter::Sync(txn));
      return true;
    }
    case kVolume_GetInstanceGuid_Ordinal:
    case kVolume_GetInstanceGuid_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<GetInstanceGuidRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      impl->GetInstanceGuid(
          Interface::GetInstanceGuidCompleter::Sync(txn));
      return true;
    }
    case kVolume_GetName_Ordinal:
    case kVolume_GetName_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<GetNameRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      impl->GetName(
          Interface::GetNameCompleter::Sync(txn));
      return true;
    }
    case kVolume_Query_Ordinal:
    case kVolume_Query_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<QueryRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      impl->Query(
          Interface::QueryCompleter::Sync(txn));
      return true;
    }
    case kVolume_QuerySlices_Ordinal:
    case kVolume_QuerySlices_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<QuerySlicesRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->QuerySlices(std::move(message->start_slices),
          Interface::QuerySlicesCompleter::Sync(txn));
      return true;
    }
    case kVolume_Extend_Ordinal:
    case kVolume_Extend_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<ExtendRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->Extend(std::move(message->start_slice), std::move(message->slice_count),
          Interface::ExtendCompleter::Sync(txn));
      return true;
    }
    case kVolume_Shrink_Ordinal:
    case kVolume_Shrink_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<ShrinkRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->Shrink(std::move(message->start_slice), std::move(message->slice_count),
          Interface::ShrinkCompleter::Sync(txn));
      return true;
    }
    case kVolume_Destroy_Ordinal:
    case kVolume_Destroy_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<DestroyRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      impl->Destroy(
          Interface::DestroyCompleter::Sync(txn));
      return true;
    }
    default: {
      return false;
    }
  }
}

bool Volume::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 Volume::Interface::GetInfoCompleterBase::Reply(int32_t status, ::llcpp::fuchsia::hardware::block::BlockInfo* info) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetInfoResponse, ::fidl::MessageDirection::kSending>();
  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
  GetInfoResponse _response = {};
  Volume::SetTransactionHeaderFor::GetInfoResponse(
      ::fidl::DecodedMessage<GetInfoResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              GetInfoResponse::PrimarySize,
              GetInfoResponse::PrimarySize)));
  _response.status = std::move(status);
  _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 Volume::Interface::GetInfoCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::llcpp::fuchsia::hardware::block::BlockInfo* info) {
  if (_buffer.capacity() < GetInfoResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  GetInfoResponse _response = {};
  Volume::SetTransactionHeaderFor::GetInfoResponse(
      ::fidl::DecodedMessage<GetInfoResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              GetInfoResponse::PrimarySize,
              GetInfoResponse::PrimarySize)));
  _response.status = std::move(status);
  _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 Volume::Interface::GetInfoCompleterBase::Reply(::fidl::DecodedMessage<GetInfoResponse> params) {
  Volume::SetTransactionHeaderFor::GetInfoResponse(params);
  CompleterBase::SendReply(std::move(params));
}


void Volume::Interface::GetStatsCompleterBase::Reply(int32_t status, ::llcpp::fuchsia::hardware::block::BlockStats* stats) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetStatsResponse, ::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();
  GetStatsResponse _response = {};
  Volume::SetTransactionHeaderFor::GetStatsResponse(
      ::fidl::DecodedMessage<GetStatsResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              GetStatsResponse::PrimarySize,
              GetStatsResponse::PrimarySize)));
  _response.status = std::move(status);
  _response.stats = std::move(stats);
  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 Volume::Interface::GetStatsCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::llcpp::fuchsia::hardware::block::BlockStats* stats) {
  if (_buffer.capacity() < GetStatsResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  GetStatsResponse _response = {};
  Volume::SetTransactionHeaderFor::GetStatsResponse(
      ::fidl::DecodedMessage<GetStatsResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              GetStatsResponse::PrimarySize,
              GetStatsResponse::PrimarySize)));
  _response.status = std::move(status);
  _response.stats = std::move(stats);
  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 Volume::Interface::GetStatsCompleterBase::Reply(::fidl::DecodedMessage<GetStatsResponse> params) {
  Volume::SetTransactionHeaderFor::GetStatsResponse(params);
  CompleterBase::SendReply(std::move(params));
}


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

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

void Volume::Interface::GetFifoCompleterBase::Reply(::fidl::DecodedMessage<GetFifoResponse> params) {
  Volume::SetTransactionHeaderFor::GetFifoResponse(params);
  CompleterBase::SendReply(std::move(params));
}


void Volume::Interface::AttachVmoCompleterBase::Reply(int32_t status, ::llcpp::fuchsia::hardware::block::VmoID* vmoid) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<AttachVmoResponse, ::fidl::MessageDirection::kSending>();
  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
  AttachVmoResponse _response = {};
  Volume::SetTransactionHeaderFor::AttachVmoResponse(
      ::fidl::DecodedMessage<AttachVmoResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              AttachVmoResponse::PrimarySize,
              AttachVmoResponse::PrimarySize)));
  _response.status = std::move(status);
  _response.vmoid = std::move(vmoid);
  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 Volume::Interface::AttachVmoCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::llcpp::fuchsia::hardware::block::VmoID* vmoid) {
  if (_buffer.capacity() < AttachVmoResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  AttachVmoResponse _response = {};
  Volume::SetTransactionHeaderFor::AttachVmoResponse(
      ::fidl::DecodedMessage<AttachVmoResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              AttachVmoResponse::PrimarySize,
              AttachVmoResponse::PrimarySize)));
  _response.status = std::move(status);
  _response.vmoid = std::move(vmoid);
  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 Volume::Interface::AttachVmoCompleterBase::Reply(::fidl::DecodedMessage<AttachVmoResponse> params) {
  Volume::SetTransactionHeaderFor::AttachVmoResponse(params);
  CompleterBase::SendReply(std::move(params));
}


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

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

void Volume::Interface::CloseFifoCompleterBase::Reply(::fidl::DecodedMessage<CloseFifoResponse> params) {
  Volume::SetTransactionHeaderFor::CloseFifoResponse(params);
  CompleterBase::SendReply(std::move(params));
}


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

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

void Volume::Interface::RebindDeviceCompleterBase::Reply(::fidl::DecodedMessage<RebindDeviceResponse> params) {
  Volume::SetTransactionHeaderFor::RebindDeviceResponse(params);
  CompleterBase::SendReply(std::move(params));
}


void Volume::Interface::GetTypeGuidCompleterBase::Reply(int32_t status, ::llcpp::fuchsia::hardware::block::partition::GUID* guid) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetTypeGuidResponse, ::fidl::MessageDirection::kSending>();
  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
  GetTypeGuidResponse _response = {};
  Volume::SetTransactionHeaderFor::GetTypeGuidResponse(
      ::fidl::DecodedMessage<GetTypeGuidResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              GetTypeGuidResponse::PrimarySize,
              GetTypeGuidResponse::PrimarySize)));
  _response.status = std::move(status);
  _response.guid = std::move(guid);
  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 Volume::Interface::GetTypeGuidCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::llcpp::fuchsia::hardware::block::partition::GUID* guid) {
  if (_buffer.capacity() < GetTypeGuidResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  GetTypeGuidResponse _response = {};
  Volume::SetTransactionHeaderFor::GetTypeGuidResponse(
      ::fidl::DecodedMessage<GetTypeGuidResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              GetTypeGuidResponse::PrimarySize,
              GetTypeGuidResponse::PrimarySize)));
  _response.status = std::move(status);
  _response.guid = std::move(guid);
  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 Volume::Interface::GetTypeGuidCompleterBase::Reply(::fidl::DecodedMessage<GetTypeGuidResponse> params) {
  Volume::SetTransactionHeaderFor::GetTypeGuidResponse(params);
  CompleterBase::SendReply(std::move(params));
}


void Volume::Interface::GetInstanceGuidCompleterBase::Reply(int32_t status, ::llcpp::fuchsia::hardware::block::partition::GUID* guid) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetInstanceGuidResponse, ::fidl::MessageDirection::kSending>();
  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
  GetInstanceGuidResponse _response = {};
  Volume::SetTransactionHeaderFor::GetInstanceGuidResponse(
      ::fidl::DecodedMessage<GetInstanceGuidResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              GetInstanceGuidResponse::PrimarySize,
              GetInstanceGuidResponse::PrimarySize)));
  _response.status = std::move(status);
  _response.guid = std::move(guid);
  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 Volume::Interface::GetInstanceGuidCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::llcpp::fuchsia::hardware::block::partition::GUID* guid) {
  if (_buffer.capacity() < GetInstanceGuidResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  GetInstanceGuidResponse _response = {};
  Volume::SetTransactionHeaderFor::GetInstanceGuidResponse(
      ::fidl::DecodedMessage<GetInstanceGuidResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              GetInstanceGuidResponse::PrimarySize,
              GetInstanceGuidResponse::PrimarySize)));
  _response.status = std::move(status);
  _response.guid = std::move(guid);
  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 Volume::Interface::GetInstanceGuidCompleterBase::Reply(::fidl::DecodedMessage<GetInstanceGuidResponse> params) {
  Volume::SetTransactionHeaderFor::GetInstanceGuidResponse(params);
  CompleterBase::SendReply(std::move(params));
}


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


void Volume::Interface::QueryCompleterBase::Reply(int32_t status, ::llcpp::fuchsia::hardware::block::volume::VolumeInfo* info) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<QueryResponse, ::fidl::MessageDirection::kSending>();
  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
  QueryResponse _response = {};
  Volume::SetTransactionHeaderFor::QueryResponse(
      ::fidl::DecodedMessage<QueryResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              QueryResponse::PrimarySize,
              QueryResponse::PrimarySize)));
  _response.status = std::move(status);
  _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 Volume::Interface::QueryCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::llcpp::fuchsia::hardware::block::volume::VolumeInfo* info) {
  if (_buffer.capacity() < QueryResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  QueryResponse _response = {};
  Volume::SetTransactionHeaderFor::QueryResponse(
      ::fidl::DecodedMessage<QueryResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              QueryResponse::PrimarySize,
              QueryResponse::PrimarySize)));
  _response.status = std::move(status);
  _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 Volume::Interface::QueryCompleterBase::Reply(::fidl::DecodedMessage<QueryResponse> params) {
  Volume::SetTransactionHeaderFor::QueryResponse(params);
  CompleterBase::SendReply(std::move(params));
}


void Volume::Interface::QuerySlicesCompleterBase::Reply(int32_t status, ::fidl::Array<::llcpp::fuchsia::hardware::block::volume::VsliceRange, 16> response, uint64_t response_count) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<QuerySlicesResponse, ::fidl::MessageDirection::kSending>();
  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
  auto& _response = *reinterpret_cast<QuerySlicesResponse*>(_write_bytes);
  Volume::SetTransactionHeaderFor::QuerySlicesResponse(
      ::fidl::DecodedMessage<QuerySlicesResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              QuerySlicesResponse::PrimarySize,
              QuerySlicesResponse::PrimarySize)));
  _response.status = std::move(status);
  _response.response = std::move(response);
  _response.response_count = std::move(response_count);
  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(QuerySlicesResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<QuerySlicesResponse>(std::move(_response_bytes)));
}

void Volume::Interface::QuerySlicesCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::fidl::Array<::llcpp::fuchsia::hardware::block::volume::VsliceRange, 16> response, uint64_t response_count) {
  if (_buffer.capacity() < QuerySlicesResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  auto& _response = *reinterpret_cast<QuerySlicesResponse*>(_buffer.data());
  Volume::SetTransactionHeaderFor::QuerySlicesResponse(
      ::fidl::DecodedMessage<QuerySlicesResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              QuerySlicesResponse::PrimarySize,
              QuerySlicesResponse::PrimarySize)));
  _response.status = std::move(status);
  _response.response = std::move(response);
  _response.response_count = std::move(response_count);
  _buffer.set_actual(sizeof(QuerySlicesResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<QuerySlicesResponse>(std::move(_buffer)));
}

void Volume::Interface::QuerySlicesCompleterBase::Reply(::fidl::DecodedMessage<QuerySlicesResponse> params) {
  Volume::SetTransactionHeaderFor::QuerySlicesResponse(params);
  CompleterBase::SendReply(std::move(params));
}


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

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

void Volume::Interface::ExtendCompleterBase::Reply(::fidl::DecodedMessage<ExtendResponse> params) {
  Volume::SetTransactionHeaderFor::ExtendResponse(params);
  CompleterBase::SendReply(std::move(params));
}


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

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

void Volume::Interface::ShrinkCompleterBase::Reply(::fidl::DecodedMessage<ShrinkResponse> params) {
  Volume::SetTransactionHeaderFor::ShrinkResponse(params);
  CompleterBase::SendReply(std::move(params));
}


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

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

void Volume::Interface::DestroyCompleterBase::Reply(::fidl::DecodedMessage<DestroyResponse> params) {
  Volume::SetTransactionHeaderFor::DestroyResponse(params);
  CompleterBase::SendReply(std::move(params));
}



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

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

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

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

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

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

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

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

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

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

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

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

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

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

namespace {

[[maybe_unused]]
constexpr uint64_t kVolumeManager_AllocatePartition_Ordinal = 0x33fab3bd00000000lu;
[[maybe_unused]]
constexpr uint64_t kVolumeManager_AllocatePartition_GenOrdinal = 0x4e79f24ed059e394lu;
extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeManagerAllocatePartitionRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeManagerAllocatePartitionResponseTable;
[[maybe_unused]]
constexpr uint64_t kVolumeManager_Query_Ordinal = 0x4591d72f00000000lu;
[[maybe_unused]]
constexpr uint64_t kVolumeManager_Query_GenOrdinal = 0x7604167e7b72904flu;
extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeManagerQueryRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeManagerQueryResponseTable;
[[maybe_unused]]
constexpr uint64_t kVolumeManager_GetInfo_Ordinal = 0x21196e0c00000000lu;
[[maybe_unused]]
constexpr uint64_t kVolumeManager_GetInfo_GenOrdinal = 0x735b3548582b2c9lu;
extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeManagerGetInfoRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeManagerGetInfoResponseTable;
[[maybe_unused]]
constexpr uint64_t kVolumeManager_Activate_Ordinal = 0x45f8979b00000000lu;
[[maybe_unused]]
constexpr uint64_t kVolumeManager_Activate_GenOrdinal = 0xc8cef57012874d0lu;
extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeManagerActivateRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeManagerActivateResponseTable;

}  // namespace
template <>
VolumeManager::ResultOf::AllocatePartition_Impl<VolumeManager::AllocatePartitionResponse>::AllocatePartition_Impl(::zx::unowned_channel _client_end, uint64_t slice_count, ::llcpp::fuchsia::hardware::block::partition::GUID type, ::llcpp::fuchsia::hardware::block::partition::GUID instance, ::fidl::StringView name, uint32_t flags) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<AllocatePartitionRequest, ::fidl::MessageDirection::kSending>();
  ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
  auto& _write_bytes_array = _write_bytes_inlined;
  AllocatePartitionRequest _request = {};
  _request.slice_count = std::move(slice_count);
  _request.type = std::move(type);
  _request.instance = std::move(instance);
  _request.name = std::move(name);
  _request.flags = std::move(flags);
  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<AllocatePartitionRequest> _decoded_request = std::move(_linearize_result.message);
  Super::SetResult(
      VolumeManager::InPlace::AllocatePartition(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
}

VolumeManager::ResultOf::AllocatePartition VolumeManager::SyncClient::AllocatePartition(uint64_t slice_count, ::llcpp::fuchsia::hardware::block::partition::GUID type, ::llcpp::fuchsia::hardware::block::partition::GUID instance, ::fidl::StringView name, uint32_t flags) {
    return ResultOf::AllocatePartition(::zx::unowned_channel(this->channel_), std::move(slice_count), std::move(type), std::move(instance), std::move(name), std::move(flags));
}

VolumeManager::ResultOf::AllocatePartition VolumeManager::Call::AllocatePartition(::zx::unowned_channel _client_end, uint64_t slice_count, ::llcpp::fuchsia::hardware::block::partition::GUID type, ::llcpp::fuchsia::hardware::block::partition::GUID instance, ::fidl::StringView name, uint32_t flags) {
  return ResultOf::AllocatePartition(std::move(_client_end), std::move(slice_count), std::move(type), std::move(instance), std::move(name), std::move(flags));
}

template <>
VolumeManager::UnownedResultOf::AllocatePartition_Impl<VolumeManager::AllocatePartitionResponse>::AllocatePartition_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t slice_count, ::llcpp::fuchsia::hardware::block::partition::GUID type, ::llcpp::fuchsia::hardware::block::partition::GUID instance, ::fidl::StringView name, uint32_t flags, ::fidl::BytePart _response_buffer) {
  if (_request_buffer.capacity() < AllocatePartitionRequest::PrimarySize) {
    Super::SetFailure(::fidl::DecodeResult<AllocatePartitionResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
    return;
  }
  AllocatePartitionRequest _request = {};
  _request.slice_count = std::move(slice_count);
  _request.type = std::move(type);
  _request.instance = std::move(instance);
  _request.name = std::move(name);
  _request.flags = std::move(flags);
  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<AllocatePartitionRequest> _decoded_request = std::move(_linearize_result.message);
  Super::SetResult(
      VolumeManager::InPlace::AllocatePartition(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
}

VolumeManager::UnownedResultOf::AllocatePartition VolumeManager::SyncClient::AllocatePartition(::fidl::BytePart _request_buffer, uint64_t slice_count, ::llcpp::fuchsia::hardware::block::partition::GUID type, ::llcpp::fuchsia::hardware::block::partition::GUID instance, ::fidl::StringView name, uint32_t flags, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::AllocatePartition(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(slice_count), std::move(type), std::move(instance), std::move(name), std::move(flags), std::move(_response_buffer));
}

VolumeManager::UnownedResultOf::AllocatePartition VolumeManager::Call::AllocatePartition(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t slice_count, ::llcpp::fuchsia::hardware::block::partition::GUID type, ::llcpp::fuchsia::hardware::block::partition::GUID instance, ::fidl::StringView name, uint32_t flags, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::AllocatePartition(std::move(_client_end), std::move(_request_buffer), std::move(slice_count), std::move(type), std::move(instance), std::move(name), std::move(flags), std::move(_response_buffer));
}

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

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

VolumeManager::ResultOf::Query VolumeManager::SyncClient::Query() {
    return ResultOf::Query(::zx::unowned_channel(this->channel_));
}

VolumeManager::ResultOf::Query VolumeManager::Call::Query(::zx::unowned_channel _client_end) {
  return ResultOf::Query(std::move(_client_end));
}

template <>
VolumeManager::UnownedResultOf::Query_Impl<VolumeManager::QueryResponse>::Query_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(QueryRequest)] = {};
  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
  memset(_request_buffer.data(), 0, QueryRequest::PrimarySize);
  _request_buffer.set_actual(sizeof(QueryRequest));
  ::fidl::DecodedMessage<QueryRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      VolumeManager::InPlace::Query(std::move(_client_end), std::move(_response_buffer)));
}

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

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

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

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

VolumeManager::ResultOf::GetInfo VolumeManager::SyncClient::GetInfo() {
    return ResultOf::GetInfo(::zx::unowned_channel(this->channel_));
}

VolumeManager::ResultOf::GetInfo VolumeManager::Call::GetInfo(::zx::unowned_channel _client_end) {
  return ResultOf::GetInfo(std::move(_client_end));
}

template <>
VolumeManager::UnownedResultOf::GetInfo_Impl<VolumeManager::GetInfoResponse>::GetInfo_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetInfoRequest)] = {};
  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
  memset(_request_buffer.data(), 0, GetInfoRequest::PrimarySize);
  _request_buffer.set_actual(sizeof(GetInfoRequest));
  ::fidl::DecodedMessage<GetInfoRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      VolumeManager::InPlace::GetInfo(std::move(_client_end), std::move(_response_buffer)));
}

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

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

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

template <>
VolumeManager::ResultOf::Activate_Impl<VolumeManager::ActivateResponse>::Activate_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::block::partition::GUID old_guid, ::llcpp::fuchsia::hardware::block::partition::GUID new_guid) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ActivateRequest, ::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, ActivateRequest::PrimarySize);
  auto& _request = *reinterpret_cast<ActivateRequest*>(_write_bytes);
  _request.old_guid = std::move(old_guid);
  _request.new_guid = std::move(new_guid);
  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ActivateRequest));
  ::fidl::DecodedMessage<ActivateRequest> _decoded_request(std::move(_request_bytes));
  Super::SetResult(
      VolumeManager::InPlace::Activate(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
}

VolumeManager::ResultOf::Activate VolumeManager::SyncClient::Activate(::llcpp::fuchsia::hardware::block::partition::GUID old_guid, ::llcpp::fuchsia::hardware::block::partition::GUID new_guid) {
    return ResultOf::Activate(::zx::unowned_channel(this->channel_), std::move(old_guid), std::move(new_guid));
}

VolumeManager::ResultOf::Activate VolumeManager::Call::Activate(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::block::partition::GUID old_guid, ::llcpp::fuchsia::hardware::block::partition::GUID new_guid) {
  return ResultOf::Activate(std::move(_client_end), std::move(old_guid), std::move(new_guid));
}

template <>
VolumeManager::UnownedResultOf::Activate_Impl<VolumeManager::ActivateResponse>::Activate_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::block::partition::GUID old_guid, ::llcpp::fuchsia::hardware::block::partition::GUID new_guid, ::fidl::BytePart _response_buffer) {
  if (_request_buffer.capacity() < ActivateRequest::PrimarySize) {
    Super::SetFailure(::fidl::DecodeResult<ActivateResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
    return;
  }
  memset(_request_buffer.data(), 0, ActivateRequest::PrimarySize);
  auto& _request = *reinterpret_cast<ActivateRequest*>(_request_buffer.data());
  _request.old_guid = std::move(old_guid);
  _request.new_guid = std::move(new_guid);
  _request_buffer.set_actual(sizeof(ActivateRequest));
  ::fidl::DecodedMessage<ActivateRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      VolumeManager::InPlace::Activate(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
}

VolumeManager::UnownedResultOf::Activate VolumeManager::SyncClient::Activate(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::block::partition::GUID old_guid, ::llcpp::fuchsia::hardware::block::partition::GUID new_guid, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::Activate(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(old_guid), std::move(new_guid), std::move(_response_buffer));
}

VolumeManager::UnownedResultOf::Activate VolumeManager::Call::Activate(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::block::partition::GUID old_guid, ::llcpp::fuchsia::hardware::block::partition::GUID new_guid, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::Activate(std::move(_client_end), std::move(_request_buffer), std::move(old_guid), std::move(new_guid), std::move(_response_buffer));
}

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


bool VolumeManager::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 kVolumeManager_AllocatePartition_Ordinal:
    case kVolumeManager_AllocatePartition_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<AllocatePartitionRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->AllocatePartition(std::move(message->slice_count), std::move(message->type), std::move(message->instance), std::move(message->name), std::move(message->flags),
          Interface::AllocatePartitionCompleter::Sync(txn));
      return true;
    }
    case kVolumeManager_Query_Ordinal:
    case kVolumeManager_Query_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<QueryRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      impl->Query(
          Interface::QueryCompleter::Sync(txn));
      return true;
    }
    case kVolumeManager_GetInfo_Ordinal:
    case kVolumeManager_GetInfo_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<GetInfoRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      impl->GetInfo(
          Interface::GetInfoCompleter::Sync(txn));
      return true;
    }
    case kVolumeManager_Activate_Ordinal:
    case kVolumeManager_Activate_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<ActivateRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->Activate(std::move(message->old_guid), std::move(message->new_guid),
          Interface::ActivateCompleter::Sync(txn));
      return true;
    }
    default: {
      return false;
    }
  }
}

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

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

void VolumeManager::Interface::AllocatePartitionCompleterBase::Reply(::fidl::DecodedMessage<AllocatePartitionResponse> params) {
  VolumeManager::SetTransactionHeaderFor::AllocatePartitionResponse(params);
  CompleterBase::SendReply(std::move(params));
}


void VolumeManager::Interface::QueryCompleterBase::Reply(int32_t status, ::llcpp::fuchsia::hardware::block::volume::VolumeInfo* info) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<QueryResponse, ::fidl::MessageDirection::kSending>();
  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
  QueryResponse _response = {};
  VolumeManager::SetTransactionHeaderFor::QueryResponse(
      ::fidl::DecodedMessage<QueryResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              QueryResponse::PrimarySize,
              QueryResponse::PrimarySize)));
  _response.status = std::move(status);
  _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 VolumeManager::Interface::QueryCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::llcpp::fuchsia::hardware::block::volume::VolumeInfo* info) {
  if (_buffer.capacity() < QueryResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  QueryResponse _response = {};
  VolumeManager::SetTransactionHeaderFor::QueryResponse(
      ::fidl::DecodedMessage<QueryResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              QueryResponse::PrimarySize,
              QueryResponse::PrimarySize)));
  _response.status = std::move(status);
  _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 VolumeManager::Interface::QueryCompleterBase::Reply(::fidl::DecodedMessage<QueryResponse> params) {
  VolumeManager::SetTransactionHeaderFor::QueryResponse(params);
  CompleterBase::SendReply(std::move(params));
}


void VolumeManager::Interface::GetInfoCompleterBase::Reply(int32_t status, ::llcpp::fuchsia::hardware::block::volume::VolumeManagerInfo* info) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetInfoResponse, ::fidl::MessageDirection::kSending>();
  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
  GetInfoResponse _response = {};
  VolumeManager::SetTransactionHeaderFor::GetInfoResponse(
      ::fidl::DecodedMessage<GetInfoResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              GetInfoResponse::PrimarySize,
              GetInfoResponse::PrimarySize)));
  _response.status = std::move(status);
  _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 VolumeManager::Interface::GetInfoCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::llcpp::fuchsia::hardware::block::volume::VolumeManagerInfo* info) {
  if (_buffer.capacity() < GetInfoResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  GetInfoResponse _response = {};
  VolumeManager::SetTransactionHeaderFor::GetInfoResponse(
      ::fidl::DecodedMessage<GetInfoResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              GetInfoResponse::PrimarySize,
              GetInfoResponse::PrimarySize)));
  _response.status = std::move(status);
  _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 VolumeManager::Interface::GetInfoCompleterBase::Reply(::fidl::DecodedMessage<GetInfoResponse> params) {
  VolumeManager::SetTransactionHeaderFor::GetInfoResponse(params);
  CompleterBase::SendReply(std::move(params));
}


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

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

void VolumeManager::Interface::ActivateCompleterBase::Reply(::fidl::DecodedMessage<ActivateResponse> params) {
  VolumeManager::SetTransactionHeaderFor::ActivateResponse(params);
  CompleterBase::SendReply(std::move(params));
}



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

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

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

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

}  // namespace volume
}  // namespace block
}  // namespace hardware
}  // namespace fuchsia
}  // namespace llcpp