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

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

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

namespace llcpp {

namespace fuchsia {
namespace hardware {
namespace block {
namespace partition {

namespace {

[[maybe_unused]]
constexpr uint64_t kPartition_GetInfo_Ordinal = 0x7279049800000000lu;
[[maybe_unused]]
constexpr uint64_t kPartition_GetInfo_GenOrdinal = 0x79df1a5cdb6cc6a3lu;
extern "C" const fidl_type_t v1_fuchsia_hardware_block_partition_PartitionGetInfoRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_block_partition_PartitionGetInfoResponseTable;
[[maybe_unused]]
constexpr uint64_t kPartition_GetStats_Ordinal = 0x73b9275400000000lu;
[[maybe_unused]]
constexpr uint64_t kPartition_GetStats_GenOrdinal = 0x53d9542a778385aelu;
extern "C" const fidl_type_t v1_fuchsia_hardware_block_partition_PartitionGetStatsRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_block_partition_PartitionGetStatsResponseTable;
[[maybe_unused]]
constexpr uint64_t kPartition_GetFifo_Ordinal = 0x63616dbe00000000lu;
[[maybe_unused]]
constexpr uint64_t kPartition_GetFifo_GenOrdinal = 0x507ea563fb50747elu;
extern "C" const fidl_type_t v1_fuchsia_hardware_block_partition_PartitionGetFifoRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_block_partition_PartitionGetFifoResponseTable;
[[maybe_unused]]
constexpr uint64_t kPartition_AttachVmo_Ordinal = 0x72df2e6600000000lu;
[[maybe_unused]]
constexpr uint64_t kPartition_AttachVmo_GenOrdinal = 0x7e726e5993add9b7lu;
extern "C" const fidl_type_t v1_fuchsia_hardware_block_partition_PartitionAttachVmoRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_block_partition_PartitionAttachVmoResponseTable;
[[maybe_unused]]
constexpr uint64_t kPartition_CloseFifo_Ordinal = 0x6b4a461300000000lu;
[[maybe_unused]]
constexpr uint64_t kPartition_CloseFifo_GenOrdinal = 0x4dc09acdfa2a2a65lu;
extern "C" const fidl_type_t v1_fuchsia_hardware_block_partition_PartitionCloseFifoRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_block_partition_PartitionCloseFifoResponseTable;
[[maybe_unused]]
constexpr uint64_t kPartition_RebindDevice_Ordinal = 0x2c1ffdb000000000lu;
[[maybe_unused]]
constexpr uint64_t kPartition_RebindDevice_GenOrdinal = 0x5d728cbd5312c9aelu;
extern "C" const fidl_type_t v1_fuchsia_hardware_block_partition_PartitionRebindDeviceRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_block_partition_PartitionRebindDeviceResponseTable;
[[maybe_unused]]
constexpr uint64_t kPartition_GetTypeGuid_Ordinal = 0x40d3186c00000000lu;
[[maybe_unused]]
constexpr uint64_t kPartition_GetTypeGuid_GenOrdinal = 0x111843d737a9b847lu;
extern "C" const fidl_type_t v1_fuchsia_hardware_block_partition_PartitionGetTypeGuidRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_block_partition_PartitionGetTypeGuidResponseTable;
[[maybe_unused]]
constexpr uint64_t kPartition_GetInstanceGuid_Ordinal = 0x69f426600000000lu;
[[maybe_unused]]
constexpr uint64_t kPartition_GetInstanceGuid_GenOrdinal = 0x14a5a573b275d435lu;
extern "C" const fidl_type_t v1_fuchsia_hardware_block_partition_PartitionGetInstanceGuidRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_block_partition_PartitionGetInstanceGuidResponseTable;
[[maybe_unused]]
constexpr uint64_t kPartition_GetName_Ordinal = 0x39b49c4000000000lu;
[[maybe_unused]]
constexpr uint64_t kPartition_GetName_GenOrdinal = 0x7e3c6f0b0937fc02lu;
extern "C" const fidl_type_t v1_fuchsia_hardware_block_partition_PartitionGetNameRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_block_partition_PartitionGetNameResponseTable;

}  // namespace
template <>
Partition::ResultOf::GetInfo_Impl<Partition::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(
      Partition::InPlace::GetInfo(std::move(_client_end), Super::response_buffer()));
}

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

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

template <>
Partition::UnownedResultOf::GetInfo_Impl<Partition::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(
      Partition::InPlace::GetInfo(std::move(_client_end), std::move(_response_buffer)));
}

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

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

::fidl::DecodeResult<Partition::GetInfoResponse> Partition::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));
  Partition::SetTransactionHeaderFor::GetInfoRequest(params);
  auto _encode_request_result = ::fidl::Encode(std::move(params));
  if (_encode_request_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Partition::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<Partition::GetInfoResponse>::FromFailure(
        std::move(_call_result));
  }
  return ::fidl::Decode(std::move(_call_result.message));
}

template <>
Partition::ResultOf::GetStats_Impl<Partition::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(
      Partition::InPlace::GetStats(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
}

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

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

template <>
Partition::UnownedResultOf::GetStats_Impl<Partition::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(
      Partition::InPlace::GetStats(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
}

Partition::UnownedResultOf::GetStats Partition::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));
}

Partition::UnownedResultOf::GetStats Partition::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<Partition::GetStatsResponse> Partition::InPlace::GetStats(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetStatsRequest> params, ::fidl::BytePart response_buffer) {
  Partition::SetTransactionHeaderFor::GetStatsRequest(params);
  auto _encode_request_result = ::fidl::Encode(std::move(params));
  if (_encode_request_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Partition::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<Partition::GetStatsResponse>::FromFailure(
        std::move(_call_result));
  }
  return ::fidl::Decode(std::move(_call_result.message));
}

template <>
Partition::ResultOf::GetFifo_Impl<Partition::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(
      Partition::InPlace::GetFifo(std::move(_client_end), Super::response_buffer()));
}

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

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

template <>
Partition::UnownedResultOf::GetFifo_Impl<Partition::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(
      Partition::InPlace::GetFifo(std::move(_client_end), std::move(_response_buffer)));
}

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

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

::fidl::DecodeResult<Partition::GetFifoResponse> Partition::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));
  Partition::SetTransactionHeaderFor::GetFifoRequest(params);
  auto _encode_request_result = ::fidl::Encode(std::move(params));
  if (_encode_request_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Partition::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<Partition::GetFifoResponse>::FromFailure(
        std::move(_call_result));
  }
  return ::fidl::Decode(std::move(_call_result.message));
}

template <>
Partition::ResultOf::AttachVmo_Impl<Partition::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(
      Partition::InPlace::AttachVmo(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
}

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

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

template <>
Partition::UnownedResultOf::AttachVmo_Impl<Partition::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(
      Partition::InPlace::AttachVmo(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
}

Partition::UnownedResultOf::AttachVmo Partition::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));
}

Partition::UnownedResultOf::AttachVmo Partition::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<Partition::AttachVmoResponse> Partition::InPlace::AttachVmo(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<AttachVmoRequest> params, ::fidl::BytePart response_buffer) {
  Partition::SetTransactionHeaderFor::AttachVmoRequest(params);
  auto _encode_request_result = ::fidl::Encode(std::move(params));
  if (_encode_request_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Partition::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<Partition::AttachVmoResponse>::FromFailure(
        std::move(_call_result));
  }
  return ::fidl::Decode(std::move(_call_result.message));
}

template <>
Partition::ResultOf::CloseFifo_Impl<Partition::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(
      Partition::InPlace::CloseFifo(std::move(_client_end), Super::response_buffer()));
}

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

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

template <>
Partition::UnownedResultOf::CloseFifo_Impl<Partition::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(
      Partition::InPlace::CloseFifo(std::move(_client_end), std::move(_response_buffer)));
}

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

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

::fidl::DecodeResult<Partition::CloseFifoResponse> Partition::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));
  Partition::SetTransactionHeaderFor::CloseFifoRequest(params);
  auto _encode_request_result = ::fidl::Encode(std::move(params));
  if (_encode_request_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Partition::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<Partition::CloseFifoResponse>::FromFailure(
        std::move(_call_result));
  }
  return ::fidl::Decode(std::move(_call_result.message));
}

template <>
Partition::ResultOf::RebindDevice_Impl<Partition::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(
      Partition::InPlace::RebindDevice(std::move(_client_end), Super::response_buffer()));
}

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

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

template <>
Partition::UnownedResultOf::RebindDevice_Impl<Partition::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(
      Partition::InPlace::RebindDevice(std::move(_client_end), std::move(_response_buffer)));
}

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

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

::fidl::DecodeResult<Partition::RebindDeviceResponse> Partition::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));
  Partition::SetTransactionHeaderFor::RebindDeviceRequest(params);
  auto _encode_request_result = ::fidl::Encode(std::move(params));
  if (_encode_request_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Partition::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<Partition::RebindDeviceResponse>::FromFailure(
        std::move(_call_result));
  }
  return ::fidl::Decode(std::move(_call_result.message));
}

template <>
Partition::ResultOf::GetTypeGuid_Impl<Partition::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(
      Partition::InPlace::GetTypeGuid(std::move(_client_end), Super::response_buffer()));
}

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

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

template <>
Partition::UnownedResultOf::GetTypeGuid_Impl<Partition::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(
      Partition::InPlace::GetTypeGuid(std::move(_client_end), std::move(_response_buffer)));
}

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

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

::fidl::DecodeResult<Partition::GetTypeGuidResponse> Partition::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));
  Partition::SetTransactionHeaderFor::GetTypeGuidRequest(params);
  auto _encode_request_result = ::fidl::Encode(std::move(params));
  if (_encode_request_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Partition::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<Partition::GetTypeGuidResponse>::FromFailure(
        std::move(_call_result));
  }
  return ::fidl::Decode(std::move(_call_result.message));
}

template <>
Partition::ResultOf::GetInstanceGuid_Impl<Partition::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(
      Partition::InPlace::GetInstanceGuid(std::move(_client_end), Super::response_buffer()));
}

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

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

template <>
Partition::UnownedResultOf::GetInstanceGuid_Impl<Partition::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(
      Partition::InPlace::GetInstanceGuid(std::move(_client_end), std::move(_response_buffer)));
}

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

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

::fidl::DecodeResult<Partition::GetInstanceGuidResponse> Partition::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));
  Partition::SetTransactionHeaderFor::GetInstanceGuidRequest(params);
  auto _encode_request_result = ::fidl::Encode(std::move(params));
  if (_encode_request_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Partition::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<Partition::GetInstanceGuidResponse>::FromFailure(
        std::move(_call_result));
  }
  return ::fidl::Decode(std::move(_call_result.message));
}

template <>
Partition::ResultOf::GetName_Impl<Partition::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(
      Partition::InPlace::GetName(std::move(_client_end), Super::response_buffer()));
}

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

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

template <>
Partition::UnownedResultOf::GetName_Impl<Partition::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(
      Partition::InPlace::GetName(std::move(_client_end), std::move(_response_buffer)));
}

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

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

::fidl::DecodeResult<Partition::GetNameResponse> Partition::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));
  Partition::SetTransactionHeaderFor::GetNameRequest(params);
  auto _encode_request_result = ::fidl::Encode(std::move(params));
  if (_encode_request_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Partition::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<Partition::GetNameResponse>::FromFailure(
        std::move(_call_result));
  }
  return ::fidl::Decode(std::move(_call_result.message));
}


bool Partition::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 kPartition_GetInfo_Ordinal:
    case kPartition_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 kPartition_GetStats_Ordinal:
    case kPartition_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 kPartition_GetFifo_Ordinal:
    case kPartition_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 kPartition_AttachVmo_Ordinal:
    case kPartition_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 kPartition_CloseFifo_Ordinal:
    case kPartition_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 kPartition_RebindDevice_Ordinal:
    case kPartition_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 kPartition_GetTypeGuid_Ordinal:
    case kPartition_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 kPartition_GetInstanceGuid_Ordinal:
    case kPartition_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 kPartition_GetName_Ordinal:
    case kPartition_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;
    }
    default: {
      return false;
    }
  }
}

bool Partition::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 Partition::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 = {};
  Partition::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 Partition::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 = {};
  Partition::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 Partition::Interface::GetInfoCompleterBase::Reply(::fidl::DecodedMessage<GetInfoResponse> params) {
  Partition::SetTransactionHeaderFor::GetInfoResponse(params);
  CompleterBase::SendReply(std::move(params));
}


void Partition::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 = {};
  Partition::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 Partition::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 = {};
  Partition::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 Partition::Interface::GetStatsCompleterBase::Reply(::fidl::DecodedMessage<GetStatsResponse> params) {
  Partition::SetTransactionHeaderFor::GetStatsResponse(params);
  CompleterBase::SendReply(std::move(params));
}


void Partition::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);
  Partition::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 Partition::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());
  Partition::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 Partition::Interface::GetFifoCompleterBase::Reply(::fidl::DecodedMessage<GetFifoResponse> params) {
  Partition::SetTransactionHeaderFor::GetFifoResponse(params);
  CompleterBase::SendReply(std::move(params));
}


void Partition::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 = {};
  Partition::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 Partition::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 = {};
  Partition::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 Partition::Interface::AttachVmoCompleterBase::Reply(::fidl::DecodedMessage<AttachVmoResponse> params) {
  Partition::SetTransactionHeaderFor::AttachVmoResponse(params);
  CompleterBase::SendReply(std::move(params));
}


void Partition::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);
  Partition::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 Partition::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());
  Partition::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 Partition::Interface::CloseFifoCompleterBase::Reply(::fidl::DecodedMessage<CloseFifoResponse> params) {
  Partition::SetTransactionHeaderFor::CloseFifoResponse(params);
  CompleterBase::SendReply(std::move(params));
}


void Partition::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);
  Partition::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 Partition::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());
  Partition::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 Partition::Interface::RebindDeviceCompleterBase::Reply(::fidl::DecodedMessage<RebindDeviceResponse> params) {
  Partition::SetTransactionHeaderFor::RebindDeviceResponse(params);
  CompleterBase::SendReply(std::move(params));
}


void Partition::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 = {};
  Partition::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 Partition::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 = {};
  Partition::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 Partition::Interface::GetTypeGuidCompleterBase::Reply(::fidl::DecodedMessage<GetTypeGuidResponse> params) {
  Partition::SetTransactionHeaderFor::GetTypeGuidResponse(params);
  CompleterBase::SendReply(std::move(params));
}


void Partition::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 = {};
  Partition::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 Partition::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 = {};
  Partition::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 Partition::Interface::GetInstanceGuidCompleterBase::Reply(::fidl::DecodedMessage<GetInstanceGuidResponse> params) {
  Partition::SetTransactionHeaderFor::GetInstanceGuidResponse(params);
  CompleterBase::SendReply(std::move(params));
}


void Partition::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 = {};
  Partition::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 Partition::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 = {};
  Partition::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 Partition::Interface::GetNameCompleterBase::Reply(::fidl::DecodedMessage<GetNameResponse> params) {
  Partition::SetTransactionHeaderFor::GetNameResponse(params);
  CompleterBase::SendReply(std::move(params));
}



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

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

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

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

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

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

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

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

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

}  // namespace partition
}  // namespace block
}  // namespace hardware
}  // namespace fuchsia
}  // namespace llcpp