zircon/system/fidl/fuchsia-device/gen/llcpp/include/fuchsia/device/llcpp/fidl.h

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

#pragma once

#include <lib/fidl/internal.h>
#include <lib/fidl/txn_header.h>
#include <lib/fidl/llcpp/array.h>
#include <lib/fidl/llcpp/coding.h>
#include <lib/fidl/llcpp/connect_service.h>
#include <lib/fidl/llcpp/service_handler_interface.h>
#include <lib/fidl/llcpp/string_view.h>
#include <lib/fidl/llcpp/sync_call.h>
#include <lib/fidl/llcpp/traits.h>
#include <lib/fidl/llcpp/transaction.h>
#include <lib/fidl/llcpp/vector_view.h>
#include <lib/fit/function.h>
#include <lib/zx/channel.h>
#include <lib/zx/event.h>
#include <zircon/fidl.h>

#include <fuchsia/device/manager/llcpp/fidl.h>

namespace llcpp {

namespace fuchsia {
namespace device {

struct NameProvider_GetDeviceName_Response;
struct NameProvider_GetDeviceName_Result;
class NameProvider;
enum class DevicePowerState : uint8_t {
  DEVICE_POWER_STATE_D0 = 0u,
  DEVICE_POWER_STATE_D1 = 1u,
  DEVICE_POWER_STATE_D2 = 2u,
  DEVICE_POWER_STATE_D3HOT = 3u,
  DEVICE_POWER_STATE_D3COLD = 4u,
};


struct SystemPowerStateInfo;
struct Controller_GetPowerStateMapping_Response;
struct Controller_GetPowerStateMapping_Result;
struct DevicePowerStateInfo;
struct Controller_GetDevicePowerCaps_Response;
struct Controller_GetDevicePowerCaps_Result;
struct Controller_Resume_Response;
struct Controller_Resume_Result;
struct DevicePerformanceStateInfo;
struct Controller_UpdatePowerStateMapping_Response;
struct Controller_UpdatePowerStateMapping_Result;
struct Controller_ScheduleUnbind_Response;
struct Controller_ScheduleUnbind_Result;
struct Controller_Rebind_Response;
struct Controller_Rebind_Result;
struct Controller_GetTopologicalPath_Response;
struct Controller_GetTopologicalPath_Result;
struct Controller_Bind_Response;
struct Controller_Bind_Result;
class Controller;

extern "C" const fidl_type_t v1_fuchsia_device_NameProvider_GetDeviceName_ResultTable;

struct NameProvider_GetDeviceName_Result {
  NameProvider_GetDeviceName_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}

  enum class Tag : fidl_xunion_tag_t {
    kResponse = 1,  // 0x1
    kErr = 2,  // 0x2
  };

  bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }

  bool is_response() const { return ordinal() == Ordinal::kResponse; }

  static NameProvider_GetDeviceName_Result WithResponse(::llcpp::fuchsia::device::NameProvider_GetDeviceName_Response* val) {
    NameProvider_GetDeviceName_Result result;
    result.set_response(val);
    return result;
  }

  void set_response(::llcpp::fuchsia::device::NameProvider_GetDeviceName_Response* elem) {
    ordinal_ = Ordinal::kResponse;
    envelope_.data = static_cast<void*>(elem);
  }

  ::llcpp::fuchsia::device::NameProvider_GetDeviceName_Response& mutable_response() {
    ZX_ASSERT(ordinal() == Ordinal::kResponse);
    return *static_cast<::llcpp::fuchsia::device::NameProvider_GetDeviceName_Response*>(envelope_.data);
  }
  const ::llcpp::fuchsia::device::NameProvider_GetDeviceName_Response& response() const {
    ZX_ASSERT(ordinal() == Ordinal::kResponse);
    return *static_cast<::llcpp::fuchsia::device::NameProvider_GetDeviceName_Response*>(envelope_.data);
  }

  bool is_err() const { return ordinal() == Ordinal::kErr; }

  static NameProvider_GetDeviceName_Result WithErr(int32_t* val) {
    NameProvider_GetDeviceName_Result result;
    result.set_err(val);
    return result;
  }

  void set_err(int32_t* elem) {
    ordinal_ = Ordinal::kErr;
    envelope_.data = static_cast<void*>(elem);
  }

  int32_t& mutable_err() {
    ZX_ASSERT(ordinal() == Ordinal::kErr);
    return *static_cast<int32_t*>(envelope_.data);
  }
  const int32_t& err() const {
    ZX_ASSERT(ordinal() == Ordinal::kErr);
    return *static_cast<int32_t*>(envelope_.data);
  }
  Tag which() const {
    ZX_ASSERT(!has_invalid_tag());
    return static_cast<Tag>(ordinal());
  }

  static constexpr const fidl_type_t* Type = &v1_fuchsia_device_NameProvider_GetDeviceName_ResultTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 24;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 272;
  static constexpr bool HasPointer = true;

 private:
  enum class Ordinal : fidl_xunion_tag_t {
    Invalid = 0,
    kResponse = 1,  // 0x1
    kErr = 2,  // 0x2
  };

  Ordinal ordinal() const {
    return ordinal_;
  }

  static void SizeAndOffsetAssertionHelper();
  Ordinal ordinal_;
  FIDL_ALIGNDECL
  fidl_envelope_t envelope_;
};

extern "C" const fidl_type_t v1_fuchsia_device_Controller_GetPowerStateMapping_ResultTable;

struct Controller_GetPowerStateMapping_Result {
  Controller_GetPowerStateMapping_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}

  enum class Tag : fidl_xunion_tag_t {
    kResponse = 1,  // 0x1
    kErr = 2,  // 0x2
  };

  bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }

  bool is_response() const { return ordinal() == Ordinal::kResponse; }

  static Controller_GetPowerStateMapping_Result WithResponse(::llcpp::fuchsia::device::Controller_GetPowerStateMapping_Response* val) {
    Controller_GetPowerStateMapping_Result result;
    result.set_response(val);
    return result;
  }

  void set_response(::llcpp::fuchsia::device::Controller_GetPowerStateMapping_Response* elem) {
    ordinal_ = Ordinal::kResponse;
    envelope_.data = static_cast<void*>(elem);
  }

  ::llcpp::fuchsia::device::Controller_GetPowerStateMapping_Response& mutable_response() {
    ZX_ASSERT(ordinal() == Ordinal::kResponse);
    return *static_cast<::llcpp::fuchsia::device::Controller_GetPowerStateMapping_Response*>(envelope_.data);
  }
  const ::llcpp::fuchsia::device::Controller_GetPowerStateMapping_Response& response() const {
    ZX_ASSERT(ordinal() == Ordinal::kResponse);
    return *static_cast<::llcpp::fuchsia::device::Controller_GetPowerStateMapping_Response*>(envelope_.data);
  }

  bool is_err() const { return ordinal() == Ordinal::kErr; }

  static Controller_GetPowerStateMapping_Result WithErr(int32_t* val) {
    Controller_GetPowerStateMapping_Result result;
    result.set_err(val);
    return result;
  }

  void set_err(int32_t* elem) {
    ordinal_ = Ordinal::kErr;
    envelope_.data = static_cast<void*>(elem);
  }

  int32_t& mutable_err() {
    ZX_ASSERT(ordinal() == Ordinal::kErr);
    return *static_cast<int32_t*>(envelope_.data);
  }
  const int32_t& err() const {
    ZX_ASSERT(ordinal() == Ordinal::kErr);
    return *static_cast<int32_t*>(envelope_.data);
  }
  Tag which() const {
    ZX_ASSERT(!has_invalid_tag());
    return static_cast<Tag>(ordinal());
  }

  static constexpr const fidl_type_t* Type = &v1_fuchsia_device_Controller_GetPowerStateMapping_ResultTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 24;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 56;
  static constexpr bool HasPointer = true;

 private:
  enum class Ordinal : fidl_xunion_tag_t {
    Invalid = 0,
    kResponse = 1,  // 0x1
    kErr = 2,  // 0x2
  };

  Ordinal ordinal() const {
    return ordinal_;
  }

  static void SizeAndOffsetAssertionHelper();
  Ordinal ordinal_;
  FIDL_ALIGNDECL
  fidl_envelope_t envelope_;
};

extern "C" const fidl_type_t v1_fuchsia_device_Controller_GetDevicePowerCaps_ResultTable;

struct Controller_GetDevicePowerCaps_Result {
  Controller_GetDevicePowerCaps_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}

  enum class Tag : fidl_xunion_tag_t {
    kResponse = 1,  // 0x1
    kErr = 2,  // 0x2
  };

  bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }

  bool is_response() const { return ordinal() == Ordinal::kResponse; }

  static Controller_GetDevicePowerCaps_Result WithResponse(::llcpp::fuchsia::device::Controller_GetDevicePowerCaps_Response* val) {
    Controller_GetDevicePowerCaps_Result result;
    result.set_response(val);
    return result;
  }

  void set_response(::llcpp::fuchsia::device::Controller_GetDevicePowerCaps_Response* elem) {
    ordinal_ = Ordinal::kResponse;
    envelope_.data = static_cast<void*>(elem);
  }

  ::llcpp::fuchsia::device::Controller_GetDevicePowerCaps_Response& mutable_response() {
    ZX_ASSERT(ordinal() == Ordinal::kResponse);
    return *static_cast<::llcpp::fuchsia::device::Controller_GetDevicePowerCaps_Response*>(envelope_.data);
  }
  const ::llcpp::fuchsia::device::Controller_GetDevicePowerCaps_Response& response() const {
    ZX_ASSERT(ordinal() == Ordinal::kResponse);
    return *static_cast<::llcpp::fuchsia::device::Controller_GetDevicePowerCaps_Response*>(envelope_.data);
  }

  bool is_err() const { return ordinal() == Ordinal::kErr; }

  static Controller_GetDevicePowerCaps_Result WithErr(int32_t* val) {
    Controller_GetDevicePowerCaps_Result result;
    result.set_err(val);
    return result;
  }

  void set_err(int32_t* elem) {
    ordinal_ = Ordinal::kErr;
    envelope_.data = static_cast<void*>(elem);
  }

  int32_t& mutable_err() {
    ZX_ASSERT(ordinal() == Ordinal::kErr);
    return *static_cast<int32_t*>(envelope_.data);
  }
  const int32_t& err() const {
    ZX_ASSERT(ordinal() == Ordinal::kErr);
    return *static_cast<int32_t*>(envelope_.data);
  }
  Tag which() const {
    ZX_ASSERT(!has_invalid_tag());
    return static_cast<Tag>(ordinal());
  }

  static constexpr const fidl_type_t* Type = &v1_fuchsia_device_Controller_GetDevicePowerCaps_ResultTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 24;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 120;
  static constexpr bool HasPointer = true;

 private:
  enum class Ordinal : fidl_xunion_tag_t {
    Invalid = 0,
    kResponse = 1,  // 0x1
    kErr = 2,  // 0x2
  };

  Ordinal ordinal() const {
    return ordinal_;
  }

  static void SizeAndOffsetAssertionHelper();
  Ordinal ordinal_;
  FIDL_ALIGNDECL
  fidl_envelope_t envelope_;
};

extern "C" const fidl_type_t v1_fuchsia_device_Controller_Resume_ResultTable;

struct Controller_Resume_Result {
  Controller_Resume_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}

  enum class Tag : fidl_xunion_tag_t {
    kResponse = 1,  // 0x1
    kErr = 2,  // 0x2
  };

  bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }

  bool is_response() const { return ordinal() == Ordinal::kResponse; }

  static Controller_Resume_Result WithResponse(::llcpp::fuchsia::device::Controller_Resume_Response* val) {
    Controller_Resume_Result result;
    result.set_response(val);
    return result;
  }

  void set_response(::llcpp::fuchsia::device::Controller_Resume_Response* elem) {
    ordinal_ = Ordinal::kResponse;
    envelope_.data = static_cast<void*>(elem);
  }

  ::llcpp::fuchsia::device::Controller_Resume_Response& mutable_response() {
    ZX_ASSERT(ordinal() == Ordinal::kResponse);
    return *static_cast<::llcpp::fuchsia::device::Controller_Resume_Response*>(envelope_.data);
  }
  const ::llcpp::fuchsia::device::Controller_Resume_Response& response() const {
    ZX_ASSERT(ordinal() == Ordinal::kResponse);
    return *static_cast<::llcpp::fuchsia::device::Controller_Resume_Response*>(envelope_.data);
  }

  bool is_err() const { return ordinal() == Ordinal::kErr; }

  static Controller_Resume_Result WithErr(int32_t* val) {
    Controller_Resume_Result result;
    result.set_err(val);
    return result;
  }

  void set_err(int32_t* elem) {
    ordinal_ = Ordinal::kErr;
    envelope_.data = static_cast<void*>(elem);
  }

  int32_t& mutable_err() {
    ZX_ASSERT(ordinal() == Ordinal::kErr);
    return *static_cast<int32_t*>(envelope_.data);
  }
  const int32_t& err() const {
    ZX_ASSERT(ordinal() == Ordinal::kErr);
    return *static_cast<int32_t*>(envelope_.data);
  }
  Tag which() const {
    ZX_ASSERT(!has_invalid_tag());
    return static_cast<Tag>(ordinal());
  }

  static constexpr const fidl_type_t* Type = &v1_fuchsia_device_Controller_Resume_ResultTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 24;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 8;
  static constexpr bool HasPointer = true;

 private:
  enum class Ordinal : fidl_xunion_tag_t {
    Invalid = 0,
    kResponse = 1,  // 0x1
    kErr = 2,  // 0x2
  };

  Ordinal ordinal() const {
    return ordinal_;
  }

  static void SizeAndOffsetAssertionHelper();
  Ordinal ordinal_;
  FIDL_ALIGNDECL
  fidl_envelope_t envelope_;
};

extern "C" const fidl_type_t v1_fuchsia_device_Controller_UpdatePowerStateMapping_ResultTable;

struct Controller_UpdatePowerStateMapping_Result {
  Controller_UpdatePowerStateMapping_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}

  enum class Tag : fidl_xunion_tag_t {
    kResponse = 1,  // 0x1
    kErr = 2,  // 0x2
  };

  bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }

  bool is_response() const { return ordinal() == Ordinal::kResponse; }

  static Controller_UpdatePowerStateMapping_Result WithResponse(::llcpp::fuchsia::device::Controller_UpdatePowerStateMapping_Response* val) {
    Controller_UpdatePowerStateMapping_Result result;
    result.set_response(val);
    return result;
  }

  void set_response(::llcpp::fuchsia::device::Controller_UpdatePowerStateMapping_Response* elem) {
    ordinal_ = Ordinal::kResponse;
    envelope_.data = static_cast<void*>(elem);
  }

  ::llcpp::fuchsia::device::Controller_UpdatePowerStateMapping_Response& mutable_response() {
    ZX_ASSERT(ordinal() == Ordinal::kResponse);
    return *static_cast<::llcpp::fuchsia::device::Controller_UpdatePowerStateMapping_Response*>(envelope_.data);
  }
  const ::llcpp::fuchsia::device::Controller_UpdatePowerStateMapping_Response& response() const {
    ZX_ASSERT(ordinal() == Ordinal::kResponse);
    return *static_cast<::llcpp::fuchsia::device::Controller_UpdatePowerStateMapping_Response*>(envelope_.data);
  }

  bool is_err() const { return ordinal() == Ordinal::kErr; }

  static Controller_UpdatePowerStateMapping_Result WithErr(int32_t* val) {
    Controller_UpdatePowerStateMapping_Result result;
    result.set_err(val);
    return result;
  }

  void set_err(int32_t* elem) {
    ordinal_ = Ordinal::kErr;
    envelope_.data = static_cast<void*>(elem);
  }

  int32_t& mutable_err() {
    ZX_ASSERT(ordinal() == Ordinal::kErr);
    return *static_cast<int32_t*>(envelope_.data);
  }
  const int32_t& err() const {
    ZX_ASSERT(ordinal() == Ordinal::kErr);
    return *static_cast<int32_t*>(envelope_.data);
  }
  Tag which() const {
    ZX_ASSERT(!has_invalid_tag());
    return static_cast<Tag>(ordinal());
  }

  static constexpr const fidl_type_t* Type = &v1_fuchsia_device_Controller_UpdatePowerStateMapping_ResultTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 24;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 8;
  static constexpr bool HasPointer = true;

 private:
  enum class Ordinal : fidl_xunion_tag_t {
    Invalid = 0,
    kResponse = 1,  // 0x1
    kErr = 2,  // 0x2
  };

  Ordinal ordinal() const {
    return ordinal_;
  }

  static void SizeAndOffsetAssertionHelper();
  Ordinal ordinal_;
  FIDL_ALIGNDECL
  fidl_envelope_t envelope_;
};

extern "C" const fidl_type_t v1_fuchsia_device_Controller_ScheduleUnbind_ResultTable;

struct Controller_ScheduleUnbind_Result {
  Controller_ScheduleUnbind_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}

  enum class Tag : fidl_xunion_tag_t {
    kResponse = 1,  // 0x1
    kErr = 2,  // 0x2
  };

  bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }

  bool is_response() const { return ordinal() == Ordinal::kResponse; }

  static Controller_ScheduleUnbind_Result WithResponse(::llcpp::fuchsia::device::Controller_ScheduleUnbind_Response* val) {
    Controller_ScheduleUnbind_Result result;
    result.set_response(val);
    return result;
  }

  void set_response(::llcpp::fuchsia::device::Controller_ScheduleUnbind_Response* elem) {
    ordinal_ = Ordinal::kResponse;
    envelope_.data = static_cast<void*>(elem);
  }

  ::llcpp::fuchsia::device::Controller_ScheduleUnbind_Response& mutable_response() {
    ZX_ASSERT(ordinal() == Ordinal::kResponse);
    return *static_cast<::llcpp::fuchsia::device::Controller_ScheduleUnbind_Response*>(envelope_.data);
  }
  const ::llcpp::fuchsia::device::Controller_ScheduleUnbind_Response& response() const {
    ZX_ASSERT(ordinal() == Ordinal::kResponse);
    return *static_cast<::llcpp::fuchsia::device::Controller_ScheduleUnbind_Response*>(envelope_.data);
  }

  bool is_err() const { return ordinal() == Ordinal::kErr; }

  static Controller_ScheduleUnbind_Result WithErr(int32_t* val) {
    Controller_ScheduleUnbind_Result result;
    result.set_err(val);
    return result;
  }

  void set_err(int32_t* elem) {
    ordinal_ = Ordinal::kErr;
    envelope_.data = static_cast<void*>(elem);
  }

  int32_t& mutable_err() {
    ZX_ASSERT(ordinal() == Ordinal::kErr);
    return *static_cast<int32_t*>(envelope_.data);
  }
  const int32_t& err() const {
    ZX_ASSERT(ordinal() == Ordinal::kErr);
    return *static_cast<int32_t*>(envelope_.data);
  }
  Tag which() const {
    ZX_ASSERT(!has_invalid_tag());
    return static_cast<Tag>(ordinal());
  }

  static constexpr const fidl_type_t* Type = &v1_fuchsia_device_Controller_ScheduleUnbind_ResultTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 24;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 8;
  static constexpr bool HasPointer = true;

 private:
  enum class Ordinal : fidl_xunion_tag_t {
    Invalid = 0,
    kResponse = 1,  // 0x1
    kErr = 2,  // 0x2
  };

  Ordinal ordinal() const {
    return ordinal_;
  }

  static void SizeAndOffsetAssertionHelper();
  Ordinal ordinal_;
  FIDL_ALIGNDECL
  fidl_envelope_t envelope_;
};

extern "C" const fidl_type_t v1_fuchsia_device_Controller_Rebind_ResultTable;

struct Controller_Rebind_Result {
  Controller_Rebind_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}

  enum class Tag : fidl_xunion_tag_t {
    kResponse = 1,  // 0x1
    kErr = 2,  // 0x2
  };

  bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }

  bool is_response() const { return ordinal() == Ordinal::kResponse; }

  static Controller_Rebind_Result WithResponse(::llcpp::fuchsia::device::Controller_Rebind_Response* val) {
    Controller_Rebind_Result result;
    result.set_response(val);
    return result;
  }

  void set_response(::llcpp::fuchsia::device::Controller_Rebind_Response* elem) {
    ordinal_ = Ordinal::kResponse;
    envelope_.data = static_cast<void*>(elem);
  }

  ::llcpp::fuchsia::device::Controller_Rebind_Response& mutable_response() {
    ZX_ASSERT(ordinal() == Ordinal::kResponse);
    return *static_cast<::llcpp::fuchsia::device::Controller_Rebind_Response*>(envelope_.data);
  }
  const ::llcpp::fuchsia::device::Controller_Rebind_Response& response() const {
    ZX_ASSERT(ordinal() == Ordinal::kResponse);
    return *static_cast<::llcpp::fuchsia::device::Controller_Rebind_Response*>(envelope_.data);
  }

  bool is_err() const { return ordinal() == Ordinal::kErr; }

  static Controller_Rebind_Result WithErr(int32_t* val) {
    Controller_Rebind_Result result;
    result.set_err(val);
    return result;
  }

  void set_err(int32_t* elem) {
    ordinal_ = Ordinal::kErr;
    envelope_.data = static_cast<void*>(elem);
  }

  int32_t& mutable_err() {
    ZX_ASSERT(ordinal() == Ordinal::kErr);
    return *static_cast<int32_t*>(envelope_.data);
  }
  const int32_t& err() const {
    ZX_ASSERT(ordinal() == Ordinal::kErr);
    return *static_cast<int32_t*>(envelope_.data);
  }
  Tag which() const {
    ZX_ASSERT(!has_invalid_tag());
    return static_cast<Tag>(ordinal());
  }

  static constexpr const fidl_type_t* Type = &v1_fuchsia_device_Controller_Rebind_ResultTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 24;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 8;
  static constexpr bool HasPointer = true;

 private:
  enum class Ordinal : fidl_xunion_tag_t {
    Invalid = 0,
    kResponse = 1,  // 0x1
    kErr = 2,  // 0x2
  };

  Ordinal ordinal() const {
    return ordinal_;
  }

  static void SizeAndOffsetAssertionHelper();
  Ordinal ordinal_;
  FIDL_ALIGNDECL
  fidl_envelope_t envelope_;
};

extern "C" const fidl_type_t v1_fuchsia_device_Controller_GetTopologicalPath_ResultTable;

struct Controller_GetTopologicalPath_Result {
  Controller_GetTopologicalPath_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}

  enum class Tag : fidl_xunion_tag_t {
    kResponse = 1,  // 0x1
    kErr = 2,  // 0x2
  };

  bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }

  bool is_response() const { return ordinal() == Ordinal::kResponse; }

  static Controller_GetTopologicalPath_Result WithResponse(::llcpp::fuchsia::device::Controller_GetTopologicalPath_Response* val) {
    Controller_GetTopologicalPath_Result result;
    result.set_response(val);
    return result;
  }

  void set_response(::llcpp::fuchsia::device::Controller_GetTopologicalPath_Response* elem) {
    ordinal_ = Ordinal::kResponse;
    envelope_.data = static_cast<void*>(elem);
  }

  ::llcpp::fuchsia::device::Controller_GetTopologicalPath_Response& mutable_response() {
    ZX_ASSERT(ordinal() == Ordinal::kResponse);
    return *static_cast<::llcpp::fuchsia::device::Controller_GetTopologicalPath_Response*>(envelope_.data);
  }
  const ::llcpp::fuchsia::device::Controller_GetTopologicalPath_Response& response() const {
    ZX_ASSERT(ordinal() == Ordinal::kResponse);
    return *static_cast<::llcpp::fuchsia::device::Controller_GetTopologicalPath_Response*>(envelope_.data);
  }

  bool is_err() const { return ordinal() == Ordinal::kErr; }

  static Controller_GetTopologicalPath_Result WithErr(int32_t* val) {
    Controller_GetTopologicalPath_Result result;
    result.set_err(val);
    return result;
  }

  void set_err(int32_t* elem) {
    ordinal_ = Ordinal::kErr;
    envelope_.data = static_cast<void*>(elem);
  }

  int32_t& mutable_err() {
    ZX_ASSERT(ordinal() == Ordinal::kErr);
    return *static_cast<int32_t*>(envelope_.data);
  }
  const int32_t& err() const {
    ZX_ASSERT(ordinal() == Ordinal::kErr);
    return *static_cast<int32_t*>(envelope_.data);
  }
  Tag which() const {
    ZX_ASSERT(!has_invalid_tag());
    return static_cast<Tag>(ordinal());
  }

  static constexpr const fidl_type_t* Type = &v1_fuchsia_device_Controller_GetTopologicalPath_ResultTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 24;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 1040;
  static constexpr bool HasPointer = true;

 private:
  enum class Ordinal : fidl_xunion_tag_t {
    Invalid = 0,
    kResponse = 1,  // 0x1
    kErr = 2,  // 0x2
  };

  Ordinal ordinal() const {
    return ordinal_;
  }

  static void SizeAndOffsetAssertionHelper();
  Ordinal ordinal_;
  FIDL_ALIGNDECL
  fidl_envelope_t envelope_;
};

extern "C" const fidl_type_t v1_fuchsia_device_Controller_Bind_ResultTable;

struct Controller_Bind_Result {
  Controller_Bind_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}

  enum class Tag : fidl_xunion_tag_t {
    kResponse = 1,  // 0x1
    kErr = 2,  // 0x2
  };

  bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }

  bool is_response() const { return ordinal() == Ordinal::kResponse; }

  static Controller_Bind_Result WithResponse(::llcpp::fuchsia::device::Controller_Bind_Response* val) {
    Controller_Bind_Result result;
    result.set_response(val);
    return result;
  }

  void set_response(::llcpp::fuchsia::device::Controller_Bind_Response* elem) {
    ordinal_ = Ordinal::kResponse;
    envelope_.data = static_cast<void*>(elem);
  }

  ::llcpp::fuchsia::device::Controller_Bind_Response& mutable_response() {
    ZX_ASSERT(ordinal() == Ordinal::kResponse);
    return *static_cast<::llcpp::fuchsia::device::Controller_Bind_Response*>(envelope_.data);
  }
  const ::llcpp::fuchsia::device::Controller_Bind_Response& response() const {
    ZX_ASSERT(ordinal() == Ordinal::kResponse);
    return *static_cast<::llcpp::fuchsia::device::Controller_Bind_Response*>(envelope_.data);
  }

  bool is_err() const { return ordinal() == Ordinal::kErr; }

  static Controller_Bind_Result WithErr(int32_t* val) {
    Controller_Bind_Result result;
    result.set_err(val);
    return result;
  }

  void set_err(int32_t* elem) {
    ordinal_ = Ordinal::kErr;
    envelope_.data = static_cast<void*>(elem);
  }

  int32_t& mutable_err() {
    ZX_ASSERT(ordinal() == Ordinal::kErr);
    return *static_cast<int32_t*>(envelope_.data);
  }
  const int32_t& err() const {
    ZX_ASSERT(ordinal() == Ordinal::kErr);
    return *static_cast<int32_t*>(envelope_.data);
  }
  Tag which() const {
    ZX_ASSERT(!has_invalid_tag());
    return static_cast<Tag>(ordinal());
  }

  static constexpr const fidl_type_t* Type = &v1_fuchsia_device_Controller_Bind_ResultTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 24;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 8;
  static constexpr bool HasPointer = true;

 private:
  enum class Ordinal : fidl_xunion_tag_t {
    Invalid = 0,
    kResponse = 1,  // 0x1
    kErr = 2,  // 0x2
  };

  Ordinal ordinal() const {
    return ordinal_;
  }

  static void SizeAndOffsetAssertionHelper();
  Ordinal ordinal_;
  FIDL_ALIGNDECL
  fidl_envelope_t envelope_;
};

extern "C" const fidl_type_t v1_fuchsia_device_NameProvider_GetDeviceName_ResponseTable;

struct NameProvider_GetDeviceName_Response {
  static constexpr const fidl_type_t* Type = &v1_fuchsia_device_NameProvider_GetDeviceName_ResponseTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 16;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 256;
  static constexpr bool HasPointer = true;

  ::fidl::StringView name = {};
};

extern "C" const fidl_type_t v1_fuchsia_device_NameProviderGetDeviceNameRequestTable;
extern "C" const fidl_type_t v1_fuchsia_device_NameProviderGetDeviceNameResponseTable;

// Interface for getting device names.
class NameProvider final {
  NameProvider() = delete;
 public:
  static constexpr char Name[] = "fuchsia.device.NameProvider";

  struct GetDeviceNameResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::llcpp::fuchsia::device::NameProvider_GetDeviceName_Result result;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_NameProviderGetDeviceNameResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 40;
    static constexpr uint32_t MaxOutOfLine = 272;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = true;
    static constexpr bool ContainsUnion = true;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  using GetDeviceNameRequest = ::fidl::AnyZeroArgMessage;


  // Collection of return types of FIDL calls in this interface.
  class ResultOf final {
    ResultOf() = delete;
   private:
    template <typename ResponseType>
    class GetDeviceName_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      GetDeviceName_Impl(::zx::unowned_channel _client_end);
      ~GetDeviceName_Impl() = default;
      GetDeviceName_Impl(GetDeviceName_Impl&& other) = default;
      GetDeviceName_Impl& operator=(GetDeviceName_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };

   public:
    using GetDeviceName = GetDeviceName_Impl<GetDeviceNameResponse>;
  };

  // Collection of return types of FIDL calls in this interface,
  // when the caller-allocate flavor or in-place call is used.
  class UnownedResultOf final {
    UnownedResultOf() = delete;
   private:
    template <typename ResponseType>
    class GetDeviceName_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      GetDeviceName_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
      ~GetDeviceName_Impl() = default;
      GetDeviceName_Impl(GetDeviceName_Impl&& other) = default;
      GetDeviceName_Impl& operator=(GetDeviceName_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };

   public:
    using GetDeviceName = GetDeviceName_Impl<GetDeviceNameResponse>;
  };

  class SyncClient final {
   public:
    explicit SyncClient(::zx::channel channel) : channel_(std::move(channel)) {}
    ~SyncClient() = default;
    SyncClient(SyncClient&&) = default;
    SyncClient& operator=(SyncClient&&) = default;

    const ::zx::channel& channel() const { return channel_; }

    ::zx::channel* mutable_channel() { return &channel_; }

    // Return the name of this Fuchsia device.
    // Allocates 328 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::GetDeviceName GetDeviceName();

    // Return the name of this Fuchsia device.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::GetDeviceName GetDeviceName(::fidl::BytePart _response_buffer);

   private:
    ::zx::channel channel_;
  };

  // Methods to make a sync FIDL call directly on an unowned channel, avoiding setting up a client.
  class Call final {
    Call() = delete;
   public:

    // Return the name of this Fuchsia device.
    // Allocates 328 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::GetDeviceName GetDeviceName(::zx::unowned_channel _client_end);

    // Return the name of this Fuchsia device.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::GetDeviceName GetDeviceName(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);

  };

  // Messages are encoded and decoded in-place when these methods are used.
  // Additionally, requests must be already laid-out according to the FIDL wire-format.
  class InPlace final {
    InPlace() = delete;
   public:

    // Return the name of this Fuchsia device.
    static ::fidl::DecodeResult<GetDeviceNameResponse> GetDeviceName(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);

  };

  // Pure-virtual interface to be implemented by a server.
  class Interface {
   public:
    Interface() = default;
    virtual ~Interface() = default;
    using _Outer = NameProvider;
    using _Base = ::fidl::CompleterBase;

    class GetDeviceNameCompleterBase : public _Base {
     public:
      void Reply(::llcpp::fuchsia::device::NameProvider_GetDeviceName_Result result);
      void ReplySuccess(::fidl::StringView name);
      void ReplyError(int32_t error);
      void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::NameProvider_GetDeviceName_Result result);
      void ReplySuccess(::fidl::BytePart _buffer, ::fidl::StringView name);
      void Reply(::fidl::DecodedMessage<GetDeviceNameResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using GetDeviceNameCompleter = ::fidl::Completer<GetDeviceNameCompleterBase>;

    virtual void GetDeviceName(GetDeviceNameCompleter::Sync _completer) = 0;

  };

  // Attempts to dispatch the incoming message to a handler function in the server implementation.
  // If there is no matching handler, it returns false, leaving the message and transaction intact.
  // In all other cases, it consumes the message and returns true.
  // It is possible to chain multiple TryDispatch functions in this manner.
  static bool TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn);

  // Dispatches the incoming message to one of the handlers functions in the interface.
  // If there is no matching handler, it closes all the handles in |msg| and closes the channel with
  // a |ZX_ERR_NOT_SUPPORTED| epitaph, before returning false. The message should then be discarded.
  static bool Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn);

  // Same as |Dispatch|, but takes a |void*| instead of |Interface*|. Only used with |fidl::Bind|
  // to reduce template expansion.
  // Do not call this method manually. Use |Dispatch| instead.
  static bool TypeErasedDispatch(void* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
    return Dispatch(static_cast<Interface*>(impl), msg, txn);
  }


  // Helper functions to fill in the transaction header in a |DecodedMessage<TransactionalMessage>|.
  class SetTransactionHeaderFor final {
    SetTransactionHeaderFor() = delete;
   public:
    static void GetDeviceNameRequest(const ::fidl::DecodedMessage<NameProvider::GetDeviceNameRequest>& _msg);
    static void GetDeviceNameResponse(const ::fidl::DecodedMessage<NameProvider::GetDeviceNameResponse>& _msg);
  };
};

constexpr uint32_t MIN_DEVICE_POWER_STATES = 2u;

constexpr uint32_t MIN_DEVICE_PERFORMANCE_STATES = 1u;

// Maximum length for a driver path
constexpr uint64_t MAX_DRIVER_PATH_LEN = 1024u;

// Maxmium length for a driver name
constexpr uint64_t MAX_DRIVER_NAME_LEN = 32u;

// Maximum device power states. In future this should account
// for performance states.
constexpr uint32_t MAX_DEVICE_POWER_STATES = 5u;

constexpr uint32_t MAX_DEVICE_PERFORMANCE_STATES = 20u;

// Maximum length of a device path
constexpr uint64_t MAX_DEVICE_PATH_LEN = 1024u;

// Maxmium length for a device name
constexpr uint64_t MAX_DEVICE_NAME_LEN = 32u;

extern "C" const fidl_type_t v1_fuchsia_device_SystemPowerStateInfoTable;

struct SystemPowerStateInfo {
  static constexpr const fidl_type_t* Type = &v1_fuchsia_device_SystemPowerStateInfoTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 8;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 0;
  static constexpr bool HasPointer = false;

  uint32_t suspend_flag = {};

  // Should wakeup be enabled from this system state?
  bool wakeup_enable = {};

  // Device power state that the device should be in for this system power state.
  ::llcpp::fuchsia::device::DevicePowerState dev_state = {};
};

extern "C" const fidl_type_t v1_fuchsia_device_Controller_GetPowerStateMapping_ResponseTable;

struct Controller_GetPowerStateMapping_Response {
  static constexpr const fidl_type_t* Type = &v1_fuchsia_device_Controller_GetPowerStateMapping_ResponseTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 56;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 0;
  static constexpr bool HasPointer = false;

  ::fidl::Array<::llcpp::fuchsia::device::SystemPowerStateInfo, 7> mapping = {};
};

extern "C" const fidl_type_t v1_fuchsia_device_DevicePowerStateInfoTable;

struct DevicePowerStateInfo {
  static constexpr const fidl_type_t* Type = &v1_fuchsia_device_DevicePowerStateInfoTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 24;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 0;
  static constexpr bool HasPointer = false;

  ::llcpp::fuchsia::device::DevicePowerState state_id = {};

  // Is this state supported?
  bool is_supported = {};

  // Restore time for coming out of this state to working D0 state.
  int64_t restore_latency = {};

  // Is this device wakeup_capable?
  bool wakeup_capable = {};

  // Deepest system system sleep state that the device can wake the system from.
  int32_t system_wake_state = {};
};

extern "C" const fidl_type_t v1_fuchsia_device_Controller_GetDevicePowerCaps_ResponseTable;

struct Controller_GetDevicePowerCaps_Response {
  static constexpr const fidl_type_t* Type = &v1_fuchsia_device_Controller_GetDevicePowerCaps_ResponseTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 120;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 0;
  static constexpr bool HasPointer = false;

  ::fidl::Array<::llcpp::fuchsia::device::DevicePowerStateInfo, 5> dpstates = {};
};

extern "C" const fidl_type_t v1_fuchsia_device_Controller_Resume_ResponseTable;

struct Controller_Resume_Response {
  static constexpr const fidl_type_t* Type = &v1_fuchsia_device_Controller_Resume_ResponseTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 1;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 0;
  static constexpr bool HasPointer = false;

  ::llcpp::fuchsia::device::DevicePowerState out_state = {};
};

extern "C" const fidl_type_t v1_fuchsia_device_DevicePerformanceStateInfoTable;

// Performance state info for a device. A performance state is relevant only
// when the device is in non-sleeping working device power state.
struct DevicePerformanceStateInfo {
  static constexpr const fidl_type_t* Type = &v1_fuchsia_device_DevicePerformanceStateInfoTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 24;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 0;
  static constexpr bool HasPointer = false;

  int32_t state_id = {};

  // Restore time for coming out of this state to fully working performance state.
  int64_t restore_latency = {};

  // Is this state supported?
  bool is_supported = {};
};

// Signal that will be active on a device event handle if the device's write() method
// will accept data.
constexpr uint32_t DEVICE_SIGNAL_WRITABLE = 67108864u;

// Signal that will be active on a device event handle if the device's read() method
// will return data.
constexpr uint32_t DEVICE_SIGNAL_READABLE = 16777216u;

// Signal that will be active on a device event handle if the device has some out-of-band
// mechanism that needs attention.
// This is primarily used by the PTY support.
constexpr uint32_t DEVICE_SIGNAL_OOB = 33554432u;

// Signal that will be active on a device event handle if the device has been disconnected.
// This is primarily used by the PTY support.
constexpr uint32_t DEVICE_SIGNAL_HANGUP = 268435456u;

// Signal that will be active on a device event handle if the device has encountered an error.
// This is primarily used by the PTY support.
constexpr uint32_t DEVICE_SIGNAL_ERROR = 134217728u;

// [MANDATORY] Default performance state when the device is in DEVICE_POWER_STATE_D0
constexpr uint32_t DEVICE_PERFORMANCE_STATE_P0 = 0u;

// Maximum length of a device name (without a null byte), based on
// HOST_NAME_MAX as defined by <limits.h>.
constexpr uint32_t DEVICE_NAME_MAX = 255u;

extern const char DEFAULT_DEVICE_NAME[];

extern "C" const fidl_type_t v1_fuchsia_device_Controller_UpdatePowerStateMapping_ResponseTable;

struct Controller_UpdatePowerStateMapping_Response {
  static constexpr const fidl_type_t* Type = &v1_fuchsia_device_Controller_UpdatePowerStateMapping_ResponseTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 1;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 0;
  static constexpr bool HasPointer = false;

  uint8_t __reserved = {};
};

extern "C" const fidl_type_t v1_fuchsia_device_Controller_ScheduleUnbind_ResponseTable;

struct Controller_ScheduleUnbind_Response {
  static constexpr const fidl_type_t* Type = &v1_fuchsia_device_Controller_ScheduleUnbind_ResponseTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 1;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 0;
  static constexpr bool HasPointer = false;

  uint8_t __reserved = {};
};

extern "C" const fidl_type_t v1_fuchsia_device_Controller_Rebind_ResponseTable;

struct Controller_Rebind_Response {
  static constexpr const fidl_type_t* Type = &v1_fuchsia_device_Controller_Rebind_ResponseTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 1;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 0;
  static constexpr bool HasPointer = false;

  uint8_t __reserved = {};
};

extern "C" const fidl_type_t v1_fuchsia_device_Controller_GetTopologicalPath_ResponseTable;

struct Controller_GetTopologicalPath_Response {
  static constexpr const fidl_type_t* Type = &v1_fuchsia_device_Controller_GetTopologicalPath_ResponseTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 16;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 1024;
  static constexpr bool HasPointer = true;

  ::fidl::StringView path = {};
};

extern "C" const fidl_type_t v1_fuchsia_device_Controller_Bind_ResponseTable;

struct Controller_Bind_Response {
  static constexpr const fidl_type_t* Type = &v1_fuchsia_device_Controller_Bind_ResponseTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 1;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 0;
  static constexpr bool HasPointer = false;

  uint8_t __reserved = {};
};

extern "C" const fidl_type_t v1_fuchsia_device_ControllerBindRequestTable;
extern "C" const fidl_type_t v1_fuchsia_device_ControllerBindResponseTable;
extern "C" const fidl_type_t v1_fuchsia_device_ControllerRebindRequestTable;
extern "C" const fidl_type_t v1_fuchsia_device_ControllerRebindResponseTable;
extern "C" const fidl_type_t v1_fuchsia_device_ControllerScheduleUnbindRequestTable;
extern "C" const fidl_type_t v1_fuchsia_device_ControllerScheduleUnbindResponseTable;
extern "C" const fidl_type_t v1_fuchsia_device_ControllerGetDriverNameRequestTable;
extern "C" const fidl_type_t v1_fuchsia_device_ControllerGetDriverNameResponseTable;
extern "C" const fidl_type_t v1_fuchsia_device_ControllerGetDeviceNameRequestTable;
extern "C" const fidl_type_t v1_fuchsia_device_ControllerGetDeviceNameResponseTable;
extern "C" const fidl_type_t v1_fuchsia_device_ControllerGetTopologicalPathRequestTable;
extern "C" const fidl_type_t v1_fuchsia_device_ControllerGetTopologicalPathResponseTable;
extern "C" const fidl_type_t v1_fuchsia_device_ControllerGetEventHandleRequestTable;
extern "C" const fidl_type_t v1_fuchsia_device_ControllerGetEventHandleResponseTable;
extern "C" const fidl_type_t v1_fuchsia_device_ControllerGetDriverLogFlagsRequestTable;
extern "C" const fidl_type_t v1_fuchsia_device_ControllerGetDriverLogFlagsResponseTable;
extern "C" const fidl_type_t v1_fuchsia_device_ControllerSetDriverLogFlagsRequestTable;
extern "C" const fidl_type_t v1_fuchsia_device_ControllerSetDriverLogFlagsResponseTable;
extern "C" const fidl_type_t v1_fuchsia_device_ControllerDebugResumeRequestTable;
extern "C" const fidl_type_t v1_fuchsia_device_ControllerDebugResumeResponseTable;
extern "C" const fidl_type_t v1_fuchsia_device_ControllerRunCompatibilityTestsRequestTable;
extern "C" const fidl_type_t v1_fuchsia_device_ControllerRunCompatibilityTestsResponseTable;
extern "C" const fidl_type_t v1_fuchsia_device_ControllerGetDevicePowerCapsRequestTable;
extern "C" const fidl_type_t v1_fuchsia_device_ControllerGetDevicePowerCapsResponseTable;
extern "C" const fidl_type_t v1_fuchsia_device_ControllerGetDevicePerformanceStatesRequestTable;
extern "C" const fidl_type_t v1_fuchsia_device_ControllerGetDevicePerformanceStatesResponseTable;
extern "C" const fidl_type_t v1_fuchsia_device_ControllerUpdatePowerStateMappingRequestTable;
extern "C" const fidl_type_t v1_fuchsia_device_ControllerUpdatePowerStateMappingResponseTable;
extern "C" const fidl_type_t v1_fuchsia_device_ControllerGetPowerStateMappingRequestTable;
extern "C" const fidl_type_t v1_fuchsia_device_ControllerGetPowerStateMappingResponseTable;
extern "C" const fidl_type_t v1_fuchsia_device_ControllerSuspendRequestTable;
extern "C" const fidl_type_t v1_fuchsia_device_ControllerSuspendResponseTable;
extern "C" const fidl_type_t v1_fuchsia_device_ControllerResumeRequestTable;
extern "C" const fidl_type_t v1_fuchsia_device_ControllerResumeResponseTable;
extern "C" const fidl_type_t v1_fuchsia_device_ControllerSetPerformanceStateRequestTable;
extern "C" const fidl_type_t v1_fuchsia_device_ControllerSetPerformanceStateResponseTable;
extern "C" const fidl_type_t v1_fuchsia_device_ControllerConfigureAutoSuspendRequestTable;
extern "C" const fidl_type_t v1_fuchsia_device_ControllerConfigureAutoSuspendResponseTable;

// Interface for manipulating a device in a devhost
class Controller final {
  Controller() = delete;
 public:

  struct BindResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::llcpp::fuchsia::device::Controller_Bind_Result result;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_ControllerBindResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 40;
    static constexpr uint32_t MaxOutOfLine = 8;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = true;
    static constexpr bool ContainsUnion = true;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  struct BindRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::fidl::StringView driver;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_ControllerBindRequestTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 32;
    static constexpr uint32_t MaxOutOfLine = 1024;
    static constexpr uint32_t AltPrimarySize = 32;
    static constexpr uint32_t AltMaxOutOfLine = 1024;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = true;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kRequest;
    using ResponseType = BindResponse;
  };

  struct RebindResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::llcpp::fuchsia::device::Controller_Rebind_Result result;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_ControllerRebindResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 40;
    static constexpr uint32_t MaxOutOfLine = 8;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = true;
    static constexpr bool ContainsUnion = true;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  struct RebindRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::fidl::StringView driver;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_ControllerRebindRequestTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 32;
    static constexpr uint32_t MaxOutOfLine = 1024;
    static constexpr uint32_t AltPrimarySize = 32;
    static constexpr uint32_t AltMaxOutOfLine = 1024;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = true;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kRequest;
    using ResponseType = RebindResponse;
  };

  struct ScheduleUnbindResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::llcpp::fuchsia::device::Controller_ScheduleUnbind_Result result;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_ControllerScheduleUnbindResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 40;
    static constexpr uint32_t MaxOutOfLine = 8;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = true;
    static constexpr bool ContainsUnion = true;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  using ScheduleUnbindRequest = ::fidl::AnyZeroArgMessage;

  struct GetDriverNameResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t status;
    ::fidl::StringView name;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_ControllerGetDriverNameResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 40;
    static constexpr uint32_t MaxOutOfLine = 32;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = true;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  using GetDriverNameRequest = ::fidl::AnyZeroArgMessage;

  struct GetDeviceNameResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::fidl::StringView name;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_ControllerGetDeviceNameResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 32;
    static constexpr uint32_t MaxOutOfLine = 32;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = true;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  using GetDeviceNameRequest = ::fidl::AnyZeroArgMessage;

  struct GetTopologicalPathResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::llcpp::fuchsia::device::Controller_GetTopologicalPath_Result result;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_ControllerGetTopologicalPathResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 40;
    static constexpr uint32_t MaxOutOfLine = 1040;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = true;
    static constexpr bool ContainsUnion = true;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  using GetTopologicalPathRequest = ::fidl::AnyZeroArgMessage;

  struct GetEventHandleResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t status;
    ::zx::event event;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_ControllerGetEventHandleResponseTable;
    static constexpr uint32_t MaxNumHandles = 1;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  using GetEventHandleRequest = ::fidl::AnyZeroArgMessage;

  struct GetDriverLogFlagsResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t status;
    uint32_t flags;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_ControllerGetDriverLogFlagsResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  using GetDriverLogFlagsRequest = ::fidl::AnyZeroArgMessage;

  struct SetDriverLogFlagsResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t status;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_ControllerSetDriverLogFlagsResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  struct SetDriverLogFlagsRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    uint32_t clear_flags;
    uint32_t set_flags;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_ControllerSetDriverLogFlagsRequestTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr uint32_t AltPrimarySize = 24;
    static constexpr uint32_t AltMaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kRequest;
    using ResponseType = SetDriverLogFlagsResponse;
  };

  struct DebugResumeResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t status;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_ControllerDebugResumeResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  using DebugResumeRequest = ::fidl::AnyZeroArgMessage;

  struct RunCompatibilityTestsResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    uint32_t status;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_ControllerRunCompatibilityTestsResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  struct RunCompatibilityTestsRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int64_t hook_wait_time;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_ControllerRunCompatibilityTestsRequestTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr uint32_t AltPrimarySize = 24;
    static constexpr uint32_t AltMaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kRequest;
    using ResponseType = RunCompatibilityTestsResponse;
  };

  struct GetDevicePowerCapsResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::llcpp::fuchsia::device::Controller_GetDevicePowerCaps_Result result;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_ControllerGetDevicePowerCapsResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 40;
    static constexpr uint32_t MaxOutOfLine = 120;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = true;
    static constexpr bool ContainsUnion = true;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  using GetDevicePowerCapsRequest = ::fidl::AnyZeroArgMessage;

  struct GetDevicePerformanceStatesResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::fidl::Array<::llcpp::fuchsia::device::DevicePerformanceStateInfo, 20> states;
    int32_t status;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_ControllerGetDevicePerformanceStatesResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 504;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  using GetDevicePerformanceStatesRequest = ::fidl::AnyZeroArgMessage;

  struct UpdatePowerStateMappingResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::llcpp::fuchsia::device::Controller_UpdatePowerStateMapping_Result result;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_ControllerUpdatePowerStateMappingResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 40;
    static constexpr uint32_t MaxOutOfLine = 8;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = true;
    static constexpr bool ContainsUnion = true;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  struct UpdatePowerStateMappingRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::fidl::Array<::llcpp::fuchsia::device::SystemPowerStateInfo, 7> mapping;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_ControllerUpdatePowerStateMappingRequestTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 72;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr uint32_t AltPrimarySize = 72;
    static constexpr uint32_t AltMaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kRequest;
    using ResponseType = UpdatePowerStateMappingResponse;
  };

  struct GetPowerStateMappingResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::llcpp::fuchsia::device::Controller_GetPowerStateMapping_Result result;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_ControllerGetPowerStateMappingResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 40;
    static constexpr uint32_t MaxOutOfLine = 56;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = true;
    static constexpr bool ContainsUnion = true;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  using GetPowerStateMappingRequest = ::fidl::AnyZeroArgMessage;

  struct SuspendResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t status;
    ::llcpp::fuchsia::device::DevicePowerState out_state;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_ControllerSuspendResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  struct SuspendRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::llcpp::fuchsia::device::DevicePowerState requested_state;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_ControllerSuspendRequestTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr uint32_t AltPrimarySize = 24;
    static constexpr uint32_t AltMaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kRequest;
    using ResponseType = SuspendResponse;
  };

  struct ResumeResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::llcpp::fuchsia::device::Controller_Resume_Result result;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_ControllerResumeResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 40;
    static constexpr uint32_t MaxOutOfLine = 8;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = true;
    static constexpr bool ContainsUnion = true;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  struct ResumeRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::llcpp::fuchsia::device::DevicePowerState requested_state;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_ControllerResumeRequestTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr uint32_t AltPrimarySize = 24;
    static constexpr uint32_t AltMaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kRequest;
    using ResponseType = ResumeResponse;
  };

  struct SetPerformanceStateResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t status;
    uint32_t out_state;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_ControllerSetPerformanceStateResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  struct SetPerformanceStateRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    uint32_t requested_state;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_ControllerSetPerformanceStateRequestTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr uint32_t AltPrimarySize = 24;
    static constexpr uint32_t AltMaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kRequest;
    using ResponseType = SetPerformanceStateResponse;
  };

  struct ConfigureAutoSuspendResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t status;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_ControllerConfigureAutoSuspendResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  struct ConfigureAutoSuspendRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    bool enable;
    ::llcpp::fuchsia::device::DevicePowerState requested_deepest_sleep_state;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_ControllerConfigureAutoSuspendRequestTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr uint32_t AltPrimarySize = 24;
    static constexpr uint32_t AltMaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kRequest;
    using ResponseType = ConfigureAutoSuspendResponse;
  };


  // Collection of return types of FIDL calls in this interface.
  class ResultOf final {
    ResultOf() = delete;
   private:
    template <typename ResponseType>
    class Bind_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      Bind_Impl(::zx::unowned_channel _client_end, ::fidl::StringView driver);
      ~Bind_Impl() = default;
      Bind_Impl(Bind_Impl&& other) = default;
      Bind_Impl& operator=(Bind_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class Rebind_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      Rebind_Impl(::zx::unowned_channel _client_end, ::fidl::StringView driver);
      ~Rebind_Impl() = default;
      Rebind_Impl(Rebind_Impl&& other) = default;
      Rebind_Impl& operator=(Rebind_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class ScheduleUnbind_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      ScheduleUnbind_Impl(::zx::unowned_channel _client_end);
      ~ScheduleUnbind_Impl() = default;
      ScheduleUnbind_Impl(ScheduleUnbind_Impl&& other) = default;
      ScheduleUnbind_Impl& operator=(ScheduleUnbind_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class GetDriverName_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      GetDriverName_Impl(::zx::unowned_channel _client_end);
      ~GetDriverName_Impl() = default;
      GetDriverName_Impl(GetDriverName_Impl&& other) = default;
      GetDriverName_Impl& operator=(GetDriverName_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class GetDeviceName_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      GetDeviceName_Impl(::zx::unowned_channel _client_end);
      ~GetDeviceName_Impl() = default;
      GetDeviceName_Impl(GetDeviceName_Impl&& other) = default;
      GetDeviceName_Impl& operator=(GetDeviceName_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class GetTopologicalPath_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      GetTopologicalPath_Impl(::zx::unowned_channel _client_end);
      ~GetTopologicalPath_Impl() = default;
      GetTopologicalPath_Impl(GetTopologicalPath_Impl&& other) = default;
      GetTopologicalPath_Impl& operator=(GetTopologicalPath_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class GetEventHandle_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      GetEventHandle_Impl(::zx::unowned_channel _client_end);
      ~GetEventHandle_Impl() = default;
      GetEventHandle_Impl(GetEventHandle_Impl&& other) = default;
      GetEventHandle_Impl& operator=(GetEventHandle_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class GetDriverLogFlags_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      GetDriverLogFlags_Impl(::zx::unowned_channel _client_end);
      ~GetDriverLogFlags_Impl() = default;
      GetDriverLogFlags_Impl(GetDriverLogFlags_Impl&& other) = default;
      GetDriverLogFlags_Impl& operator=(GetDriverLogFlags_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class SetDriverLogFlags_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      SetDriverLogFlags_Impl(::zx::unowned_channel _client_end, uint32_t clear_flags, uint32_t set_flags);
      ~SetDriverLogFlags_Impl() = default;
      SetDriverLogFlags_Impl(SetDriverLogFlags_Impl&& other) = default;
      SetDriverLogFlags_Impl& operator=(SetDriverLogFlags_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class DebugResume_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      DebugResume_Impl(::zx::unowned_channel _client_end);
      ~DebugResume_Impl() = default;
      DebugResume_Impl(DebugResume_Impl&& other) = default;
      DebugResume_Impl& operator=(DebugResume_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class RunCompatibilityTests_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      RunCompatibilityTests_Impl(::zx::unowned_channel _client_end, int64_t hook_wait_time);
      ~RunCompatibilityTests_Impl() = default;
      RunCompatibilityTests_Impl(RunCompatibilityTests_Impl&& other) = default;
      RunCompatibilityTests_Impl& operator=(RunCompatibilityTests_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class GetDevicePowerCaps_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      GetDevicePowerCaps_Impl(::zx::unowned_channel _client_end);
      ~GetDevicePowerCaps_Impl() = default;
      GetDevicePowerCaps_Impl(GetDevicePowerCaps_Impl&& other) = default;
      GetDevicePowerCaps_Impl& operator=(GetDevicePowerCaps_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class GetDevicePerformanceStates_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      GetDevicePerformanceStates_Impl(::zx::unowned_channel _client_end);
      ~GetDevicePerformanceStates_Impl() = default;
      GetDevicePerformanceStates_Impl(GetDevicePerformanceStates_Impl&& other) = default;
      GetDevicePerformanceStates_Impl& operator=(GetDevicePerformanceStates_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class UpdatePowerStateMapping_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      UpdatePowerStateMapping_Impl(::zx::unowned_channel _client_end, ::fidl::Array<::llcpp::fuchsia::device::SystemPowerStateInfo, 7> mapping);
      ~UpdatePowerStateMapping_Impl() = default;
      UpdatePowerStateMapping_Impl(UpdatePowerStateMapping_Impl&& other) = default;
      UpdatePowerStateMapping_Impl& operator=(UpdatePowerStateMapping_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class GetPowerStateMapping_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      GetPowerStateMapping_Impl(::zx::unowned_channel _client_end);
      ~GetPowerStateMapping_Impl() = default;
      GetPowerStateMapping_Impl(GetPowerStateMapping_Impl&& other) = default;
      GetPowerStateMapping_Impl& operator=(GetPowerStateMapping_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class Suspend_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      Suspend_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::DevicePowerState requested_state);
      ~Suspend_Impl() = default;
      Suspend_Impl(Suspend_Impl&& other) = default;
      Suspend_Impl& operator=(Suspend_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class Resume_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      Resume_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::DevicePowerState requested_state);
      ~Resume_Impl() = default;
      Resume_Impl(Resume_Impl&& other) = default;
      Resume_Impl& operator=(Resume_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class SetPerformanceState_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      SetPerformanceState_Impl(::zx::unowned_channel _client_end, uint32_t requested_state);
      ~SetPerformanceState_Impl() = default;
      SetPerformanceState_Impl(SetPerformanceState_Impl&& other) = default;
      SetPerformanceState_Impl& operator=(SetPerformanceState_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class ConfigureAutoSuspend_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      ConfigureAutoSuspend_Impl(::zx::unowned_channel _client_end, bool enable, ::llcpp::fuchsia::device::DevicePowerState requested_deepest_sleep_state);
      ~ConfigureAutoSuspend_Impl() = default;
      ConfigureAutoSuspend_Impl(ConfigureAutoSuspend_Impl&& other) = default;
      ConfigureAutoSuspend_Impl& operator=(ConfigureAutoSuspend_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };

   public:
    using Bind = Bind_Impl<BindResponse>;
    using Rebind = Rebind_Impl<RebindResponse>;
    using ScheduleUnbind = ScheduleUnbind_Impl<ScheduleUnbindResponse>;
    using GetDriverName = GetDriverName_Impl<GetDriverNameResponse>;
    using GetDeviceName = GetDeviceName_Impl<GetDeviceNameResponse>;
    using GetTopologicalPath = GetTopologicalPath_Impl<GetTopologicalPathResponse>;
    using GetEventHandle = GetEventHandle_Impl<GetEventHandleResponse>;
    using GetDriverLogFlags = GetDriverLogFlags_Impl<GetDriverLogFlagsResponse>;
    using SetDriverLogFlags = SetDriverLogFlags_Impl<SetDriverLogFlagsResponse>;
    using DebugResume = DebugResume_Impl<DebugResumeResponse>;
    using RunCompatibilityTests = RunCompatibilityTests_Impl<RunCompatibilityTestsResponse>;
    using GetDevicePowerCaps = GetDevicePowerCaps_Impl<GetDevicePowerCapsResponse>;
    using GetDevicePerformanceStates = GetDevicePerformanceStates_Impl<GetDevicePerformanceStatesResponse>;
    using UpdatePowerStateMapping = UpdatePowerStateMapping_Impl<UpdatePowerStateMappingResponse>;
    using GetPowerStateMapping = GetPowerStateMapping_Impl<GetPowerStateMappingResponse>;
    using Suspend = Suspend_Impl<SuspendResponse>;
    using Resume = Resume_Impl<ResumeResponse>;
    using SetPerformanceState = SetPerformanceState_Impl<SetPerformanceStateResponse>;
    using ConfigureAutoSuspend = ConfigureAutoSuspend_Impl<ConfigureAutoSuspendResponse>;
  };

  // Collection of return types of FIDL calls in this interface,
  // when the caller-allocate flavor or in-place call is used.
  class UnownedResultOf final {
    UnownedResultOf() = delete;
   private:
    template <typename ResponseType>
    class Bind_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      Bind_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView driver, ::fidl::BytePart _response_buffer);
      ~Bind_Impl() = default;
      Bind_Impl(Bind_Impl&& other) = default;
      Bind_Impl& operator=(Bind_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class Rebind_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      Rebind_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView driver, ::fidl::BytePart _response_buffer);
      ~Rebind_Impl() = default;
      Rebind_Impl(Rebind_Impl&& other) = default;
      Rebind_Impl& operator=(Rebind_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class ScheduleUnbind_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      ScheduleUnbind_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
      ~ScheduleUnbind_Impl() = default;
      ScheduleUnbind_Impl(ScheduleUnbind_Impl&& other) = default;
      ScheduleUnbind_Impl& operator=(ScheduleUnbind_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class GetDriverName_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      GetDriverName_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
      ~GetDriverName_Impl() = default;
      GetDriverName_Impl(GetDriverName_Impl&& other) = default;
      GetDriverName_Impl& operator=(GetDriverName_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class GetDeviceName_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      GetDeviceName_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
      ~GetDeviceName_Impl() = default;
      GetDeviceName_Impl(GetDeviceName_Impl&& other) = default;
      GetDeviceName_Impl& operator=(GetDeviceName_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class GetTopologicalPath_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      GetTopologicalPath_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
      ~GetTopologicalPath_Impl() = default;
      GetTopologicalPath_Impl(GetTopologicalPath_Impl&& other) = default;
      GetTopologicalPath_Impl& operator=(GetTopologicalPath_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class GetEventHandle_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      GetEventHandle_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
      ~GetEventHandle_Impl() = default;
      GetEventHandle_Impl(GetEventHandle_Impl&& other) = default;
      GetEventHandle_Impl& operator=(GetEventHandle_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class GetDriverLogFlags_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      GetDriverLogFlags_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
      ~GetDriverLogFlags_Impl() = default;
      GetDriverLogFlags_Impl(GetDriverLogFlags_Impl&& other) = default;
      GetDriverLogFlags_Impl& operator=(GetDriverLogFlags_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class SetDriverLogFlags_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      SetDriverLogFlags_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t clear_flags, uint32_t set_flags, ::fidl::BytePart _response_buffer);
      ~SetDriverLogFlags_Impl() = default;
      SetDriverLogFlags_Impl(SetDriverLogFlags_Impl&& other) = default;
      SetDriverLogFlags_Impl& operator=(SetDriverLogFlags_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class DebugResume_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      DebugResume_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
      ~DebugResume_Impl() = default;
      DebugResume_Impl(DebugResume_Impl&& other) = default;
      DebugResume_Impl& operator=(DebugResume_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class RunCompatibilityTests_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      RunCompatibilityTests_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int64_t hook_wait_time, ::fidl::BytePart _response_buffer);
      ~RunCompatibilityTests_Impl() = default;
      RunCompatibilityTests_Impl(RunCompatibilityTests_Impl&& other) = default;
      RunCompatibilityTests_Impl& operator=(RunCompatibilityTests_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class GetDevicePowerCaps_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      GetDevicePowerCaps_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
      ~GetDevicePowerCaps_Impl() = default;
      GetDevicePowerCaps_Impl(GetDevicePowerCaps_Impl&& other) = default;
      GetDevicePowerCaps_Impl& operator=(GetDevicePowerCaps_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class GetDevicePerformanceStates_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      GetDevicePerformanceStates_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
      ~GetDevicePerformanceStates_Impl() = default;
      GetDevicePerformanceStates_Impl(GetDevicePerformanceStates_Impl&& other) = default;
      GetDevicePerformanceStates_Impl& operator=(GetDevicePerformanceStates_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class UpdatePowerStateMapping_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      UpdatePowerStateMapping_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::Array<::llcpp::fuchsia::device::SystemPowerStateInfo, 7> mapping, ::fidl::BytePart _response_buffer);
      ~UpdatePowerStateMapping_Impl() = default;
      UpdatePowerStateMapping_Impl(UpdatePowerStateMapping_Impl&& other) = default;
      UpdatePowerStateMapping_Impl& operator=(UpdatePowerStateMapping_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class GetPowerStateMapping_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      GetPowerStateMapping_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
      ~GetPowerStateMapping_Impl() = default;
      GetPowerStateMapping_Impl(GetPowerStateMapping_Impl&& other) = default;
      GetPowerStateMapping_Impl& operator=(GetPowerStateMapping_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class Suspend_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      Suspend_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::DevicePowerState requested_state, ::fidl::BytePart _response_buffer);
      ~Suspend_Impl() = default;
      Suspend_Impl(Suspend_Impl&& other) = default;
      Suspend_Impl& operator=(Suspend_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class Resume_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      Resume_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::DevicePowerState requested_state, ::fidl::BytePart _response_buffer);
      ~Resume_Impl() = default;
      Resume_Impl(Resume_Impl&& other) = default;
      Resume_Impl& operator=(Resume_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class SetPerformanceState_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      SetPerformanceState_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t requested_state, ::fidl::BytePart _response_buffer);
      ~SetPerformanceState_Impl() = default;
      SetPerformanceState_Impl(SetPerformanceState_Impl&& other) = default;
      SetPerformanceState_Impl& operator=(SetPerformanceState_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    template <typename ResponseType>
    class ConfigureAutoSuspend_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      ConfigureAutoSuspend_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool enable, ::llcpp::fuchsia::device::DevicePowerState requested_deepest_sleep_state, ::fidl::BytePart _response_buffer);
      ~ConfigureAutoSuspend_Impl() = default;
      ConfigureAutoSuspend_Impl(ConfigureAutoSuspend_Impl&& other) = default;
      ConfigureAutoSuspend_Impl& operator=(ConfigureAutoSuspend_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };

   public:
    using Bind = Bind_Impl<BindResponse>;
    using Rebind = Rebind_Impl<RebindResponse>;
    using ScheduleUnbind = ScheduleUnbind_Impl<ScheduleUnbindResponse>;
    using GetDriverName = GetDriverName_Impl<GetDriverNameResponse>;
    using GetDeviceName = GetDeviceName_Impl<GetDeviceNameResponse>;
    using GetTopologicalPath = GetTopologicalPath_Impl<GetTopologicalPathResponse>;
    using GetEventHandle = GetEventHandle_Impl<GetEventHandleResponse>;
    using GetDriverLogFlags = GetDriverLogFlags_Impl<GetDriverLogFlagsResponse>;
    using SetDriverLogFlags = SetDriverLogFlags_Impl<SetDriverLogFlagsResponse>;
    using DebugResume = DebugResume_Impl<DebugResumeResponse>;
    using RunCompatibilityTests = RunCompatibilityTests_Impl<RunCompatibilityTestsResponse>;
    using GetDevicePowerCaps = GetDevicePowerCaps_Impl<GetDevicePowerCapsResponse>;
    using GetDevicePerformanceStates = GetDevicePerformanceStates_Impl<GetDevicePerformanceStatesResponse>;
    using UpdatePowerStateMapping = UpdatePowerStateMapping_Impl<UpdatePowerStateMappingResponse>;
    using GetPowerStateMapping = GetPowerStateMapping_Impl<GetPowerStateMappingResponse>;
    using Suspend = Suspend_Impl<SuspendResponse>;
    using Resume = Resume_Impl<ResumeResponse>;
    using SetPerformanceState = SetPerformanceState_Impl<SetPerformanceStateResponse>;
    using ConfigureAutoSuspend = ConfigureAutoSuspend_Impl<ConfigureAutoSuspendResponse>;
  };

  class SyncClient final {
   public:
    explicit SyncClient(::zx::channel channel) : channel_(std::move(channel)) {}
    ~SyncClient() = default;
    SyncClient(SyncClient&&) = default;
    SyncClient& operator=(SyncClient&&) = default;

    const ::zx::channel& channel() const { return channel_; }

    ::zx::channel* mutable_channel() { return &channel_; }

    // Attempt to bind the requested driver to this device
    // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated.
    ResultOf::Bind Bind(::fidl::StringView driver);

    // Attempt to bind the requested driver to this device
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::Bind Bind(::fidl::BytePart _request_buffer, ::fidl::StringView driver, ::fidl::BytePart _response_buffer);

    // This api will unbind all the children of this device and bind the
    // requested driver. If the driver is empty, it will autobind.
    // The Rebind will not return until the bind completes.
    // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated.
    ResultOf::Rebind Rebind(::fidl::StringView driver);

    // This api will unbind all the children of this device and bind the
    // requested driver. If the driver is empty, it will autobind.
    // The Rebind will not return until the bind completes.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::Rebind Rebind(::fidl::BytePart _request_buffer, ::fidl::StringView driver, ::fidl::BytePart _response_buffer);

    // Disconnect this device and allow its parent to be bound again.
    // This may not complete before it returns.
    // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::ScheduleUnbind ScheduleUnbind();

    // Disconnect this device and allow its parent to be bound again.
    // This may not complete before it returns.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::ScheduleUnbind ScheduleUnbind(::fidl::BytePart _response_buffer);

    // Return the name of the driver managing this the device
    // Allocates 88 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::GetDriverName GetDriverName();

    // Return the name of the driver managing this the device
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::GetDriverName GetDriverName(::fidl::BytePart _response_buffer);

    // Return the name of the device
    // Allocates 80 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::GetDeviceName GetDeviceName();

    // Return the name of the device
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::GetDeviceName GetDeviceName(::fidl::BytePart _response_buffer);

    // Return the topological path for this device
    // Allocates 16 bytes of request buffer on the stack. Response is heap-allocated.
    ResultOf::GetTopologicalPath GetTopologicalPath();

    // Return the topological path for this device
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::GetTopologicalPath GetTopologicalPath(::fidl::BytePart _response_buffer);

    // Get an event for monitoring device conditions (see `DEVICE_SIGNAL_*` constants)
    // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::GetEventHandle GetEventHandle();

    // Get an event for monitoring device conditions (see `DEVICE_SIGNAL_*` constants)
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::GetEventHandle GetEventHandle(::fidl::BytePart _response_buffer);

    // Return the current logging flags for this device's driver
    // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::GetDriverLogFlags GetDriverLogFlags();

    // Return the current logging flags for this device's driver
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::GetDriverLogFlags GetDriverLogFlags(::fidl::BytePart _response_buffer);

    // Set the logging flags for this device's driver.
    // Each set bit in `clear_flags` will be cleared in the log flags state.
    // Each set bit in `set_flags` will then be set in the log flags state.
    // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::SetDriverLogFlags SetDriverLogFlags(uint32_t clear_flags, uint32_t set_flags);

    // Set the logging flags for this device's driver.
    // Each set bit in `clear_flags` will be cleared in the log flags state.
    // Each set bit in `set_flags` will then be set in the log flags state.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::SetDriverLogFlags SetDriverLogFlags(::fidl::BytePart _request_buffer, uint32_t clear_flags, uint32_t set_flags, ::fidl::BytePart _response_buffer);

    // Debug command: execute the device's resume hook
    // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::DebugResume DebugResume();

    // Debug command: execute the device's resume hook
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::DebugResume DebugResume(::fidl::BytePart _response_buffer);

    // Runs compatibility tests for the driver that binds to this device.
    // The |hook_wait_time| is the time that the driver expects to take for
    // each device hook in nanoseconds.
    // Returns whether the driver passed the compatibility check.
    // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::RunCompatibilityTests RunCompatibilityTests(int64_t hook_wait_time);

    // Runs compatibility tests for the driver that binds to this device.
    // The |hook_wait_time| is the time that the driver expects to take for
    // each device hook in nanoseconds.
    // Returns whether the driver passed the compatibility check.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::RunCompatibilityTests RunCompatibilityTests(::fidl::BytePart _request_buffer, int64_t hook_wait_time, ::fidl::BytePart _response_buffer);

    // Gets the device power capabilities. Used by the system wide power manager
    // to manage power for this device.
    // Allocates 176 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::GetDevicePowerCaps GetDevicePowerCaps();

    // Gets the device power capabilities. Used by the system wide power manager
    // to manage power for this device.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::GetDevicePowerCaps GetDevicePowerCaps(::fidl::BytePart _response_buffer);

    // Gets the device performance states. Used by the system wide power manager
    // to manage power for this device.
    // Allocates 520 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::GetDevicePerformanceStates GetDevicePerformanceStates();

    // Gets the device performance states. Used by the system wide power manager
    // to manage power for this device.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::GetDevicePerformanceStates GetDevicePerformanceStates(::fidl::BytePart _response_buffer);

    // Updates the mapping between system power states to device power states. Used by the system
    // wide power manager to manage power for this device
    // Allocates 120 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::UpdatePowerStateMapping UpdatePowerStateMapping(::fidl::Array<::llcpp::fuchsia::device::SystemPowerStateInfo, 7> mapping);

    // Updates the mapping between system power states to device power states. Used by the system
    // wide power manager to manage power for this device
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::UpdatePowerStateMapping UpdatePowerStateMapping(::fidl::BytePart _request_buffer, ::fidl::Array<::llcpp::fuchsia::device::SystemPowerStateInfo, 7> mapping, ::fidl::BytePart _response_buffer);

    // Get the mapping between system power states to device power states. Used by the system
    // wide power manager to manage power for this device.
    // Allocates 112 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::GetPowerStateMapping GetPowerStateMapping();

    // Get the mapping between system power states to device power states. Used by the system
    // wide power manager to manage power for this device.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::GetPowerStateMapping GetPowerStateMapping(::fidl::BytePart _response_buffer);

    // Transition this device from a working to a sleep state or from a sleep state to a deeper sleep
    // state.
    // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::Suspend Suspend(::llcpp::fuchsia::device::DevicePowerState requested_state);

    // Transition this device from a working to a sleep state or from a sleep state to a deeper sleep
    // state.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::Suspend Suspend(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::DevicePowerState requested_state, ::fidl::BytePart _response_buffer);

    // Transition this device from a sleep state to a working state.
    // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::Resume Resume(::llcpp::fuchsia::device::DevicePowerState requested_state);

    // Transition this device from a sleep state to a working state.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::Resume Resume(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::DevicePowerState requested_state, ::fidl::BytePart _response_buffer);

    // Set the performance state of this device to the requested performance state. This is only
    // called for the current device and none of the descendants are aware of the state
    // transition.
    // On success, the out_state and the requested_state is same. If the device is in a working
    // state, the performance state will be changed to requested_state immediately. If the device
    // is in non-working state, the performance state will be the requested_state whenever the
    // device transitions to working state.
    // On failure, the out_state will have the state that the device can go into.
    // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::SetPerformanceState SetPerformanceState(uint32_t requested_state);

    // Set the performance state of this device to the requested performance state. This is only
    // called for the current device and none of the descendants are aware of the state
    // transition.
    // On success, the out_state and the requested_state is same. If the device is in a working
    // state, the performance state will be changed to requested_state immediately. If the device
    // is in non-working state, the performance state will be the requested_state whenever the
    // device transitions to working state.
    // On failure, the out_state will have the state that the device can go into.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::SetPerformanceState SetPerformanceState(::fidl::BytePart _request_buffer, uint32_t requested_state, ::fidl::BytePart _response_buffer);

    // Configure autosuspend of device to this deepest sleep state.
    // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::ConfigureAutoSuspend ConfigureAutoSuspend(bool enable, ::llcpp::fuchsia::device::DevicePowerState requested_deepest_sleep_state);

    // Configure autosuspend of device to this deepest sleep state.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::ConfigureAutoSuspend ConfigureAutoSuspend(::fidl::BytePart _request_buffer, bool enable, ::llcpp::fuchsia::device::DevicePowerState requested_deepest_sleep_state, ::fidl::BytePart _response_buffer);

   private:
    ::zx::channel channel_;
  };

  // Methods to make a sync FIDL call directly on an unowned channel, avoiding setting up a client.
  class Call final {
    Call() = delete;
   public:

    // Attempt to bind the requested driver to this device
    // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated.
    static ResultOf::Bind Bind(::zx::unowned_channel _client_end, ::fidl::StringView driver);

    // Attempt to bind the requested driver to this device
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::Bind Bind(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView driver, ::fidl::BytePart _response_buffer);

    // This api will unbind all the children of this device and bind the
    // requested driver. If the driver is empty, it will autobind.
    // The Rebind will not return until the bind completes.
    // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated.
    static ResultOf::Rebind Rebind(::zx::unowned_channel _client_end, ::fidl::StringView driver);

    // This api will unbind all the children of this device and bind the
    // requested driver. If the driver is empty, it will autobind.
    // The Rebind will not return until the bind completes.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::Rebind Rebind(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView driver, ::fidl::BytePart _response_buffer);

    // Disconnect this device and allow its parent to be bound again.
    // This may not complete before it returns.
    // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::ScheduleUnbind ScheduleUnbind(::zx::unowned_channel _client_end);

    // Disconnect this device and allow its parent to be bound again.
    // This may not complete before it returns.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::ScheduleUnbind ScheduleUnbind(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);

    // Return the name of the driver managing this the device
    // Allocates 88 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::GetDriverName GetDriverName(::zx::unowned_channel _client_end);

    // Return the name of the driver managing this the device
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::GetDriverName GetDriverName(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);

    // Return the name of the device
    // Allocates 80 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::GetDeviceName GetDeviceName(::zx::unowned_channel _client_end);

    // Return the name of the device
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::GetDeviceName GetDeviceName(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);

    // Return the topological path for this device
    // Allocates 16 bytes of request buffer on the stack. Response is heap-allocated.
    static ResultOf::GetTopologicalPath GetTopologicalPath(::zx::unowned_channel _client_end);

    // Return the topological path for this device
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::GetTopologicalPath GetTopologicalPath(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);

    // Get an event for monitoring device conditions (see `DEVICE_SIGNAL_*` constants)
    // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::GetEventHandle GetEventHandle(::zx::unowned_channel _client_end);

    // Get an event for monitoring device conditions (see `DEVICE_SIGNAL_*` constants)
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::GetEventHandle GetEventHandle(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);

    // Return the current logging flags for this device's driver
    // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::GetDriverLogFlags GetDriverLogFlags(::zx::unowned_channel _client_end);

    // Return the current logging flags for this device's driver
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::GetDriverLogFlags GetDriverLogFlags(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);

    // Set the logging flags for this device's driver.
    // Each set bit in `clear_flags` will be cleared in the log flags state.
    // Each set bit in `set_flags` will then be set in the log flags state.
    // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::SetDriverLogFlags SetDriverLogFlags(::zx::unowned_channel _client_end, uint32_t clear_flags, uint32_t set_flags);

    // Set the logging flags for this device's driver.
    // Each set bit in `clear_flags` will be cleared in the log flags state.
    // Each set bit in `set_flags` will then be set in the log flags state.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::SetDriverLogFlags SetDriverLogFlags(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t clear_flags, uint32_t set_flags, ::fidl::BytePart _response_buffer);

    // Debug command: execute the device's resume hook
    // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::DebugResume DebugResume(::zx::unowned_channel _client_end);

    // Debug command: execute the device's resume hook
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::DebugResume DebugResume(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);

    // Runs compatibility tests for the driver that binds to this device.
    // The |hook_wait_time| is the time that the driver expects to take for
    // each device hook in nanoseconds.
    // Returns whether the driver passed the compatibility check.
    // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::RunCompatibilityTests RunCompatibilityTests(::zx::unowned_channel _client_end, int64_t hook_wait_time);

    // Runs compatibility tests for the driver that binds to this device.
    // The |hook_wait_time| is the time that the driver expects to take for
    // each device hook in nanoseconds.
    // Returns whether the driver passed the compatibility check.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::RunCompatibilityTests RunCompatibilityTests(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int64_t hook_wait_time, ::fidl::BytePart _response_buffer);

    // Gets the device power capabilities. Used by the system wide power manager
    // to manage power for this device.
    // Allocates 176 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::GetDevicePowerCaps GetDevicePowerCaps(::zx::unowned_channel _client_end);

    // Gets the device power capabilities. Used by the system wide power manager
    // to manage power for this device.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::GetDevicePowerCaps GetDevicePowerCaps(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);

    // Gets the device performance states. Used by the system wide power manager
    // to manage power for this device.
    // Allocates 520 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::GetDevicePerformanceStates GetDevicePerformanceStates(::zx::unowned_channel _client_end);

    // Gets the device performance states. Used by the system wide power manager
    // to manage power for this device.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::GetDevicePerformanceStates GetDevicePerformanceStates(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);

    // Updates the mapping between system power states to device power states. Used by the system
    // wide power manager to manage power for this device
    // Allocates 120 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::UpdatePowerStateMapping UpdatePowerStateMapping(::zx::unowned_channel _client_end, ::fidl::Array<::llcpp::fuchsia::device::SystemPowerStateInfo, 7> mapping);

    // Updates the mapping between system power states to device power states. Used by the system
    // wide power manager to manage power for this device
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::UpdatePowerStateMapping UpdatePowerStateMapping(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::Array<::llcpp::fuchsia::device::SystemPowerStateInfo, 7> mapping, ::fidl::BytePart _response_buffer);

    // Get the mapping between system power states to device power states. Used by the system
    // wide power manager to manage power for this device.
    // Allocates 112 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::GetPowerStateMapping GetPowerStateMapping(::zx::unowned_channel _client_end);

    // Get the mapping between system power states to device power states. Used by the system
    // wide power manager to manage power for this device.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::GetPowerStateMapping GetPowerStateMapping(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);

    // Transition this device from a working to a sleep state or from a sleep state to a deeper sleep
    // state.
    // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::Suspend Suspend(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::DevicePowerState requested_state);

    // Transition this device from a working to a sleep state or from a sleep state to a deeper sleep
    // state.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::Suspend Suspend(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::DevicePowerState requested_state, ::fidl::BytePart _response_buffer);

    // Transition this device from a sleep state to a working state.
    // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::Resume Resume(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::DevicePowerState requested_state);

    // Transition this device from a sleep state to a working state.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::Resume Resume(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::DevicePowerState requested_state, ::fidl::BytePart _response_buffer);

    // Set the performance state of this device to the requested performance state. This is only
    // called for the current device and none of the descendants are aware of the state
    // transition.
    // On success, the out_state and the requested_state is same. If the device is in a working
    // state, the performance state will be changed to requested_state immediately. If the device
    // is in non-working state, the performance state will be the requested_state whenever the
    // device transitions to working state.
    // On failure, the out_state will have the state that the device can go into.
    // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::SetPerformanceState SetPerformanceState(::zx::unowned_channel _client_end, uint32_t requested_state);

    // Set the performance state of this device to the requested performance state. This is only
    // called for the current device and none of the descendants are aware of the state
    // transition.
    // On success, the out_state and the requested_state is same. If the device is in a working
    // state, the performance state will be changed to requested_state immediately. If the device
    // is in non-working state, the performance state will be the requested_state whenever the
    // device transitions to working state.
    // On failure, the out_state will have the state that the device can go into.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::SetPerformanceState SetPerformanceState(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t requested_state, ::fidl::BytePart _response_buffer);

    // Configure autosuspend of device to this deepest sleep state.
    // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::ConfigureAutoSuspend ConfigureAutoSuspend(::zx::unowned_channel _client_end, bool enable, ::llcpp::fuchsia::device::DevicePowerState requested_deepest_sleep_state);

    // Configure autosuspend of device to this deepest sleep state.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::ConfigureAutoSuspend ConfigureAutoSuspend(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool enable, ::llcpp::fuchsia::device::DevicePowerState requested_deepest_sleep_state, ::fidl::BytePart _response_buffer);

  };

  // Messages are encoded and decoded in-place when these methods are used.
  // Additionally, requests must be already laid-out according to the FIDL wire-format.
  class InPlace final {
    InPlace() = delete;
   public:

    // Attempt to bind the requested driver to this device
    static ::fidl::DecodeResult<BindResponse> Bind(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<BindRequest> params, ::fidl::BytePart response_buffer);

    // This api will unbind all the children of this device and bind the
    // requested driver. If the driver is empty, it will autobind.
    // The Rebind will not return until the bind completes.
    static ::fidl::DecodeResult<RebindResponse> Rebind(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<RebindRequest> params, ::fidl::BytePart response_buffer);

    // Disconnect this device and allow its parent to be bound again.
    // This may not complete before it returns.
    static ::fidl::DecodeResult<ScheduleUnbindResponse> ScheduleUnbind(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);

    // Return the name of the driver managing this the device
    static ::fidl::DecodeResult<GetDriverNameResponse> GetDriverName(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);

    // Return the name of the device
    static ::fidl::DecodeResult<GetDeviceNameResponse> GetDeviceName(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);

    // Return the topological path for this device
    static ::fidl::DecodeResult<GetTopologicalPathResponse> GetTopologicalPath(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);

    // Get an event for monitoring device conditions (see `DEVICE_SIGNAL_*` constants)
    static ::fidl::DecodeResult<GetEventHandleResponse> GetEventHandle(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);

    // Return the current logging flags for this device's driver
    static ::fidl::DecodeResult<GetDriverLogFlagsResponse> GetDriverLogFlags(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);

    // Set the logging flags for this device's driver.
    // Each set bit in `clear_flags` will be cleared in the log flags state.
    // Each set bit in `set_flags` will then be set in the log flags state.
    static ::fidl::DecodeResult<SetDriverLogFlagsResponse> SetDriverLogFlags(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetDriverLogFlagsRequest> params, ::fidl::BytePart response_buffer);

    // Debug command: execute the device's resume hook
    static ::fidl::DecodeResult<DebugResumeResponse> DebugResume(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);

    // Runs compatibility tests for the driver that binds to this device.
    // The |hook_wait_time| is the time that the driver expects to take for
    // each device hook in nanoseconds.
    // Returns whether the driver passed the compatibility check.
    static ::fidl::DecodeResult<RunCompatibilityTestsResponse> RunCompatibilityTests(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<RunCompatibilityTestsRequest> params, ::fidl::BytePart response_buffer);

    // Gets the device power capabilities. Used by the system wide power manager
    // to manage power for this device.
    static ::fidl::DecodeResult<GetDevicePowerCapsResponse> GetDevicePowerCaps(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);

    // Gets the device performance states. Used by the system wide power manager
    // to manage power for this device.
    static ::fidl::DecodeResult<GetDevicePerformanceStatesResponse> GetDevicePerformanceStates(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);

    // Updates the mapping between system power states to device power states. Used by the system
    // wide power manager to manage power for this device
    static ::fidl::DecodeResult<UpdatePowerStateMappingResponse> UpdatePowerStateMapping(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<UpdatePowerStateMappingRequest> params, ::fidl::BytePart response_buffer);

    // Get the mapping between system power states to device power states. Used by the system
    // wide power manager to manage power for this device.
    static ::fidl::DecodeResult<GetPowerStateMappingResponse> GetPowerStateMapping(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);

    // Transition this device from a working to a sleep state or from a sleep state to a deeper sleep
    // state.
    static ::fidl::DecodeResult<SuspendResponse> Suspend(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SuspendRequest> params, ::fidl::BytePart response_buffer);

    // Transition this device from a sleep state to a working state.
    static ::fidl::DecodeResult<ResumeResponse> Resume(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ResumeRequest> params, ::fidl::BytePart response_buffer);

    // Set the performance state of this device to the requested performance state. This is only
    // called for the current device and none of the descendants are aware of the state
    // transition.
    // On success, the out_state and the requested_state is same. If the device is in a working
    // state, the performance state will be changed to requested_state immediately. If the device
    // is in non-working state, the performance state will be the requested_state whenever the
    // device transitions to working state.
    // On failure, the out_state will have the state that the device can go into.
    static ::fidl::DecodeResult<SetPerformanceStateResponse> SetPerformanceState(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetPerformanceStateRequest> params, ::fidl::BytePart response_buffer);

    // Configure autosuspend of device to this deepest sleep state.
    static ::fidl::DecodeResult<ConfigureAutoSuspendResponse> ConfigureAutoSuspend(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ConfigureAutoSuspendRequest> params, ::fidl::BytePart response_buffer);

  };

  // Pure-virtual interface to be implemented by a server.
  class Interface {
   public:
    Interface() = default;
    virtual ~Interface() = default;
    using _Outer = Controller;
    using _Base = ::fidl::CompleterBase;

    class BindCompleterBase : public _Base {
     public:
      void Reply(::llcpp::fuchsia::device::Controller_Bind_Result result);
      void ReplySuccess();
      void ReplyError(int32_t error);
      void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::Controller_Bind_Result result);
      void ReplySuccess(::fidl::BytePart _buffer);
      void Reply(::fidl::DecodedMessage<BindResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using BindCompleter = ::fidl::Completer<BindCompleterBase>;

    virtual void Bind(::fidl::StringView driver, BindCompleter::Sync _completer) = 0;

    class RebindCompleterBase : public _Base {
     public:
      void Reply(::llcpp::fuchsia::device::Controller_Rebind_Result result);
      void ReplySuccess();
      void ReplyError(int32_t error);
      void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::Controller_Rebind_Result result);
      void ReplySuccess(::fidl::BytePart _buffer);
      void Reply(::fidl::DecodedMessage<RebindResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using RebindCompleter = ::fidl::Completer<RebindCompleterBase>;

    virtual void Rebind(::fidl::StringView driver, RebindCompleter::Sync _completer) = 0;

    class ScheduleUnbindCompleterBase : public _Base {
     public:
      void Reply(::llcpp::fuchsia::device::Controller_ScheduleUnbind_Result result);
      void ReplySuccess();
      void ReplyError(int32_t error);
      void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::Controller_ScheduleUnbind_Result result);
      void ReplySuccess(::fidl::BytePart _buffer);
      void Reply(::fidl::DecodedMessage<ScheduleUnbindResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using ScheduleUnbindCompleter = ::fidl::Completer<ScheduleUnbindCompleterBase>;

    virtual void ScheduleUnbind(ScheduleUnbindCompleter::Sync _completer) = 0;

    class GetDriverNameCompleterBase : public _Base {
     public:
      void Reply(int32_t status, ::fidl::StringView name);
      void Reply(::fidl::BytePart _buffer, int32_t status, ::fidl::StringView name);
      void Reply(::fidl::DecodedMessage<GetDriverNameResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using GetDriverNameCompleter = ::fidl::Completer<GetDriverNameCompleterBase>;

    virtual void GetDriverName(GetDriverNameCompleter::Sync _completer) = 0;

    class GetDeviceNameCompleterBase : public _Base {
     public:
      void Reply(::fidl::StringView name);
      void Reply(::fidl::BytePart _buffer, ::fidl::StringView name);
      void Reply(::fidl::DecodedMessage<GetDeviceNameResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using GetDeviceNameCompleter = ::fidl::Completer<GetDeviceNameCompleterBase>;

    virtual void GetDeviceName(GetDeviceNameCompleter::Sync _completer) = 0;

    class GetTopologicalPathCompleterBase : public _Base {
     public:
      void Reply(::llcpp::fuchsia::device::Controller_GetTopologicalPath_Result result);
      void ReplySuccess(::fidl::StringView path);
      void ReplyError(int32_t error);
      void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::Controller_GetTopologicalPath_Result result);
      void ReplySuccess(::fidl::BytePart _buffer, ::fidl::StringView path);
      void Reply(::fidl::DecodedMessage<GetTopologicalPathResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using GetTopologicalPathCompleter = ::fidl::Completer<GetTopologicalPathCompleterBase>;

    virtual void GetTopologicalPath(GetTopologicalPathCompleter::Sync _completer) = 0;

    class GetEventHandleCompleterBase : public _Base {
     public:
      void Reply(int32_t status, ::zx::event event);
      void Reply(::fidl::BytePart _buffer, int32_t status, ::zx::event event);
      void Reply(::fidl::DecodedMessage<GetEventHandleResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using GetEventHandleCompleter = ::fidl::Completer<GetEventHandleCompleterBase>;

    virtual void GetEventHandle(GetEventHandleCompleter::Sync _completer) = 0;

    class GetDriverLogFlagsCompleterBase : public _Base {
     public:
      void Reply(int32_t status, uint32_t flags);
      void Reply(::fidl::BytePart _buffer, int32_t status, uint32_t flags);
      void Reply(::fidl::DecodedMessage<GetDriverLogFlagsResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using GetDriverLogFlagsCompleter = ::fidl::Completer<GetDriverLogFlagsCompleterBase>;

    virtual void GetDriverLogFlags(GetDriverLogFlagsCompleter::Sync _completer) = 0;

    class SetDriverLogFlagsCompleterBase : public _Base {
     public:
      void Reply(int32_t status);
      void Reply(::fidl::BytePart _buffer, int32_t status);
      void Reply(::fidl::DecodedMessage<SetDriverLogFlagsResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using SetDriverLogFlagsCompleter = ::fidl::Completer<SetDriverLogFlagsCompleterBase>;

    virtual void SetDriverLogFlags(uint32_t clear_flags, uint32_t set_flags, SetDriverLogFlagsCompleter::Sync _completer) = 0;

    class DebugResumeCompleterBase : public _Base {
     public:
      void Reply(int32_t status);
      void Reply(::fidl::BytePart _buffer, int32_t status);
      void Reply(::fidl::DecodedMessage<DebugResumeResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using DebugResumeCompleter = ::fidl::Completer<DebugResumeCompleterBase>;

    virtual void DebugResume(DebugResumeCompleter::Sync _completer) = 0;

    class RunCompatibilityTestsCompleterBase : public _Base {
     public:
      void Reply(uint32_t status);
      void Reply(::fidl::BytePart _buffer, uint32_t status);
      void Reply(::fidl::DecodedMessage<RunCompatibilityTestsResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using RunCompatibilityTestsCompleter = ::fidl::Completer<RunCompatibilityTestsCompleterBase>;

    virtual void RunCompatibilityTests(int64_t hook_wait_time, RunCompatibilityTestsCompleter::Sync _completer) = 0;

    class GetDevicePowerCapsCompleterBase : public _Base {
     public:
      void Reply(::llcpp::fuchsia::device::Controller_GetDevicePowerCaps_Result result);
      void ReplySuccess(::fidl::Array<::llcpp::fuchsia::device::DevicePowerStateInfo, 5> dpstates);
      void ReplyError(int32_t error);
      void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::Controller_GetDevicePowerCaps_Result result);
      void ReplySuccess(::fidl::BytePart _buffer, ::fidl::Array<::llcpp::fuchsia::device::DevicePowerStateInfo, 5> dpstates);
      void Reply(::fidl::DecodedMessage<GetDevicePowerCapsResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using GetDevicePowerCapsCompleter = ::fidl::Completer<GetDevicePowerCapsCompleterBase>;

    virtual void GetDevicePowerCaps(GetDevicePowerCapsCompleter::Sync _completer) = 0;

    class GetDevicePerformanceStatesCompleterBase : public _Base {
     public:
      void Reply(::fidl::Array<::llcpp::fuchsia::device::DevicePerformanceStateInfo, 20> states, int32_t status);
      void Reply(::fidl::BytePart _buffer, ::fidl::Array<::llcpp::fuchsia::device::DevicePerformanceStateInfo, 20> states, int32_t status);
      void Reply(::fidl::DecodedMessage<GetDevicePerformanceStatesResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using GetDevicePerformanceStatesCompleter = ::fidl::Completer<GetDevicePerformanceStatesCompleterBase>;

    virtual void GetDevicePerformanceStates(GetDevicePerformanceStatesCompleter::Sync _completer) = 0;

    class UpdatePowerStateMappingCompleterBase : public _Base {
     public:
      void Reply(::llcpp::fuchsia::device::Controller_UpdatePowerStateMapping_Result result);
      void ReplySuccess();
      void ReplyError(int32_t error);
      void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::Controller_UpdatePowerStateMapping_Result result);
      void ReplySuccess(::fidl::BytePart _buffer);
      void Reply(::fidl::DecodedMessage<UpdatePowerStateMappingResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using UpdatePowerStateMappingCompleter = ::fidl::Completer<UpdatePowerStateMappingCompleterBase>;

    virtual void UpdatePowerStateMapping(::fidl::Array<::llcpp::fuchsia::device::SystemPowerStateInfo, 7> mapping, UpdatePowerStateMappingCompleter::Sync _completer) = 0;

    class GetPowerStateMappingCompleterBase : public _Base {
     public:
      void Reply(::llcpp::fuchsia::device::Controller_GetPowerStateMapping_Result result);
      void ReplySuccess(::fidl::Array<::llcpp::fuchsia::device::SystemPowerStateInfo, 7> mapping);
      void ReplyError(int32_t error);
      void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::Controller_GetPowerStateMapping_Result result);
      void ReplySuccess(::fidl::BytePart _buffer, ::fidl::Array<::llcpp::fuchsia::device::SystemPowerStateInfo, 7> mapping);
      void Reply(::fidl::DecodedMessage<GetPowerStateMappingResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using GetPowerStateMappingCompleter = ::fidl::Completer<GetPowerStateMappingCompleterBase>;

    virtual void GetPowerStateMapping(GetPowerStateMappingCompleter::Sync _completer) = 0;

    class SuspendCompleterBase : public _Base {
     public:
      void Reply(int32_t status, ::llcpp::fuchsia::device::DevicePowerState out_state);
      void Reply(::fidl::BytePart _buffer, int32_t status, ::llcpp::fuchsia::device::DevicePowerState out_state);
      void Reply(::fidl::DecodedMessage<SuspendResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using SuspendCompleter = ::fidl::Completer<SuspendCompleterBase>;

    virtual void Suspend(::llcpp::fuchsia::device::DevicePowerState requested_state, SuspendCompleter::Sync _completer) = 0;

    class ResumeCompleterBase : public _Base {
     public:
      void Reply(::llcpp::fuchsia::device::Controller_Resume_Result result);
      void ReplySuccess(::llcpp::fuchsia::device::DevicePowerState out_state);
      void ReplyError(int32_t error);
      void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::Controller_Resume_Result result);
      void ReplySuccess(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::DevicePowerState out_state);
      void Reply(::fidl::DecodedMessage<ResumeResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using ResumeCompleter = ::fidl::Completer<ResumeCompleterBase>;

    virtual void Resume(::llcpp::fuchsia::device::DevicePowerState requested_state, ResumeCompleter::Sync _completer) = 0;

    class SetPerformanceStateCompleterBase : public _Base {
     public:
      void Reply(int32_t status, uint32_t out_state);
      void Reply(::fidl::BytePart _buffer, int32_t status, uint32_t out_state);
      void Reply(::fidl::DecodedMessage<SetPerformanceStateResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using SetPerformanceStateCompleter = ::fidl::Completer<SetPerformanceStateCompleterBase>;

    virtual void SetPerformanceState(uint32_t requested_state, SetPerformanceStateCompleter::Sync _completer) = 0;

    class ConfigureAutoSuspendCompleterBase : public _Base {
     public:
      void Reply(int32_t status);
      void Reply(::fidl::BytePart _buffer, int32_t status);
      void Reply(::fidl::DecodedMessage<ConfigureAutoSuspendResponse> params);

     protected:
      using ::fidl::CompleterBase::CompleterBase;
    };

    using ConfigureAutoSuspendCompleter = ::fidl::Completer<ConfigureAutoSuspendCompleterBase>;

    virtual void ConfigureAutoSuspend(bool enable, ::llcpp::fuchsia::device::DevicePowerState requested_deepest_sleep_state, ConfigureAutoSuspendCompleter::Sync _completer) = 0;

  };

  // Attempts to dispatch the incoming message to a handler function in the server implementation.
  // If there is no matching handler, it returns false, leaving the message and transaction intact.
  // In all other cases, it consumes the message and returns true.
  // It is possible to chain multiple TryDispatch functions in this manner.
  static bool TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn);

  // Dispatches the incoming message to one of the handlers functions in the interface.
  // If there is no matching handler, it closes all the handles in |msg| and closes the channel with
  // a |ZX_ERR_NOT_SUPPORTED| epitaph, before returning false. The message should then be discarded.
  static bool Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn);

  // Same as |Dispatch|, but takes a |void*| instead of |Interface*|. Only used with |fidl::Bind|
  // to reduce template expansion.
  // Do not call this method manually. Use |Dispatch| instead.
  static bool TypeErasedDispatch(void* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
    return Dispatch(static_cast<Interface*>(impl), msg, txn);
  }


  // Helper functions to fill in the transaction header in a |DecodedMessage<TransactionalMessage>|.
  class SetTransactionHeaderFor final {
    SetTransactionHeaderFor() = delete;
   public:
    static void BindRequest(const ::fidl::DecodedMessage<Controller::BindRequest>& _msg);
    static void BindResponse(const ::fidl::DecodedMessage<Controller::BindResponse>& _msg);
    static void RebindRequest(const ::fidl::DecodedMessage<Controller::RebindRequest>& _msg);
    static void RebindResponse(const ::fidl::DecodedMessage<Controller::RebindResponse>& _msg);
    static void ScheduleUnbindRequest(const ::fidl::DecodedMessage<Controller::ScheduleUnbindRequest>& _msg);
    static void ScheduleUnbindResponse(const ::fidl::DecodedMessage<Controller::ScheduleUnbindResponse>& _msg);
    static void GetDriverNameRequest(const ::fidl::DecodedMessage<Controller::GetDriverNameRequest>& _msg);
    static void GetDriverNameResponse(const ::fidl::DecodedMessage<Controller::GetDriverNameResponse>& _msg);
    static void GetDeviceNameRequest(const ::fidl::DecodedMessage<Controller::GetDeviceNameRequest>& _msg);
    static void GetDeviceNameResponse(const ::fidl::DecodedMessage<Controller::GetDeviceNameResponse>& _msg);
    static void GetTopologicalPathRequest(const ::fidl::DecodedMessage<Controller::GetTopologicalPathRequest>& _msg);
    static void GetTopologicalPathResponse(const ::fidl::DecodedMessage<Controller::GetTopologicalPathResponse>& _msg);
    static void GetEventHandleRequest(const ::fidl::DecodedMessage<Controller::GetEventHandleRequest>& _msg);
    static void GetEventHandleResponse(const ::fidl::DecodedMessage<Controller::GetEventHandleResponse>& _msg);
    static void GetDriverLogFlagsRequest(const ::fidl::DecodedMessage<Controller::GetDriverLogFlagsRequest>& _msg);
    static void GetDriverLogFlagsResponse(const ::fidl::DecodedMessage<Controller::GetDriverLogFlagsResponse>& _msg);
    static void SetDriverLogFlagsRequest(const ::fidl::DecodedMessage<Controller::SetDriverLogFlagsRequest>& _msg);
    static void SetDriverLogFlagsResponse(const ::fidl::DecodedMessage<Controller::SetDriverLogFlagsResponse>& _msg);
    static void DebugResumeRequest(const ::fidl::DecodedMessage<Controller::DebugResumeRequest>& _msg);
    static void DebugResumeResponse(const ::fidl::DecodedMessage<Controller::DebugResumeResponse>& _msg);
    static void RunCompatibilityTestsRequest(const ::fidl::DecodedMessage<Controller::RunCompatibilityTestsRequest>& _msg);
    static void RunCompatibilityTestsResponse(const ::fidl::DecodedMessage<Controller::RunCompatibilityTestsResponse>& _msg);
    static void GetDevicePowerCapsRequest(const ::fidl::DecodedMessage<Controller::GetDevicePowerCapsRequest>& _msg);
    static void GetDevicePowerCapsResponse(const ::fidl::DecodedMessage<Controller::GetDevicePowerCapsResponse>& _msg);
    static void GetDevicePerformanceStatesRequest(const ::fidl::DecodedMessage<Controller::GetDevicePerformanceStatesRequest>& _msg);
    static void GetDevicePerformanceStatesResponse(const ::fidl::DecodedMessage<Controller::GetDevicePerformanceStatesResponse>& _msg);
    static void UpdatePowerStateMappingRequest(const ::fidl::DecodedMessage<Controller::UpdatePowerStateMappingRequest>& _msg);
    static void UpdatePowerStateMappingResponse(const ::fidl::DecodedMessage<Controller::UpdatePowerStateMappingResponse>& _msg);
    static void GetPowerStateMappingRequest(const ::fidl::DecodedMessage<Controller::GetPowerStateMappingRequest>& _msg);
    static void GetPowerStateMappingResponse(const ::fidl::DecodedMessage<Controller::GetPowerStateMappingResponse>& _msg);
    static void SuspendRequest(const ::fidl::DecodedMessage<Controller::SuspendRequest>& _msg);
    static void SuspendResponse(const ::fidl::DecodedMessage<Controller::SuspendResponse>& _msg);
    static void ResumeRequest(const ::fidl::DecodedMessage<Controller::ResumeRequest>& _msg);
    static void ResumeResponse(const ::fidl::DecodedMessage<Controller::ResumeResponse>& _msg);
    static void SetPerformanceStateRequest(const ::fidl::DecodedMessage<Controller::SetPerformanceStateRequest>& _msg);
    static void SetPerformanceStateResponse(const ::fidl::DecodedMessage<Controller::SetPerformanceStateResponse>& _msg);
    static void ConfigureAutoSuspendRequest(const ::fidl::DecodedMessage<Controller::ConfigureAutoSuspendRequest>& _msg);
    static void ConfigureAutoSuspendResponse(const ::fidl::DecodedMessage<Controller::ConfigureAutoSuspendResponse>& _msg);
  };
};

}  // namespace device
}  // namespace fuchsia
}  // namespace llcpp

namespace fidl {

template <>
struct IsFidlType<::llcpp::fuchsia::device::NameProvider_GetDeviceName_Response> : public std::true_type {};
static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::NameProvider_GetDeviceName_Response>);
static_assert(offsetof(::llcpp::fuchsia::device::NameProvider_GetDeviceName_Response, name) == 0);
static_assert(sizeof(::llcpp::fuchsia::device::NameProvider_GetDeviceName_Response) == ::llcpp::fuchsia::device::NameProvider_GetDeviceName_Response::PrimarySize);

template <>
struct IsFidlType<::llcpp::fuchsia::device::NameProvider_GetDeviceName_Result> : public std::true_type {};
static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::NameProvider_GetDeviceName_Result>);

template <>
struct IsFidlType<::llcpp::fuchsia::device::NameProvider::GetDeviceNameResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::device::NameProvider::GetDeviceNameResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::device::NameProvider::GetDeviceNameResponse)
    == ::llcpp::fuchsia::device::NameProvider::GetDeviceNameResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::device::NameProvider::GetDeviceNameResponse, result) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::device::SystemPowerStateInfo> : public std::true_type {};
static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::SystemPowerStateInfo>);
static_assert(offsetof(::llcpp::fuchsia::device::SystemPowerStateInfo, suspend_flag) == 0);
static_assert(offsetof(::llcpp::fuchsia::device::SystemPowerStateInfo, wakeup_enable) == 4);
static_assert(offsetof(::llcpp::fuchsia::device::SystemPowerStateInfo, dev_state) == 5);
static_assert(sizeof(::llcpp::fuchsia::device::SystemPowerStateInfo) == ::llcpp::fuchsia::device::SystemPowerStateInfo::PrimarySize);

template <>
struct IsFidlType<::llcpp::fuchsia::device::Controller_GetPowerStateMapping_Response> : public std::true_type {};
static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::Controller_GetPowerStateMapping_Response>);
static_assert(offsetof(::llcpp::fuchsia::device::Controller_GetPowerStateMapping_Response, mapping) == 0);
static_assert(sizeof(::llcpp::fuchsia::device::Controller_GetPowerStateMapping_Response) == ::llcpp::fuchsia::device::Controller_GetPowerStateMapping_Response::PrimarySize);

template <>
struct IsFidlType<::llcpp::fuchsia::device::Controller_GetPowerStateMapping_Result> : public std::true_type {};
static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::Controller_GetPowerStateMapping_Result>);

template <>
struct IsFidlType<::llcpp::fuchsia::device::DevicePowerStateInfo> : public std::true_type {};
static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::DevicePowerStateInfo>);
static_assert(offsetof(::llcpp::fuchsia::device::DevicePowerStateInfo, state_id) == 0);
static_assert(offsetof(::llcpp::fuchsia::device::DevicePowerStateInfo, is_supported) == 1);
static_assert(offsetof(::llcpp::fuchsia::device::DevicePowerStateInfo, restore_latency) == 8);
static_assert(offsetof(::llcpp::fuchsia::device::DevicePowerStateInfo, wakeup_capable) == 16);
static_assert(offsetof(::llcpp::fuchsia::device::DevicePowerStateInfo, system_wake_state) == 20);
static_assert(sizeof(::llcpp::fuchsia::device::DevicePowerStateInfo) == ::llcpp::fuchsia::device::DevicePowerStateInfo::PrimarySize);

template <>
struct IsFidlType<::llcpp::fuchsia::device::Controller_GetDevicePowerCaps_Response> : public std::true_type {};
static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::Controller_GetDevicePowerCaps_Response>);
static_assert(offsetof(::llcpp::fuchsia::device::Controller_GetDevicePowerCaps_Response, dpstates) == 0);
static_assert(sizeof(::llcpp::fuchsia::device::Controller_GetDevicePowerCaps_Response) == ::llcpp::fuchsia::device::Controller_GetDevicePowerCaps_Response::PrimarySize);

template <>
struct IsFidlType<::llcpp::fuchsia::device::Controller_GetDevicePowerCaps_Result> : public std::true_type {};
static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::Controller_GetDevicePowerCaps_Result>);

template <>
struct IsFidlType<::llcpp::fuchsia::device::Controller_Resume_Response> : public std::true_type {};
static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::Controller_Resume_Response>);
static_assert(offsetof(::llcpp::fuchsia::device::Controller_Resume_Response, out_state) == 0);
static_assert(sizeof(::llcpp::fuchsia::device::Controller_Resume_Response) == ::llcpp::fuchsia::device::Controller_Resume_Response::PrimarySize);

template <>
struct IsFidlType<::llcpp::fuchsia::device::Controller_Resume_Result> : public std::true_type {};
static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::Controller_Resume_Result>);

template <>
struct IsFidlType<::llcpp::fuchsia::device::DevicePerformanceStateInfo> : public std::true_type {};
static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::DevicePerformanceStateInfo>);
static_assert(offsetof(::llcpp::fuchsia::device::DevicePerformanceStateInfo, state_id) == 0);
static_assert(offsetof(::llcpp::fuchsia::device::DevicePerformanceStateInfo, restore_latency) == 8);
static_assert(offsetof(::llcpp::fuchsia::device::DevicePerformanceStateInfo, is_supported) == 16);
static_assert(sizeof(::llcpp::fuchsia::device::DevicePerformanceStateInfo) == ::llcpp::fuchsia::device::DevicePerformanceStateInfo::PrimarySize);

template <>
struct IsFidlType<::llcpp::fuchsia::device::Controller_UpdatePowerStateMapping_Response> : public std::true_type {};
static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::Controller_UpdatePowerStateMapping_Response>);
static_assert(offsetof(::llcpp::fuchsia::device::Controller_UpdatePowerStateMapping_Response, __reserved) == 0);
static_assert(sizeof(::llcpp::fuchsia::device::Controller_UpdatePowerStateMapping_Response) == ::llcpp::fuchsia::device::Controller_UpdatePowerStateMapping_Response::PrimarySize);

template <>
struct IsFidlType<::llcpp::fuchsia::device::Controller_UpdatePowerStateMapping_Result> : public std::true_type {};
static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::Controller_UpdatePowerStateMapping_Result>);

template <>
struct IsFidlType<::llcpp::fuchsia::device::Controller_ScheduleUnbind_Response> : public std::true_type {};
static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::Controller_ScheduleUnbind_Response>);
static_assert(offsetof(::llcpp::fuchsia::device::Controller_ScheduleUnbind_Response, __reserved) == 0);
static_assert(sizeof(::llcpp::fuchsia::device::Controller_ScheduleUnbind_Response) == ::llcpp::fuchsia::device::Controller_ScheduleUnbind_Response::PrimarySize);

template <>
struct IsFidlType<::llcpp::fuchsia::device::Controller_ScheduleUnbind_Result> : public std::true_type {};
static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::Controller_ScheduleUnbind_Result>);

template <>
struct IsFidlType<::llcpp::fuchsia::device::Controller_Rebind_Response> : public std::true_type {};
static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::Controller_Rebind_Response>);
static_assert(offsetof(::llcpp::fuchsia::device::Controller_Rebind_Response, __reserved) == 0);
static_assert(sizeof(::llcpp::fuchsia::device::Controller_Rebind_Response) == ::llcpp::fuchsia::device::Controller_Rebind_Response::PrimarySize);

template <>
struct IsFidlType<::llcpp::fuchsia::device::Controller_Rebind_Result> : public std::true_type {};
static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::Controller_Rebind_Result>);

template <>
struct IsFidlType<::llcpp::fuchsia::device::Controller_GetTopologicalPath_Response> : public std::true_type {};
static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::Controller_GetTopologicalPath_Response>);
static_assert(offsetof(::llcpp::fuchsia::device::Controller_GetTopologicalPath_Response, path) == 0);
static_assert(sizeof(::llcpp::fuchsia::device::Controller_GetTopologicalPath_Response) == ::llcpp::fuchsia::device::Controller_GetTopologicalPath_Response::PrimarySize);

template <>
struct IsFidlType<::llcpp::fuchsia::device::Controller_GetTopologicalPath_Result> : public std::true_type {};
static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::Controller_GetTopologicalPath_Result>);

template <>
struct IsFidlType<::llcpp::fuchsia::device::Controller_Bind_Response> : public std::true_type {};
static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::Controller_Bind_Response>);
static_assert(offsetof(::llcpp::fuchsia::device::Controller_Bind_Response, __reserved) == 0);
static_assert(sizeof(::llcpp::fuchsia::device::Controller_Bind_Response) == ::llcpp::fuchsia::device::Controller_Bind_Response::PrimarySize);

template <>
struct IsFidlType<::llcpp::fuchsia::device::Controller_Bind_Result> : public std::true_type {};
static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::Controller_Bind_Result>);

template <>
struct IsFidlType<::llcpp::fuchsia::device::Controller::BindRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::device::Controller::BindRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::device::Controller::BindRequest)
    == ::llcpp::fuchsia::device::Controller::BindRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::device::Controller::BindRequest, driver) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::device::Controller::BindResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::device::Controller::BindResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::device::Controller::BindResponse)
    == ::llcpp::fuchsia::device::Controller::BindResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::device::Controller::BindResponse, result) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::device::Controller::RebindRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::device::Controller::RebindRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::device::Controller::RebindRequest)
    == ::llcpp::fuchsia::device::Controller::RebindRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::device::Controller::RebindRequest, driver) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::device::Controller::RebindResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::device::Controller::RebindResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::device::Controller::RebindResponse)
    == ::llcpp::fuchsia::device::Controller::RebindResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::device::Controller::RebindResponse, result) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::device::Controller::ScheduleUnbindResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::device::Controller::ScheduleUnbindResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::device::Controller::ScheduleUnbindResponse)
    == ::llcpp::fuchsia::device::Controller::ScheduleUnbindResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::device::Controller::ScheduleUnbindResponse, result) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::device::Controller::GetDriverNameResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::device::Controller::GetDriverNameResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::device::Controller::GetDriverNameResponse)
    == ::llcpp::fuchsia::device::Controller::GetDriverNameResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::device::Controller::GetDriverNameResponse, status) == 16);
static_assert(offsetof(::llcpp::fuchsia::device::Controller::GetDriverNameResponse, name) == 24);

template <>
struct IsFidlType<::llcpp::fuchsia::device::Controller::GetDeviceNameResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::device::Controller::GetDeviceNameResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::device::Controller::GetDeviceNameResponse)
    == ::llcpp::fuchsia::device::Controller::GetDeviceNameResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::device::Controller::GetDeviceNameResponse, name) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::device::Controller::GetTopologicalPathResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::device::Controller::GetTopologicalPathResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::device::Controller::GetTopologicalPathResponse)
    == ::llcpp::fuchsia::device::Controller::GetTopologicalPathResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::device::Controller::GetTopologicalPathResponse, result) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::device::Controller::GetEventHandleResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::device::Controller::GetEventHandleResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::device::Controller::GetEventHandleResponse)
    == ::llcpp::fuchsia::device::Controller::GetEventHandleResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::device::Controller::GetEventHandleResponse, status) == 16);
static_assert(offsetof(::llcpp::fuchsia::device::Controller::GetEventHandleResponse, event) == 20);

template <>
struct IsFidlType<::llcpp::fuchsia::device::Controller::GetDriverLogFlagsResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::device::Controller::GetDriverLogFlagsResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::device::Controller::GetDriverLogFlagsResponse)
    == ::llcpp::fuchsia::device::Controller::GetDriverLogFlagsResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::device::Controller::GetDriverLogFlagsResponse, status) == 16);
static_assert(offsetof(::llcpp::fuchsia::device::Controller::GetDriverLogFlagsResponse, flags) == 20);

template <>
struct IsFidlType<::llcpp::fuchsia::device::Controller::SetDriverLogFlagsRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::device::Controller::SetDriverLogFlagsRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::device::Controller::SetDriverLogFlagsRequest)
    == ::llcpp::fuchsia::device::Controller::SetDriverLogFlagsRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::device::Controller::SetDriverLogFlagsRequest, clear_flags) == 16);
static_assert(offsetof(::llcpp::fuchsia::device::Controller::SetDriverLogFlagsRequest, set_flags) == 20);

template <>
struct IsFidlType<::llcpp::fuchsia::device::Controller::SetDriverLogFlagsResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::device::Controller::SetDriverLogFlagsResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::device::Controller::SetDriverLogFlagsResponse)
    == ::llcpp::fuchsia::device::Controller::SetDriverLogFlagsResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::device::Controller::SetDriverLogFlagsResponse, status) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::device::Controller::DebugResumeResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::device::Controller::DebugResumeResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::device::Controller::DebugResumeResponse)
    == ::llcpp::fuchsia::device::Controller::DebugResumeResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::device::Controller::DebugResumeResponse, status) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::device::Controller::RunCompatibilityTestsRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::device::Controller::RunCompatibilityTestsRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::device::Controller::RunCompatibilityTestsRequest)
    == ::llcpp::fuchsia::device::Controller::RunCompatibilityTestsRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::device::Controller::RunCompatibilityTestsRequest, hook_wait_time) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::device::Controller::RunCompatibilityTestsResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::device::Controller::RunCompatibilityTestsResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::device::Controller::RunCompatibilityTestsResponse)
    == ::llcpp::fuchsia::device::Controller::RunCompatibilityTestsResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::device::Controller::RunCompatibilityTestsResponse, status) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::device::Controller::GetDevicePowerCapsResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::device::Controller::GetDevicePowerCapsResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::device::Controller::GetDevicePowerCapsResponse)
    == ::llcpp::fuchsia::device::Controller::GetDevicePowerCapsResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::device::Controller::GetDevicePowerCapsResponse, result) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::device::Controller::GetDevicePerformanceStatesResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::device::Controller::GetDevicePerformanceStatesResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::device::Controller::GetDevicePerformanceStatesResponse)
    == ::llcpp::fuchsia::device::Controller::GetDevicePerformanceStatesResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::device::Controller::GetDevicePerformanceStatesResponse, states) == 16);
static_assert(offsetof(::llcpp::fuchsia::device::Controller::GetDevicePerformanceStatesResponse, status) == 496);

template <>
struct IsFidlType<::llcpp::fuchsia::device::Controller::UpdatePowerStateMappingRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::device::Controller::UpdatePowerStateMappingRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::device::Controller::UpdatePowerStateMappingRequest)
    == ::llcpp::fuchsia::device::Controller::UpdatePowerStateMappingRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::device::Controller::UpdatePowerStateMappingRequest, mapping) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::device::Controller::UpdatePowerStateMappingResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::device::Controller::UpdatePowerStateMappingResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::device::Controller::UpdatePowerStateMappingResponse)
    == ::llcpp::fuchsia::device::Controller::UpdatePowerStateMappingResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::device::Controller::UpdatePowerStateMappingResponse, result) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::device::Controller::GetPowerStateMappingResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::device::Controller::GetPowerStateMappingResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::device::Controller::GetPowerStateMappingResponse)
    == ::llcpp::fuchsia::device::Controller::GetPowerStateMappingResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::device::Controller::GetPowerStateMappingResponse, result) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::device::Controller::SuspendRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::device::Controller::SuspendRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::device::Controller::SuspendRequest)
    == ::llcpp::fuchsia::device::Controller::SuspendRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::device::Controller::SuspendRequest, requested_state) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::device::Controller::SuspendResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::device::Controller::SuspendResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::device::Controller::SuspendResponse)
    == ::llcpp::fuchsia::device::Controller::SuspendResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::device::Controller::SuspendResponse, status) == 16);
static_assert(offsetof(::llcpp::fuchsia::device::Controller::SuspendResponse, out_state) == 20);

template <>
struct IsFidlType<::llcpp::fuchsia::device::Controller::ResumeRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::device::Controller::ResumeRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::device::Controller::ResumeRequest)
    == ::llcpp::fuchsia::device::Controller::ResumeRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::device::Controller::ResumeRequest, requested_state) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::device::Controller::ResumeResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::device::Controller::ResumeResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::device::Controller::ResumeResponse)
    == ::llcpp::fuchsia::device::Controller::ResumeResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::device::Controller::ResumeResponse, result) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::device::Controller::SetPerformanceStateRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::device::Controller::SetPerformanceStateRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::device::Controller::SetPerformanceStateRequest)
    == ::llcpp::fuchsia::device::Controller::SetPerformanceStateRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::device::Controller::SetPerformanceStateRequest, requested_state) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::device::Controller::SetPerformanceStateResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::device::Controller::SetPerformanceStateResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::device::Controller::SetPerformanceStateResponse)
    == ::llcpp::fuchsia::device::Controller::SetPerformanceStateResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::device::Controller::SetPerformanceStateResponse, status) == 16);
static_assert(offsetof(::llcpp::fuchsia::device::Controller::SetPerformanceStateResponse, out_state) == 20);

template <>
struct IsFidlType<::llcpp::fuchsia::device::Controller::ConfigureAutoSuspendRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::device::Controller::ConfigureAutoSuspendRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::device::Controller::ConfigureAutoSuspendRequest)
    == ::llcpp::fuchsia::device::Controller::ConfigureAutoSuspendRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::device::Controller::ConfigureAutoSuspendRequest, enable) == 16);
static_assert(offsetof(::llcpp::fuchsia::device::Controller::ConfigureAutoSuspendRequest, requested_deepest_sleep_state) == 17);

template <>
struct IsFidlType<::llcpp::fuchsia::device::Controller::ConfigureAutoSuspendResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::device::Controller::ConfigureAutoSuspendResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::device::Controller::ConfigureAutoSuspendResponse)
    == ::llcpp::fuchsia::device::Controller::ConfigureAutoSuspendResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::device::Controller::ConfigureAutoSuspendResponse, status) == 16);

}  // namespace fidl