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

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

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

namespace llcpp {

namespace fuchsia {
namespace hardware {
namespace backlight {

void ::llcpp::fuchsia::hardware::backlight::Device_GetStateNormalized_Result::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(Device_GetStateNormalized_Result) == sizeof(fidl_xunion_t));
  static_assert(offsetof(Device_GetStateNormalized_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
  static_assert(offsetof(Device_GetStateNormalized_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
}

void ::llcpp::fuchsia::hardware::backlight::Device_GetStateAbsolute_Result::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(Device_GetStateAbsolute_Result) == sizeof(fidl_xunion_t));
  static_assert(offsetof(Device_GetStateAbsolute_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
  static_assert(offsetof(Device_GetStateAbsolute_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
}

void ::llcpp::fuchsia::hardware::backlight::Device_SetStateNormalized_Result::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(Device_SetStateNormalized_Result) == sizeof(fidl_xunion_t));
  static_assert(offsetof(Device_SetStateNormalized_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
  static_assert(offsetof(Device_SetStateNormalized_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
}

void ::llcpp::fuchsia::hardware::backlight::Device_SetStateAbsolute_Result::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(Device_SetStateAbsolute_Result) == sizeof(fidl_xunion_t));
  static_assert(offsetof(Device_SetStateAbsolute_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
  static_assert(offsetof(Device_SetStateAbsolute_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
}

void ::llcpp::fuchsia::hardware::backlight::Device_GetMaxAbsoluteBrightness_Result::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(Device_GetMaxAbsoluteBrightness_Result) == sizeof(fidl_xunion_t));
  static_assert(offsetof(Device_GetMaxAbsoluteBrightness_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
  static_assert(offsetof(Device_GetMaxAbsoluteBrightness_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
}

namespace {

[[maybe_unused]]
constexpr uint64_t kDevice_GetStateNormalized_Ordinal = 0x44ba72a000000000lu;
[[maybe_unused]]
constexpr uint64_t kDevice_GetStateNormalized_GenOrdinal = 0x2506201b5999b9b7lu;
extern "C" const fidl_type_t v1_fuchsia_hardware_backlight_DeviceGetStateNormalizedRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_backlight_DeviceGetStateNormalizedResponseTable;
[[maybe_unused]]
constexpr uint64_t kDevice_SetStateNormalized_Ordinal = 0xc19adb00000000lu;
[[maybe_unused]]
constexpr uint64_t kDevice_SetStateNormalized_GenOrdinal = 0x554ac5cb4f9f5b62lu;
extern "C" const fidl_type_t v1_fuchsia_hardware_backlight_DeviceSetStateNormalizedRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_backlight_DeviceSetStateNormalizedResponseTable;
[[maybe_unused]]
constexpr uint64_t kDevice_GetStateAbsolute_Ordinal = 0x971592f00000000lu;
[[maybe_unused]]
constexpr uint64_t kDevice_GetStateAbsolute_GenOrdinal = 0x1f8ccf01cf526a2blu;
extern "C" const fidl_type_t v1_fuchsia_hardware_backlight_DeviceGetStateAbsoluteRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_backlight_DeviceGetStateAbsoluteResponseTable;
[[maybe_unused]]
constexpr uint64_t kDevice_SetStateAbsolute_Ordinal = 0x697f353e00000000lu;
[[maybe_unused]]
constexpr uint64_t kDevice_SetStateAbsolute_GenOrdinal = 0x19c100c43faaa178lu;
extern "C" const fidl_type_t v1_fuchsia_hardware_backlight_DeviceSetStateAbsoluteRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_backlight_DeviceSetStateAbsoluteResponseTable;
[[maybe_unused]]
constexpr uint64_t kDevice_GetMaxAbsoluteBrightness_Ordinal = 0x65fe16500000000lu;
[[maybe_unused]]
constexpr uint64_t kDevice_GetMaxAbsoluteBrightness_GenOrdinal = 0x2aa0699313d4160dlu;
extern "C" const fidl_type_t v1_fuchsia_hardware_backlight_DeviceGetMaxAbsoluteBrightnessRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_backlight_DeviceGetMaxAbsoluteBrightnessResponseTable;

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

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

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

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

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

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

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

template <>
Device::ResultOf::SetStateNormalized_Impl<Device::SetStateNormalizedResponse>::SetStateNormalized_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::backlight::State state) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetStateNormalizedRequest, ::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, SetStateNormalizedRequest::PrimarySize);
  auto& _request = *reinterpret_cast<SetStateNormalizedRequest*>(_write_bytes);
  _request.state = std::move(state);
  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetStateNormalizedRequest));
  ::fidl::DecodedMessage<SetStateNormalizedRequest> _decoded_request(std::move(_request_bytes));
  Super::SetResult(
      Device::InPlace::SetStateNormalized(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
}

Device::ResultOf::SetStateNormalized Device::SyncClient::SetStateNormalized(::llcpp::fuchsia::hardware::backlight::State state) {
    return ResultOf::SetStateNormalized(::zx::unowned_channel(this->channel_), std::move(state));
}

Device::ResultOf::SetStateNormalized Device::Call::SetStateNormalized(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::backlight::State state) {
  return ResultOf::SetStateNormalized(std::move(_client_end), std::move(state));
}

template <>
Device::UnownedResultOf::SetStateNormalized_Impl<Device::SetStateNormalizedResponse>::SetStateNormalized_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::backlight::State state, ::fidl::BytePart _response_buffer) {
  if (_request_buffer.capacity() < SetStateNormalizedRequest::PrimarySize) {
    Super::SetFailure(::fidl::DecodeResult<SetStateNormalizedResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
    return;
  }
  memset(_request_buffer.data(), 0, SetStateNormalizedRequest::PrimarySize);
  auto& _request = *reinterpret_cast<SetStateNormalizedRequest*>(_request_buffer.data());
  _request.state = std::move(state);
  _request_buffer.set_actual(sizeof(SetStateNormalizedRequest));
  ::fidl::DecodedMessage<SetStateNormalizedRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      Device::InPlace::SetStateNormalized(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
}

Device::UnownedResultOf::SetStateNormalized Device::SyncClient::SetStateNormalized(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::backlight::State state, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::SetStateNormalized(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(state), std::move(_response_buffer));
}

Device::UnownedResultOf::SetStateNormalized Device::Call::SetStateNormalized(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::backlight::State state, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::SetStateNormalized(std::move(_client_end), std::move(_request_buffer), std::move(state), std::move(_response_buffer));
}

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

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

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

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

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

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

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

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

template <>
Device::ResultOf::SetStateAbsolute_Impl<Device::SetStateAbsoluteResponse>::SetStateAbsolute_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::backlight::State state) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetStateAbsoluteRequest, ::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, SetStateAbsoluteRequest::PrimarySize);
  auto& _request = *reinterpret_cast<SetStateAbsoluteRequest*>(_write_bytes);
  _request.state = std::move(state);
  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetStateAbsoluteRequest));
  ::fidl::DecodedMessage<SetStateAbsoluteRequest> _decoded_request(std::move(_request_bytes));
  Super::SetResult(
      Device::InPlace::SetStateAbsolute(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
}

Device::ResultOf::SetStateAbsolute Device::SyncClient::SetStateAbsolute(::llcpp::fuchsia::hardware::backlight::State state) {
    return ResultOf::SetStateAbsolute(::zx::unowned_channel(this->channel_), std::move(state));
}

Device::ResultOf::SetStateAbsolute Device::Call::SetStateAbsolute(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::backlight::State state) {
  return ResultOf::SetStateAbsolute(std::move(_client_end), std::move(state));
}

template <>
Device::UnownedResultOf::SetStateAbsolute_Impl<Device::SetStateAbsoluteResponse>::SetStateAbsolute_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::backlight::State state, ::fidl::BytePart _response_buffer) {
  if (_request_buffer.capacity() < SetStateAbsoluteRequest::PrimarySize) {
    Super::SetFailure(::fidl::DecodeResult<SetStateAbsoluteResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
    return;
  }
  memset(_request_buffer.data(), 0, SetStateAbsoluteRequest::PrimarySize);
  auto& _request = *reinterpret_cast<SetStateAbsoluteRequest*>(_request_buffer.data());
  _request.state = std::move(state);
  _request_buffer.set_actual(sizeof(SetStateAbsoluteRequest));
  ::fidl::DecodedMessage<SetStateAbsoluteRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      Device::InPlace::SetStateAbsolute(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
}

Device::UnownedResultOf::SetStateAbsolute Device::SyncClient::SetStateAbsolute(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::backlight::State state, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::SetStateAbsolute(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(state), std::move(_response_buffer));
}

Device::UnownedResultOf::SetStateAbsolute Device::Call::SetStateAbsolute(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::backlight::State state, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::SetStateAbsolute(std::move(_client_end), std::move(_request_buffer), std::move(state), std::move(_response_buffer));
}

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

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

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

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

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

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

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

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


bool Device::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
  if (msg->num_bytes < sizeof(fidl_message_header_t)) {
    zx_handle_close_many(msg->handles, msg->num_handles);
    txn->Close(ZX_ERR_INVALID_ARGS);
    return true;
  }
  fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
  zx_status_t status = fidl_validate_txn_header(hdr);
  if (status != ZX_OK) {
    txn->Close(status);
    return true;
  }
  switch (hdr->ordinal) {
    case kDevice_GetStateNormalized_Ordinal:
    case kDevice_GetStateNormalized_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<GetStateNormalizedRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      impl->GetStateNormalized(
          Interface::GetStateNormalizedCompleter::Sync(txn));
      return true;
    }
    case kDevice_SetStateNormalized_Ordinal:
    case kDevice_SetStateNormalized_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<SetStateNormalizedRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->SetStateNormalized(std::move(message->state),
          Interface::SetStateNormalizedCompleter::Sync(txn));
      return true;
    }
    case kDevice_GetStateAbsolute_Ordinal:
    case kDevice_GetStateAbsolute_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<GetStateAbsoluteRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      impl->GetStateAbsolute(
          Interface::GetStateAbsoluteCompleter::Sync(txn));
      return true;
    }
    case kDevice_SetStateAbsolute_Ordinal:
    case kDevice_SetStateAbsolute_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<SetStateAbsoluteRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->SetStateAbsolute(std::move(message->state),
          Interface::SetStateAbsoluteCompleter::Sync(txn));
      return true;
    }
    case kDevice_GetMaxAbsoluteBrightness_Ordinal:
    case kDevice_GetMaxAbsoluteBrightness_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<GetMaxAbsoluteBrightnessRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      impl->GetMaxAbsoluteBrightness(
          Interface::GetMaxAbsoluteBrightnessCompleter::Sync(txn));
      return true;
    }
    default: {
      return false;
    }
  }
}

bool Device::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
  bool found = TryDispatch(impl, msg, txn);
  if (!found) {
    zx_handle_close_many(msg->handles, msg->num_handles);
    txn->Close(ZX_ERR_NOT_SUPPORTED);
  }
  return found;
}


void Device::Interface::GetStateNormalizedCompleterBase::Reply(::llcpp::fuchsia::hardware::backlight::Device_GetStateNormalized_Result result) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetStateNormalizedResponse, ::fidl::MessageDirection::kSending>();
  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
  GetStateNormalizedResponse _response = {};
  Device::SetTransactionHeaderFor::GetStateNormalizedResponse(
      ::fidl::DecodedMessage<GetStateNormalizedResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              GetStateNormalizedResponse::PrimarySize,
              GetStateNormalizedResponse::PrimarySize)));
  _response.result = std::move(result);
  auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
                                                                          _kWriteAllocSize));
  if (_linearize_result.status != ZX_OK) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  CompleterBase::SendReply(std::move(_linearize_result.message));
}
void Device::Interface::GetStateNormalizedCompleterBase::ReplySuccess(::llcpp::fuchsia::hardware::backlight::State state) {
  Device_GetStateNormalized_Response response;
  response.state = std::move(state);

  Reply(Device_GetStateNormalized_Result::WithResponse(&response));
}
void Device::Interface::GetStateNormalizedCompleterBase::ReplyError(int32_t error) {
  Reply(Device_GetStateNormalized_Result::WithErr(&error));
}

void Device::Interface::GetStateNormalizedCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::backlight::Device_GetStateNormalized_Result result) {
  if (_buffer.capacity() < GetStateNormalizedResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  GetStateNormalizedResponse _response = {};
  Device::SetTransactionHeaderFor::GetStateNormalizedResponse(
      ::fidl::DecodedMessage<GetStateNormalizedResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              GetStateNormalizedResponse::PrimarySize,
              GetStateNormalizedResponse::PrimarySize)));
  _response.result = std::move(result);
  auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
  if (_linearize_result.status != ZX_OK) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  CompleterBase::SendReply(std::move(_linearize_result.message));
}
void Device::Interface::GetStateNormalizedCompleterBase::ReplySuccess(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::backlight::State state) {
  Device_GetStateNormalized_Response response;
  response.state = std::move(state);

  Reply(std::move(_buffer), Device_GetStateNormalized_Result::WithResponse(&response));
}

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


void Device::Interface::SetStateNormalizedCompleterBase::Reply(::llcpp::fuchsia::hardware::backlight::Device_SetStateNormalized_Result result) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetStateNormalizedResponse, ::fidl::MessageDirection::kSending>();
  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
  SetStateNormalizedResponse _response = {};
  Device::SetTransactionHeaderFor::SetStateNormalizedResponse(
      ::fidl::DecodedMessage<SetStateNormalizedResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              SetStateNormalizedResponse::PrimarySize,
              SetStateNormalizedResponse::PrimarySize)));
  _response.result = std::move(result);
  auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
                                                                          _kWriteAllocSize));
  if (_linearize_result.status != ZX_OK) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  CompleterBase::SendReply(std::move(_linearize_result.message));
}
void Device::Interface::SetStateNormalizedCompleterBase::ReplySuccess() {
  Device_SetStateNormalized_Response response;

  Reply(Device_SetStateNormalized_Result::WithResponse(&response));
}
void Device::Interface::SetStateNormalizedCompleterBase::ReplyError(int32_t error) {
  Reply(Device_SetStateNormalized_Result::WithErr(&error));
}

void Device::Interface::SetStateNormalizedCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::backlight::Device_SetStateNormalized_Result result) {
  if (_buffer.capacity() < SetStateNormalizedResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  SetStateNormalizedResponse _response = {};
  Device::SetTransactionHeaderFor::SetStateNormalizedResponse(
      ::fidl::DecodedMessage<SetStateNormalizedResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              SetStateNormalizedResponse::PrimarySize,
              SetStateNormalizedResponse::PrimarySize)));
  _response.result = std::move(result);
  auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
  if (_linearize_result.status != ZX_OK) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  CompleterBase::SendReply(std::move(_linearize_result.message));
}
void Device::Interface::SetStateNormalizedCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
  Device_SetStateNormalized_Response response;

  Reply(std::move(_buffer), Device_SetStateNormalized_Result::WithResponse(&response));
}

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


void Device::Interface::GetStateAbsoluteCompleterBase::Reply(::llcpp::fuchsia::hardware::backlight::Device_GetStateAbsolute_Result result) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetStateAbsoluteResponse, ::fidl::MessageDirection::kSending>();
  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
  GetStateAbsoluteResponse _response = {};
  Device::SetTransactionHeaderFor::GetStateAbsoluteResponse(
      ::fidl::DecodedMessage<GetStateAbsoluteResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              GetStateAbsoluteResponse::PrimarySize,
              GetStateAbsoluteResponse::PrimarySize)));
  _response.result = std::move(result);
  auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
                                                                          _kWriteAllocSize));
  if (_linearize_result.status != ZX_OK) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  CompleterBase::SendReply(std::move(_linearize_result.message));
}
void Device::Interface::GetStateAbsoluteCompleterBase::ReplySuccess(::llcpp::fuchsia::hardware::backlight::State state) {
  Device_GetStateAbsolute_Response response;
  response.state = std::move(state);

  Reply(Device_GetStateAbsolute_Result::WithResponse(&response));
}
void Device::Interface::GetStateAbsoluteCompleterBase::ReplyError(int32_t error) {
  Reply(Device_GetStateAbsolute_Result::WithErr(&error));
}

void Device::Interface::GetStateAbsoluteCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::backlight::Device_GetStateAbsolute_Result result) {
  if (_buffer.capacity() < GetStateAbsoluteResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  GetStateAbsoluteResponse _response = {};
  Device::SetTransactionHeaderFor::GetStateAbsoluteResponse(
      ::fidl::DecodedMessage<GetStateAbsoluteResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              GetStateAbsoluteResponse::PrimarySize,
              GetStateAbsoluteResponse::PrimarySize)));
  _response.result = std::move(result);
  auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
  if (_linearize_result.status != ZX_OK) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  CompleterBase::SendReply(std::move(_linearize_result.message));
}
void Device::Interface::GetStateAbsoluteCompleterBase::ReplySuccess(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::backlight::State state) {
  Device_GetStateAbsolute_Response response;
  response.state = std::move(state);

  Reply(std::move(_buffer), Device_GetStateAbsolute_Result::WithResponse(&response));
}

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


void Device::Interface::SetStateAbsoluteCompleterBase::Reply(::llcpp::fuchsia::hardware::backlight::Device_SetStateAbsolute_Result result) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetStateAbsoluteResponse, ::fidl::MessageDirection::kSending>();
  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
  SetStateAbsoluteResponse _response = {};
  Device::SetTransactionHeaderFor::SetStateAbsoluteResponse(
      ::fidl::DecodedMessage<SetStateAbsoluteResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              SetStateAbsoluteResponse::PrimarySize,
              SetStateAbsoluteResponse::PrimarySize)));
  _response.result = std::move(result);
  auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
                                                                          _kWriteAllocSize));
  if (_linearize_result.status != ZX_OK) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  CompleterBase::SendReply(std::move(_linearize_result.message));
}
void Device::Interface::SetStateAbsoluteCompleterBase::ReplySuccess() {
  Device_SetStateAbsolute_Response response;

  Reply(Device_SetStateAbsolute_Result::WithResponse(&response));
}
void Device::Interface::SetStateAbsoluteCompleterBase::ReplyError(int32_t error) {
  Reply(Device_SetStateAbsolute_Result::WithErr(&error));
}

void Device::Interface::SetStateAbsoluteCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::backlight::Device_SetStateAbsolute_Result result) {
  if (_buffer.capacity() < SetStateAbsoluteResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  SetStateAbsoluteResponse _response = {};
  Device::SetTransactionHeaderFor::SetStateAbsoluteResponse(
      ::fidl::DecodedMessage<SetStateAbsoluteResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              SetStateAbsoluteResponse::PrimarySize,
              SetStateAbsoluteResponse::PrimarySize)));
  _response.result = std::move(result);
  auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
  if (_linearize_result.status != ZX_OK) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  CompleterBase::SendReply(std::move(_linearize_result.message));
}
void Device::Interface::SetStateAbsoluteCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
  Device_SetStateAbsolute_Response response;

  Reply(std::move(_buffer), Device_SetStateAbsolute_Result::WithResponse(&response));
}

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


void Device::Interface::GetMaxAbsoluteBrightnessCompleterBase::Reply(::llcpp::fuchsia::hardware::backlight::Device_GetMaxAbsoluteBrightness_Result result) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetMaxAbsoluteBrightnessResponse, ::fidl::MessageDirection::kSending>();
  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
  GetMaxAbsoluteBrightnessResponse _response = {};
  Device::SetTransactionHeaderFor::GetMaxAbsoluteBrightnessResponse(
      ::fidl::DecodedMessage<GetMaxAbsoluteBrightnessResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              GetMaxAbsoluteBrightnessResponse::PrimarySize,
              GetMaxAbsoluteBrightnessResponse::PrimarySize)));
  _response.result = std::move(result);
  auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
                                                                          _kWriteAllocSize));
  if (_linearize_result.status != ZX_OK) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  CompleterBase::SendReply(std::move(_linearize_result.message));
}
void Device::Interface::GetMaxAbsoluteBrightnessCompleterBase::ReplySuccess(double max_brightness) {
  Device_GetMaxAbsoluteBrightness_Response response;
  response.max_brightness = std::move(max_brightness);

  Reply(Device_GetMaxAbsoluteBrightness_Result::WithResponse(&response));
}
void Device::Interface::GetMaxAbsoluteBrightnessCompleterBase::ReplyError(int32_t error) {
  Reply(Device_GetMaxAbsoluteBrightness_Result::WithErr(&error));
}

void Device::Interface::GetMaxAbsoluteBrightnessCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::backlight::Device_GetMaxAbsoluteBrightness_Result result) {
  if (_buffer.capacity() < GetMaxAbsoluteBrightnessResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  GetMaxAbsoluteBrightnessResponse _response = {};
  Device::SetTransactionHeaderFor::GetMaxAbsoluteBrightnessResponse(
      ::fidl::DecodedMessage<GetMaxAbsoluteBrightnessResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              GetMaxAbsoluteBrightnessResponse::PrimarySize,
              GetMaxAbsoluteBrightnessResponse::PrimarySize)));
  _response.result = std::move(result);
  auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
  if (_linearize_result.status != ZX_OK) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  CompleterBase::SendReply(std::move(_linearize_result.message));
}
void Device::Interface::GetMaxAbsoluteBrightnessCompleterBase::ReplySuccess(::fidl::BytePart _buffer, double max_brightness) {
  Device_GetMaxAbsoluteBrightness_Response response;
  response.max_brightness = std::move(max_brightness);

  Reply(std::move(_buffer), Device_GetMaxAbsoluteBrightness_Result::WithResponse(&response));
}

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



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

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

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

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

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

}  // namespace backlight
}  // namespace hardware
}  // namespace fuchsia
}  // namespace llcpp