zircon/system/fidl/fuchsia-device-manager/gen/llcpp/include/fuchsia/device/manager/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/handle.h>
#include <lib/zx/vmo.h>
#include <zircon/fidl.h>

namespace llcpp {

namespace fuchsia {
namespace device {
namespace manager {

enum class SystemPowerState : uint8_t {
  SYSTEM_POWER_STATE_FULLY_ON = 1u,
  SYSTEM_POWER_STATE_REBOOT = 2u,
  SYSTEM_POWER_STATE_REBOOT_BOOTLOADER = 3u,
  SYSTEM_POWER_STATE_REBOOT_RECOVERY = 4u,
  SYSTEM_POWER_STATE_POWEROFF = 5u,
  SYSTEM_POWER_STATE_MEXEC = 6u,
  SYSTEM_POWER_STATE_SUSPEND_RAM = 7u,
};


class DebugDumper;
class Administrator;
class DevhostController;
struct Coordinator_AddDevice_Response;
struct Coordinator_AddDevice_Result;
struct Coordinator_AddDeviceInvisible_Response;
struct Coordinator_AddDeviceInvisible_Result;
struct DeviceMetadata;
struct DeviceController_Unbind_Response;
struct DeviceController_Unbind_Result;
struct DeviceController_CompleteRemoval_Response;
struct DeviceController_CompleteRemoval_Result;
struct Coordinator_RunCompatibilityTests_Response;
struct Coordinator_RunCompatibilityTests_Result;
struct Coordinator_PublishMetadata_Response;
struct Coordinator_PublishMetadata_Result;
struct Coordinator_MakeVisible_Response;
struct Coordinator_MakeVisible_Result;
struct Coordinator_LoadFirmware_Response;
struct Coordinator_LoadFirmware_Result;
struct Coordinator_GetTopologicalPath_Response;
struct Coordinator_GetTopologicalPath_Result;
struct Coordinator_GetMetadata_Response;
struct Coordinator_GetMetadata_Result;
struct Coordinator_GetMetadataSize_Response;
struct Coordinator_GetMetadataSize_Result;
struct Coordinator_DirectoryWatch_Response;
struct Coordinator_DirectoryWatch_Result;
struct Coordinator_BindDevice_Response;
struct Coordinator_BindDevice_Result;
struct Coordinator_AddMetadata_Response;
struct Coordinator_AddMetadata_Result;
struct Coordinator_AddCompositeDevice_Response;
struct Coordinator_AddCompositeDevice_Result;
enum class CompatibilityTestStatus : uint32_t {
  OK = 1u,
  ERR_BIND_NO_DDKADD = 2u,
  ERR_BIND_TIMEOUT = 3u,
  ERR_UNBIND_NO_DDKREMOVE = 4u,
  ERR_UNBIND_TIMEOUT = 5u,
  ERR_SUSPEND_DDKREMOVE = 6u,
  ERR_INTERNAL = 7u,
};


class DeviceController;
struct BindInstruction;
struct DeviceComponentPart;
struct DeviceComponent;
struct CompositeDeviceDescriptor;
class AddDeviceConfig final {
public:
  constexpr AddDeviceConfig() : value_(0u) {}
  explicit constexpr AddDeviceConfig(uint32_t value) : value_(value) {}
  const static AddDeviceConfig ALLOW_MULTI_COMPOSITE;
  const static AddDeviceConfig mask;

  explicit constexpr inline operator uint32_t() const { return value_; }
  explicit constexpr inline operator bool() const { return static_cast<bool>(value_); }
  constexpr inline bool operator==(const AddDeviceConfig& other) const { return value_ == other.value_; }
  constexpr inline bool operator!=(const AddDeviceConfig& other) const { return value_ != other.value_; }
  constexpr inline AddDeviceConfig operator~() const;
  constexpr inline AddDeviceConfig operator|(const AddDeviceConfig& other) const;
  constexpr inline AddDeviceConfig operator&(const AddDeviceConfig& other) const;
  constexpr inline AddDeviceConfig operator^(const AddDeviceConfig& other) const;
  constexpr inline void operator|=(const AddDeviceConfig& other);
  constexpr inline void operator&=(const AddDeviceConfig& other);
  constexpr inline void operator^=(const AddDeviceConfig& other);

private:
  uint32_t value_;
};
constexpr const ::llcpp::fuchsia::device::manager::AddDeviceConfig AddDeviceConfig::ALLOW_MULTI_COMPOSITE = ::llcpp::fuchsia::device::manager::AddDeviceConfig(1u);
constexpr const ::llcpp::fuchsia::device::manager::AddDeviceConfig AddDeviceConfig::mask = ::llcpp::fuchsia::device::manager::AddDeviceConfig(1u);

constexpr inline ::llcpp::fuchsia::device::manager::AddDeviceConfig AddDeviceConfig::operator~() const {
  return ::llcpp::fuchsia::device::manager::AddDeviceConfig(static_cast<uint32_t>(~this->value_ & mask.value_));
}

constexpr inline ::llcpp::fuchsia::device::manager::AddDeviceConfig AddDeviceConfig::operator|(
    const ::llcpp::fuchsia::device::manager::AddDeviceConfig& other) const {
  return ::llcpp::fuchsia::device::manager::AddDeviceConfig(static_cast<uint32_t>(this->value_ | other.value_));
}

constexpr inline ::llcpp::fuchsia::device::manager::AddDeviceConfig AddDeviceConfig::operator&(
    const ::llcpp::fuchsia::device::manager::AddDeviceConfig& other) const {
  return ::llcpp::fuchsia::device::manager::AddDeviceConfig(static_cast<uint32_t>(this->value_ & other.value_));
}

constexpr inline ::llcpp::fuchsia::device::manager::AddDeviceConfig AddDeviceConfig::operator^(
    const ::llcpp::fuchsia::device::manager::AddDeviceConfig& other) const {
  return ::llcpp::fuchsia::device::manager::AddDeviceConfig(static_cast<uint32_t>(this->value_ ^ other.value_));
}

constexpr inline void AddDeviceConfig::operator|=(
    const ::llcpp::fuchsia::device::manager::AddDeviceConfig& other) {
  this->value_ |= other.value_;
}

constexpr inline void AddDeviceConfig::operator&=(
    const ::llcpp::fuchsia::device::manager::AddDeviceConfig& other) {
  this->value_ &= other.value_;
}

constexpr inline void AddDeviceConfig::operator^=(
    const ::llcpp::fuchsia::device::manager::AddDeviceConfig& other) {
  this->value_ ^= other.value_;
}

class Coordinator;

extern "C" const fidl_type_t v1_fuchsia_device_manager_Coordinator_AddDevice_ResultTable;

struct Coordinator_AddDevice_Result {
  Coordinator_AddDevice_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 Coordinator_AddDevice_Result WithResponse(::llcpp::fuchsia::device::manager::Coordinator_AddDevice_Response* val) {
    Coordinator_AddDevice_Result result;
    result.set_response(val);
    return result;
  }

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

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

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

  static Coordinator_AddDevice_Result WithErr(int32_t* val) {
    Coordinator_AddDevice_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_manager_Coordinator_AddDevice_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_manager_Coordinator_AddDeviceInvisible_ResultTable;

struct Coordinator_AddDeviceInvisible_Result {
  Coordinator_AddDeviceInvisible_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 Coordinator_AddDeviceInvisible_Result WithResponse(::llcpp::fuchsia::device::manager::Coordinator_AddDeviceInvisible_Response* val) {
    Coordinator_AddDeviceInvisible_Result result;
    result.set_response(val);
    return result;
  }

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

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

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

  static Coordinator_AddDeviceInvisible_Result WithErr(int32_t* val) {
    Coordinator_AddDeviceInvisible_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_manager_Coordinator_AddDeviceInvisible_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_manager_DeviceController_Unbind_ResultTable;

struct DeviceController_Unbind_Result {
  DeviceController_Unbind_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 DeviceController_Unbind_Result WithResponse(::llcpp::fuchsia::device::manager::DeviceController_Unbind_Response* val) {
    DeviceController_Unbind_Result result;
    result.set_response(val);
    return result;
  }

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

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

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

  static DeviceController_Unbind_Result WithErr(int32_t* val) {
    DeviceController_Unbind_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_manager_DeviceController_Unbind_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_manager_DeviceController_CompleteRemoval_ResultTable;

struct DeviceController_CompleteRemoval_Result {
  DeviceController_CompleteRemoval_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 DeviceController_CompleteRemoval_Result WithResponse(::llcpp::fuchsia::device::manager::DeviceController_CompleteRemoval_Response* val) {
    DeviceController_CompleteRemoval_Result result;
    result.set_response(val);
    return result;
  }

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

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

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

  static DeviceController_CompleteRemoval_Result WithErr(int32_t* val) {
    DeviceController_CompleteRemoval_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_manager_DeviceController_CompleteRemoval_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_manager_Coordinator_RunCompatibilityTests_ResultTable;

struct Coordinator_RunCompatibilityTests_Result {
  Coordinator_RunCompatibilityTests_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 Coordinator_RunCompatibilityTests_Result WithResponse(::llcpp::fuchsia::device::manager::Coordinator_RunCompatibilityTests_Response* val) {
    Coordinator_RunCompatibilityTests_Result result;
    result.set_response(val);
    return result;
  }

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

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

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

  static Coordinator_RunCompatibilityTests_Result WithErr(int32_t* val) {
    Coordinator_RunCompatibilityTests_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_manager_Coordinator_RunCompatibilityTests_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_manager_Coordinator_PublishMetadata_ResultTable;

struct Coordinator_PublishMetadata_Result {
  Coordinator_PublishMetadata_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 Coordinator_PublishMetadata_Result WithResponse(::llcpp::fuchsia::device::manager::Coordinator_PublishMetadata_Response* val) {
    Coordinator_PublishMetadata_Result result;
    result.set_response(val);
    return result;
  }

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

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

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

  static Coordinator_PublishMetadata_Result WithErr(int32_t* val) {
    Coordinator_PublishMetadata_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_manager_Coordinator_PublishMetadata_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_manager_Coordinator_MakeVisible_ResultTable;

struct Coordinator_MakeVisible_Result {
  Coordinator_MakeVisible_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 Coordinator_MakeVisible_Result WithResponse(::llcpp::fuchsia::device::manager::Coordinator_MakeVisible_Response* val) {
    Coordinator_MakeVisible_Result result;
    result.set_response(val);
    return result;
  }

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

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

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

  static Coordinator_MakeVisible_Result WithErr(int32_t* val) {
    Coordinator_MakeVisible_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_manager_Coordinator_MakeVisible_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_manager_Coordinator_LoadFirmware_ResultTable;

struct Coordinator_LoadFirmware_Result {
  Coordinator_LoadFirmware_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 Coordinator_LoadFirmware_Result WithResponse(::llcpp::fuchsia::device::manager::Coordinator_LoadFirmware_Response* val) {
    Coordinator_LoadFirmware_Result result;
    result.set_response(val);
    return result;
  }

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

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

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

  static Coordinator_LoadFirmware_Result WithErr(int32_t* val) {
    Coordinator_LoadFirmware_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_manager_Coordinator_LoadFirmware_ResultTable;
  static constexpr uint32_t MaxNumHandles = 1;
  static constexpr uint32_t PrimarySize = 24;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 16;
  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_manager_Coordinator_GetTopologicalPath_ResultTable;

struct Coordinator_GetTopologicalPath_Result {
  Coordinator_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 Coordinator_GetTopologicalPath_Result WithResponse(::llcpp::fuchsia::device::manager::Coordinator_GetTopologicalPath_Response* val) {
    Coordinator_GetTopologicalPath_Result result;
    result.set_response(val);
    return result;
  }

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

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

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

  static Coordinator_GetTopologicalPath_Result WithErr(int32_t* val) {
    Coordinator_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_manager_Coordinator_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_manager_Coordinator_GetMetadata_ResultTable;

struct Coordinator_GetMetadata_Result {
  Coordinator_GetMetadata_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 Coordinator_GetMetadata_Result WithResponse(::llcpp::fuchsia::device::manager::Coordinator_GetMetadata_Response* val) {
    Coordinator_GetMetadata_Result result;
    result.set_response(val);
    return result;
  }

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

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

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

  static Coordinator_GetMetadata_Result WithErr(int32_t* val) {
    Coordinator_GetMetadata_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_manager_Coordinator_GetMetadata_ResultTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 24;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 8208;
  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_manager_Coordinator_GetMetadataSize_ResultTable;

struct Coordinator_GetMetadataSize_Result {
  Coordinator_GetMetadataSize_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 Coordinator_GetMetadataSize_Result WithResponse(::llcpp::fuchsia::device::manager::Coordinator_GetMetadataSize_Response* val) {
    Coordinator_GetMetadataSize_Result result;
    result.set_response(val);
    return result;
  }

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

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

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

  static Coordinator_GetMetadataSize_Result WithErr(int32_t* val) {
    Coordinator_GetMetadataSize_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_manager_Coordinator_GetMetadataSize_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_manager_Coordinator_DirectoryWatch_ResultTable;

struct Coordinator_DirectoryWatch_Result {
  Coordinator_DirectoryWatch_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 Coordinator_DirectoryWatch_Result WithResponse(::llcpp::fuchsia::device::manager::Coordinator_DirectoryWatch_Response* val) {
    Coordinator_DirectoryWatch_Result result;
    result.set_response(val);
    return result;
  }

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

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

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

  static Coordinator_DirectoryWatch_Result WithErr(int32_t* val) {
    Coordinator_DirectoryWatch_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_manager_Coordinator_DirectoryWatch_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_manager_Coordinator_BindDevice_ResultTable;

struct Coordinator_BindDevice_Result {
  Coordinator_BindDevice_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 Coordinator_BindDevice_Result WithResponse(::llcpp::fuchsia::device::manager::Coordinator_BindDevice_Response* val) {
    Coordinator_BindDevice_Result result;
    result.set_response(val);
    return result;
  }

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

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

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

  static Coordinator_BindDevice_Result WithErr(int32_t* val) {
    Coordinator_BindDevice_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_manager_Coordinator_BindDevice_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_manager_Coordinator_AddMetadata_ResultTable;

struct Coordinator_AddMetadata_Result {
  Coordinator_AddMetadata_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 Coordinator_AddMetadata_Result WithResponse(::llcpp::fuchsia::device::manager::Coordinator_AddMetadata_Response* val) {
    Coordinator_AddMetadata_Result result;
    result.set_response(val);
    return result;
  }

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

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

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

  static Coordinator_AddMetadata_Result WithErr(int32_t* val) {
    Coordinator_AddMetadata_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_manager_Coordinator_AddMetadata_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_manager_Coordinator_AddCompositeDevice_ResultTable;

struct Coordinator_AddCompositeDevice_Result {
  Coordinator_AddCompositeDevice_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 Coordinator_AddCompositeDevice_Result WithResponse(::llcpp::fuchsia::device::manager::Coordinator_AddCompositeDevice_Response* val) {
    Coordinator_AddCompositeDevice_Result result;
    result.set_response(val);
    return result;
  }

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

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

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

  static Coordinator_AddCompositeDevice_Result WithErr(int32_t* val) {
    Coordinator_AddCompositeDevice_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_manager_Coordinator_AddCompositeDevice_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_manager_DebugDumperDumpTreeRequestTable;
extern "C" const fidl_type_t v1_fuchsia_device_manager_DebugDumperDumpTreeResponseTable;
extern "C" const fidl_type_t v1_fuchsia_device_manager_DebugDumperDumpDriversRequestTable;
extern "C" const fidl_type_t v1_fuchsia_device_manager_DebugDumperDumpDriversResponseTable;
extern "C" const fidl_type_t v1_fuchsia_device_manager_DebugDumperDumpBindingPropertiesRequestTable;
extern "C" const fidl_type_t v1_fuchsia_device_manager_DebugDumperDumpBindingPropertiesResponseTable;

// Dumps text debug information.
//
// All methods dump ascii text into a VMO, this allows the caller the flexibility to decide
// how much data they want. Use the returned `written` value to read the data, no string
// termination is guaranteed.
class DebugDumper final {
  DebugDumper() = delete;
 public:
  static constexpr char Name[] = "fuchsia.device.manager.DebugDumper";

  struct DumpTreeResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t status;
    uint64_t written;
    uint64_t available;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_DebugDumperDumpTreeResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 40;
    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 DumpTreeRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::zx::vmo output;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_DebugDumperDumpTreeRequestTable;
    static constexpr uint32_t MaxNumHandles = 1;
    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 = DumpTreeResponse;
  };

  struct DumpDriversResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t status;
    uint64_t written;
    uint64_t available;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_DebugDumperDumpDriversResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 40;
    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 DumpDriversRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::zx::vmo output;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_DebugDumperDumpDriversRequestTable;
    static constexpr uint32_t MaxNumHandles = 1;
    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 = DumpDriversResponse;
  };

  struct DumpBindingPropertiesResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t status;
    uint64_t written;
    uint64_t available;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_DebugDumperDumpBindingPropertiesResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 40;
    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 DumpBindingPropertiesRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::zx::vmo output;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_DebugDumperDumpBindingPropertiesRequestTable;
    static constexpr uint32_t MaxNumHandles = 1;
    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 = DumpBindingPropertiesResponse;
  };


  // Collection of return types of FIDL calls in this interface.
  class ResultOf final {
    ResultOf() = delete;
   private:
    template <typename ResponseType>
    class DumpTree_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      DumpTree_Impl(::zx::unowned_channel _client_end, ::zx::vmo output);
      ~DumpTree_Impl() = default;
      DumpTree_Impl(DumpTree_Impl&& other) = default;
      DumpTree_Impl& operator=(DumpTree_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 DumpDrivers_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      DumpDrivers_Impl(::zx::unowned_channel _client_end, ::zx::vmo output);
      ~DumpDrivers_Impl() = default;
      DumpDrivers_Impl(DumpDrivers_Impl&& other) = default;
      DumpDrivers_Impl& operator=(DumpDrivers_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 DumpBindingProperties_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      DumpBindingProperties_Impl(::zx::unowned_channel _client_end, ::zx::vmo output);
      ~DumpBindingProperties_Impl() = default;
      DumpBindingProperties_Impl(DumpBindingProperties_Impl&& other) = default;
      DumpBindingProperties_Impl& operator=(DumpBindingProperties_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 DumpTree = DumpTree_Impl<DumpTreeResponse>;
    using DumpDrivers = DumpDrivers_Impl<DumpDriversResponse>;
    using DumpBindingProperties = DumpBindingProperties_Impl<DumpBindingPropertiesResponse>;
  };

  // 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 DumpTree_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      DumpTree_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::vmo output, ::fidl::BytePart _response_buffer);
      ~DumpTree_Impl() = default;
      DumpTree_Impl(DumpTree_Impl&& other) = default;
      DumpTree_Impl& operator=(DumpTree_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 DumpDrivers_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      DumpDrivers_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::vmo output, ::fidl::BytePart _response_buffer);
      ~DumpDrivers_Impl() = default;
      DumpDrivers_Impl(DumpDrivers_Impl&& other) = default;
      DumpDrivers_Impl& operator=(DumpDrivers_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 DumpBindingProperties_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      DumpBindingProperties_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::vmo output, ::fidl::BytePart _response_buffer);
      ~DumpBindingProperties_Impl() = default;
      DumpBindingProperties_Impl(DumpBindingProperties_Impl&& other) = default;
      DumpBindingProperties_Impl& operator=(DumpBindingProperties_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 DumpTree = DumpTree_Impl<DumpTreeResponse>;
    using DumpDrivers = DumpDrivers_Impl<DumpDriversResponse>;
    using DumpBindingProperties = DumpBindingProperties_Impl<DumpBindingPropertiesResponse>;
  };

  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_; }

    // Print device tree into `output`, returns bytes `written` and bytes `available` to write.
    // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::DumpTree DumpTree(::zx::vmo output);

    // Print device tree into `output`, returns bytes `written` and bytes `available` to write.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::DumpTree DumpTree(::fidl::BytePart _request_buffer, ::zx::vmo output, ::fidl::BytePart _response_buffer);

    // Print information about all drivers into `output`, returns bytes `written` and bytes `available` to write.
    // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::DumpDrivers DumpDrivers(::zx::vmo output);

    // Print information about all drivers into `output`, returns bytes `written` and bytes `available` to write.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::DumpDrivers DumpDrivers(::fidl::BytePart _request_buffer, ::zx::vmo output, ::fidl::BytePart _response_buffer);

    // Print all devices and their binding properties into `output`, returns bytes `written`
    // and bytes `available` to write.
    // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::DumpBindingProperties DumpBindingProperties(::zx::vmo output);

    // Print all devices and their binding properties into `output`, returns bytes `written`
    // and bytes `available` to write.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::DumpBindingProperties DumpBindingProperties(::fidl::BytePart _request_buffer, ::zx::vmo output, ::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:

    // Print device tree into `output`, returns bytes `written` and bytes `available` to write.
    // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::DumpTree DumpTree(::zx::unowned_channel _client_end, ::zx::vmo output);

    // Print device tree into `output`, returns bytes `written` and bytes `available` to write.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::DumpTree DumpTree(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::vmo output, ::fidl::BytePart _response_buffer);

    // Print information about all drivers into `output`, returns bytes `written` and bytes `available` to write.
    // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::DumpDrivers DumpDrivers(::zx::unowned_channel _client_end, ::zx::vmo output);

    // Print information about all drivers into `output`, returns bytes `written` and bytes `available` to write.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::DumpDrivers DumpDrivers(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::vmo output, ::fidl::BytePart _response_buffer);

    // Print all devices and their binding properties into `output`, returns bytes `written`
    // and bytes `available` to write.
    // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::DumpBindingProperties DumpBindingProperties(::zx::unowned_channel _client_end, ::zx::vmo output);

    // Print all devices and their binding properties into `output`, returns bytes `written`
    // and bytes `available` to write.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::DumpBindingProperties DumpBindingProperties(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::vmo output, ::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:

    // Print device tree into `output`, returns bytes `written` and bytes `available` to write.
    static ::fidl::DecodeResult<DumpTreeResponse> DumpTree(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<DumpTreeRequest> params, ::fidl::BytePart response_buffer);

    // Print information about all drivers into `output`, returns bytes `written` and bytes `available` to write.
    static ::fidl::DecodeResult<DumpDriversResponse> DumpDrivers(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<DumpDriversRequest> params, ::fidl::BytePart response_buffer);

    // Print all devices and their binding properties into `output`, returns bytes `written`
    // and bytes `available` to write.
    static ::fidl::DecodeResult<DumpBindingPropertiesResponse> DumpBindingProperties(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<DumpBindingPropertiesRequest> params, ::fidl::BytePart response_buffer);

  };

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

    class DumpTreeCompleterBase : public _Base {
     public:
      void Reply(int32_t status, uint64_t written, uint64_t available);
      void Reply(::fidl::BytePart _buffer, int32_t status, uint64_t written, uint64_t available);
      void Reply(::fidl::DecodedMessage<DumpTreeResponse> params);

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

    using DumpTreeCompleter = ::fidl::Completer<DumpTreeCompleterBase>;

    virtual void DumpTree(::zx::vmo output, DumpTreeCompleter::Sync _completer) = 0;

    class DumpDriversCompleterBase : public _Base {
     public:
      void Reply(int32_t status, uint64_t written, uint64_t available);
      void Reply(::fidl::BytePart _buffer, int32_t status, uint64_t written, uint64_t available);
      void Reply(::fidl::DecodedMessage<DumpDriversResponse> params);

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

    using DumpDriversCompleter = ::fidl::Completer<DumpDriversCompleterBase>;

    virtual void DumpDrivers(::zx::vmo output, DumpDriversCompleter::Sync _completer) = 0;

    class DumpBindingPropertiesCompleterBase : public _Base {
     public:
      void Reply(int32_t status, uint64_t written, uint64_t available);
      void Reply(::fidl::BytePart _buffer, int32_t status, uint64_t written, uint64_t available);
      void Reply(::fidl::DecodedMessage<DumpBindingPropertiesResponse> params);

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

    using DumpBindingPropertiesCompleter = ::fidl::Completer<DumpBindingPropertiesCompleterBase>;

    virtual void DumpBindingProperties(::zx::vmo output, DumpBindingPropertiesCompleter::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 DumpTreeRequest(const ::fidl::DecodedMessage<DebugDumper::DumpTreeRequest>& _msg);
    static void DumpTreeResponse(const ::fidl::DecodedMessage<DebugDumper::DumpTreeResponse>& _msg);
    static void DumpDriversRequest(const ::fidl::DecodedMessage<DebugDumper::DumpDriversRequest>& _msg);
    static void DumpDriversResponse(const ::fidl::DecodedMessage<DebugDumper::DumpDriversResponse>& _msg);
    static void DumpBindingPropertiesRequest(const ::fidl::DecodedMessage<DebugDumper::DumpBindingPropertiesRequest>& _msg);
    static void DumpBindingPropertiesResponse(const ::fidl::DecodedMessage<DebugDumper::DumpBindingPropertiesResponse>& _msg);
  };
};

extern "C" const fidl_type_t v1_fuchsia_device_manager_AdministratorSuspendRequestTable;
extern "C" const fidl_type_t v1_fuchsia_device_manager_AdministratorSuspendResponseTable;

// Provides administration services for the device manager service and the device tree it controls.
class Administrator final {
  Administrator() = delete;
 public:
  static constexpr char Name[] = "fuchsia.device.manager.Administrator";

  struct SuspendResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t status;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_AdministratorSuspendResponseTable;
    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;
    uint32_t flags;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_AdministratorSuspendRequestTable;
    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;
  };


  // Collection of return types of FIDL calls in this interface.
  class ResultOf final {
    ResultOf() = delete;
   private:
    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, uint32_t flags);
      ~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*;
    };

   public:
    using Suspend = Suspend_Impl<SuspendResponse>;
  };

  // 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 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, uint32_t flags, ::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*;
    };

   public:
    using Suspend = Suspend_Impl<SuspendResponse>;
  };

  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_; }

    // Ask all devices to enter the suspend state indicated by `flags`. Flags should be some
    // combination of `DEVICE_SUSPEND_FLAG_*` from the DDK.
    // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::Suspend Suspend(uint32_t flags);

    // Ask all devices to enter the suspend state indicated by `flags`. Flags should be some
    // combination of `DEVICE_SUSPEND_FLAG_*` from the DDK.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::Suspend Suspend(::fidl::BytePart _request_buffer, uint32_t flags, ::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:

    // Ask all devices to enter the suspend state indicated by `flags`. Flags should be some
    // combination of `DEVICE_SUSPEND_FLAG_*` from the DDK.
    // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::Suspend Suspend(::zx::unowned_channel _client_end, uint32_t flags);

    // Ask all devices to enter the suspend state indicated by `flags`. Flags should be some
    // combination of `DEVICE_SUSPEND_FLAG_*` from the DDK.
    // 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, uint32_t flags, ::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:

    // Ask all devices to enter the suspend state indicated by `flags`. Flags should be some
    // combination of `DEVICE_SUSPEND_FLAG_*` from the DDK.
    static ::fidl::DecodeResult<SuspendResponse> Suspend(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SuspendRequest> params, ::fidl::BytePart response_buffer);

  };

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

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

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

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

    virtual void Suspend(uint32_t flags, SuspendCompleter::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 SuspendRequest(const ::fidl::DecodedMessage<Administrator::SuspendRequest>& _msg);
    static void SuspendResponse(const ::fidl::DecodedMessage<Administrator::SuspendResponse>& _msg);
  };
};

constexpr uint32_t SUSPEND_FLAG_SUSPEND_RAM = 3705406464u;

constexpr uint32_t SUSPEND_FLAG_REBOOT_RECOVERY = 3705405698u;

constexpr uint32_t SUSPEND_FLAG_REBOOT_BOOTLOADER = 3705405697u;

// All available suspend flags
constexpr uint32_t SUSPEND_FLAG_REBOOT = 3705405696u;

constexpr uint32_t SUSPEND_FLAG_POWEROFF = 3705405952u;

constexpr uint32_t SUSPEND_FLAG_MEXEC = 3705406208u;

// Maximum number of properties that can be attached to a device
constexpr uint32_t PROPERTIES_MAX = 256u;

// Maximum number of metadata that can be added to a device
constexpr uint32_t METADATA_MAX = 32u;

// Maximum number of bytes in a metadata payload
constexpr uint32_t METADATA_BYTES_MAX = 8192u;

constexpr uint32_t MAX_SYSTEM_POWER_STATES = 7u;

extern "C" const fidl_type_t v1_fuchsia_device_manager_DevhostControllerCreateDeviceStubRequestTable;
extern "C" const fidl_type_t v1_fuchsia_device_manager_DevhostControllerCreateDeviceStubResponseTable;
extern "C" const fidl_type_t v1_fuchsia_device_manager_DevhostControllerCreateDeviceRequestTable;
extern "C" const fidl_type_t v1_fuchsia_device_manager_DevhostControllerCreateDeviceResponseTable;
extern "C" const fidl_type_t v1_fuchsia_device_manager_DevhostControllerCreateCompositeDeviceRequestTable;
extern "C" const fidl_type_t v1_fuchsia_device_manager_DevhostControllerCreateCompositeDeviceResponseTable;

// Protocol for controlling a devhost process from the devcoordinator
class DevhostController final {
  DevhostController() = delete;
 public:

  struct CreateDeviceStubRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::zx::channel coordinator_rpc;
    ::zx::channel device_controller_rpc;
    uint32_t protocol_id;
    uint64_t local_device_id;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_DevhostControllerCreateDeviceStubRequestTable;
    static constexpr uint32_t MaxNumHandles = 2;
    static constexpr uint32_t PrimarySize = 40;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr uint32_t AltPrimarySize = 40;
    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;
  };

  struct CreateDeviceRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::zx::channel coordinator_rpc;
    ::zx::channel device_controller_rpc;
    ::fidl::StringView driver_path;
    ::zx::vmo driver;
    ::zx::handle parent_proxy;
    ::fidl::StringView proxy_args;
    uint64_t local_device_id;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_DevhostControllerCreateDeviceRequestTable;
    static constexpr uint32_t MaxNumHandles = 4;
    static constexpr uint32_t PrimarySize = 72;
    static constexpr uint32_t MaxOutOfLine = 2048;
    static constexpr uint32_t AltPrimarySize = 72;
    static constexpr uint32_t AltMaxOutOfLine = 2048;
    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;
  };

  struct CreateCompositeDeviceResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t status;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_DevhostControllerCreateCompositeDeviceResponseTable;
    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 CreateCompositeDeviceRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::zx::channel coordinator_rpc;
    ::zx::channel device_controller_rpc;
    ::fidl::VectorView<uint64_t> components;
    ::fidl::StringView name;
    uint64_t local_device_id;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_DevhostControllerCreateCompositeDeviceRequestTable;
    static constexpr uint32_t MaxNumHandles = 2;
    static constexpr uint32_t PrimarySize = 64;
    static constexpr uint32_t MaxOutOfLine = 160;
    static constexpr uint32_t AltPrimarySize = 64;
    static constexpr uint32_t AltMaxOutOfLine = 160;
    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 = CreateCompositeDeviceResponse;
  };


  // Collection of return types of FIDL calls in this interface.
  class ResultOf final {
    ResultOf() = delete;
   private:
    class CreateDeviceStub_Impl final : private ::fidl::internal::StatusAndError {
      using Super = ::fidl::internal::StatusAndError;
     public:
      CreateDeviceStub_Impl(::zx::unowned_channel _client_end, ::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, uint32_t protocol_id, uint64_t local_device_id);
      ~CreateDeviceStub_Impl() = default;
      CreateDeviceStub_Impl(CreateDeviceStub_Impl&& other) = default;
      CreateDeviceStub_Impl& operator=(CreateDeviceStub_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
    };
    class CreateDevice_Impl final : private ::fidl::internal::StatusAndError {
      using Super = ::fidl::internal::StatusAndError;
     public:
      CreateDevice_Impl(::zx::unowned_channel _client_end, ::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, ::fidl::StringView driver_path, ::zx::vmo driver, ::zx::handle parent_proxy, ::fidl::StringView proxy_args, uint64_t local_device_id);
      ~CreateDevice_Impl() = default;
      CreateDevice_Impl(CreateDevice_Impl&& other) = default;
      CreateDevice_Impl& operator=(CreateDevice_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
    };
    template <typename ResponseType>
    class CreateCompositeDevice_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      CreateCompositeDevice_Impl(::zx::unowned_channel _client_end, ::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, ::fidl::VectorView<uint64_t> components, ::fidl::StringView name, uint64_t local_device_id);
      ~CreateCompositeDevice_Impl() = default;
      CreateCompositeDevice_Impl(CreateCompositeDevice_Impl&& other) = default;
      CreateCompositeDevice_Impl& operator=(CreateCompositeDevice_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 CreateDeviceStub = CreateDeviceStub_Impl;
    using CreateDevice = CreateDevice_Impl;
    using CreateCompositeDevice = CreateCompositeDevice_Impl<CreateCompositeDeviceResponse>;
  };

  // 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:
    class CreateDeviceStub_Impl final : private ::fidl::internal::StatusAndError {
      using Super = ::fidl::internal::StatusAndError;
     public:
      CreateDeviceStub_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, uint32_t protocol_id, uint64_t local_device_id);
      ~CreateDeviceStub_Impl() = default;
      CreateDeviceStub_Impl(CreateDeviceStub_Impl&& other) = default;
      CreateDeviceStub_Impl& operator=(CreateDeviceStub_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
    };
    class CreateDevice_Impl final : private ::fidl::internal::StatusAndError {
      using Super = ::fidl::internal::StatusAndError;
     public:
      CreateDevice_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, ::fidl::StringView driver_path, ::zx::vmo driver, ::zx::handle parent_proxy, ::fidl::StringView proxy_args, uint64_t local_device_id);
      ~CreateDevice_Impl() = default;
      CreateDevice_Impl(CreateDevice_Impl&& other) = default;
      CreateDevice_Impl& operator=(CreateDevice_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
    };
    template <typename ResponseType>
    class CreateCompositeDevice_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      CreateCompositeDevice_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, ::fidl::VectorView<uint64_t> components, ::fidl::StringView name, uint64_t local_device_id, ::fidl::BytePart _response_buffer);
      ~CreateCompositeDevice_Impl() = default;
      CreateCompositeDevice_Impl(CreateCompositeDevice_Impl&& other) = default;
      CreateCompositeDevice_Impl& operator=(CreateCompositeDevice_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 CreateDeviceStub = CreateDeviceStub_Impl;
    using CreateDevice = CreateDevice_Impl;
    using CreateCompositeDevice = CreateCompositeDevice_Impl<CreateCompositeDeviceResponse>;
  };

  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_; }

    // Create a device in the devhost that only implements the device protocol
    // and claims to support the given `protocol_id`.  This device will communicate
    // with the devcoordinator via `coordinator`. Implements DeviceController on device_controller_rpc
    // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::CreateDeviceStub CreateDeviceStub(::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, uint32_t protocol_id, uint64_t local_device_id);

    // Create a device in the devhost that only implements the device protocol
    // and claims to support the given `protocol_id`.  This device will communicate
    // with the devcoordinator via `coordinator`. Implements DeviceController on device_controller_rpc
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::CreateDeviceStub CreateDeviceStub(::fidl::BytePart _request_buffer, ::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, uint32_t protocol_id, uint64_t local_device_id);

    // Create a device in the devhost representing the shadowed half of device
    // in another devhost.  This new device will communicate with the devcoordinator
    // via `rpc`, and with its other half via `parent_proxy`.
    //
    // The new device will have the given driver responsible for running its half
    // of the driver's cross-process protocol.  It's create() method will be invoked,
    // giving it access to `parent_proxy` and `proxy_args`.
    //
    // parent_proxy, if present, will usually be a channel to the upper half of
    // a shadowed device.  The one exception is when this method is used
    // to create the Platform Bus, in which case it will be a channel to a
    // fuchsia.boot.Items protocol.
    //
    // `local_device_id` will be a unique value within the device's devhost
    // Request is heap-allocated.
    ResultOf::CreateDevice CreateDevice(::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, ::fidl::StringView driver_path, ::zx::vmo driver, ::zx::handle parent_proxy, ::fidl::StringView proxy_args, uint64_t local_device_id);

    // Create a device in the devhost representing the shadowed half of device
    // in another devhost.  This new device will communicate with the devcoordinator
    // via `rpc`, and with its other half via `parent_proxy`.
    //
    // The new device will have the given driver responsible for running its half
    // of the driver's cross-process protocol.  It's create() method will be invoked,
    // giving it access to `parent_proxy` and `proxy_args`.
    //
    // parent_proxy, if present, will usually be a channel to the upper half of
    // a shadowed device.  The one exception is when this method is used
    // to create the Platform Bus, in which case it will be a channel to a
    // fuchsia.boot.Items protocol.
    //
    // `local_device_id` will be a unique value within the device's devhost
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::CreateDevice CreateDevice(::fidl::BytePart _request_buffer, ::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, ::fidl::StringView driver_path, ::zx::vmo driver, ::zx::handle parent_proxy, ::fidl::StringView proxy_args, uint64_t local_device_id);

    // Introduce a composite device that has the given name and properties.
    // `components` will be a list of all of the composite's components,
    // described using devhost local device ids.  The order of the components
    // will match the original composite creation request.  The new device will
    // communicate with devcoordinator via `rpc`.
    //
    // `local_device_id` will be a unique value within the device's devhost, identifying
    // the resulting composite device.
    // Allocates 248 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::CreateCompositeDevice CreateCompositeDevice(::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, ::fidl::VectorView<uint64_t> components, ::fidl::StringView name, uint64_t local_device_id);

    // Introduce a composite device that has the given name and properties.
    // `components` will be a list of all of the composite's components,
    // described using devhost local device ids.  The order of the components
    // will match the original composite creation request.  The new device will
    // communicate with devcoordinator via `rpc`.
    //
    // `local_device_id` will be a unique value within the device's devhost, identifying
    // the resulting composite device.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::CreateCompositeDevice CreateCompositeDevice(::fidl::BytePart _request_buffer, ::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, ::fidl::VectorView<uint64_t> components, ::fidl::StringView name, uint64_t local_device_id, ::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:

    // Create a device in the devhost that only implements the device protocol
    // and claims to support the given `protocol_id`.  This device will communicate
    // with the devcoordinator via `coordinator`. Implements DeviceController on device_controller_rpc
    // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::CreateDeviceStub CreateDeviceStub(::zx::unowned_channel _client_end, ::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, uint32_t protocol_id, uint64_t local_device_id);

    // Create a device in the devhost that only implements the device protocol
    // and claims to support the given `protocol_id`.  This device will communicate
    // with the devcoordinator via `coordinator`. Implements DeviceController on device_controller_rpc
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::CreateDeviceStub CreateDeviceStub(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, uint32_t protocol_id, uint64_t local_device_id);

    // Create a device in the devhost representing the shadowed half of device
    // in another devhost.  This new device will communicate with the devcoordinator
    // via `rpc`, and with its other half via `parent_proxy`.
    //
    // The new device will have the given driver responsible for running its half
    // of the driver's cross-process protocol.  It's create() method will be invoked,
    // giving it access to `parent_proxy` and `proxy_args`.
    //
    // parent_proxy, if present, will usually be a channel to the upper half of
    // a shadowed device.  The one exception is when this method is used
    // to create the Platform Bus, in which case it will be a channel to a
    // fuchsia.boot.Items protocol.
    //
    // `local_device_id` will be a unique value within the device's devhost
    // Request is heap-allocated.
    static ResultOf::CreateDevice CreateDevice(::zx::unowned_channel _client_end, ::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, ::fidl::StringView driver_path, ::zx::vmo driver, ::zx::handle parent_proxy, ::fidl::StringView proxy_args, uint64_t local_device_id);

    // Create a device in the devhost representing the shadowed half of device
    // in another devhost.  This new device will communicate with the devcoordinator
    // via `rpc`, and with its other half via `parent_proxy`.
    //
    // The new device will have the given driver responsible for running its half
    // of the driver's cross-process protocol.  It's create() method will be invoked,
    // giving it access to `parent_proxy` and `proxy_args`.
    //
    // parent_proxy, if present, will usually be a channel to the upper half of
    // a shadowed device.  The one exception is when this method is used
    // to create the Platform Bus, in which case it will be a channel to a
    // fuchsia.boot.Items protocol.
    //
    // `local_device_id` will be a unique value within the device's devhost
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::CreateDevice CreateDevice(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, ::fidl::StringView driver_path, ::zx::vmo driver, ::zx::handle parent_proxy, ::fidl::StringView proxy_args, uint64_t local_device_id);

    // Introduce a composite device that has the given name and properties.
    // `components` will be a list of all of the composite's components,
    // described using devhost local device ids.  The order of the components
    // will match the original composite creation request.  The new device will
    // communicate with devcoordinator via `rpc`.
    //
    // `local_device_id` will be a unique value within the device's devhost, identifying
    // the resulting composite device.
    // Allocates 248 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::CreateCompositeDevice CreateCompositeDevice(::zx::unowned_channel _client_end, ::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, ::fidl::VectorView<uint64_t> components, ::fidl::StringView name, uint64_t local_device_id);

    // Introduce a composite device that has the given name and properties.
    // `components` will be a list of all of the composite's components,
    // described using devhost local device ids.  The order of the components
    // will match the original composite creation request.  The new device will
    // communicate with devcoordinator via `rpc`.
    //
    // `local_device_id` will be a unique value within the device's devhost, identifying
    // the resulting composite device.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::CreateCompositeDevice CreateCompositeDevice(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, ::fidl::VectorView<uint64_t> components, ::fidl::StringView name, uint64_t local_device_id, ::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:

    // Create a device in the devhost that only implements the device protocol
    // and claims to support the given `protocol_id`.  This device will communicate
    // with the devcoordinator via `coordinator`. Implements DeviceController on device_controller_rpc
    static ::fidl::internal::StatusAndError CreateDeviceStub(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CreateDeviceStubRequest> params);

    // Create a device in the devhost representing the shadowed half of device
    // in another devhost.  This new device will communicate with the devcoordinator
    // via `rpc`, and with its other half via `parent_proxy`.
    //
    // The new device will have the given driver responsible for running its half
    // of the driver's cross-process protocol.  It's create() method will be invoked,
    // giving it access to `parent_proxy` and `proxy_args`.
    //
    // parent_proxy, if present, will usually be a channel to the upper half of
    // a shadowed device.  The one exception is when this method is used
    // to create the Platform Bus, in which case it will be a channel to a
    // fuchsia.boot.Items protocol.
    //
    // `local_device_id` will be a unique value within the device's devhost
    static ::fidl::internal::StatusAndError CreateDevice(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CreateDeviceRequest> params);

    // Introduce a composite device that has the given name and properties.
    // `components` will be a list of all of the composite's components,
    // described using devhost local device ids.  The order of the components
    // will match the original composite creation request.  The new device will
    // communicate with devcoordinator via `rpc`.
    //
    // `local_device_id` will be a unique value within the device's devhost, identifying
    // the resulting composite device.
    static ::fidl::DecodeResult<CreateCompositeDeviceResponse> CreateCompositeDevice(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CreateCompositeDeviceRequest> params, ::fidl::BytePart response_buffer);

  };

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

    using CreateDeviceStubCompleter = ::fidl::Completer<>;

    virtual void CreateDeviceStub(::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, uint32_t protocol_id, uint64_t local_device_id, CreateDeviceStubCompleter::Sync _completer) = 0;

    using CreateDeviceCompleter = ::fidl::Completer<>;

    virtual void CreateDevice(::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, ::fidl::StringView driver_path, ::zx::vmo driver, ::zx::handle parent_proxy, ::fidl::StringView proxy_args, uint64_t local_device_id, CreateDeviceCompleter::Sync _completer) = 0;

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

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

    using CreateCompositeDeviceCompleter = ::fidl::Completer<CreateCompositeDeviceCompleterBase>;

    virtual void CreateCompositeDevice(::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, ::fidl::VectorView<uint64_t> components, ::fidl::StringView name, uint64_t local_device_id, CreateCompositeDeviceCompleter::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 CreateDeviceStubRequest(const ::fidl::DecodedMessage<DevhostController::CreateDeviceStubRequest>& _msg);
    static void CreateDeviceRequest(const ::fidl::DecodedMessage<DevhostController::CreateDeviceRequest>& _msg);
    static void CreateCompositeDeviceRequest(const ::fidl::DecodedMessage<DevhostController::CreateCompositeDeviceRequest>& _msg);
    static void CreateCompositeDeviceResponse(const ::fidl::DecodedMessage<DevhostController::CreateCompositeDeviceResponse>& _msg);
  };
};

extern "C" const fidl_type_t v1_fuchsia_device_manager_Coordinator_AddDevice_ResponseTable;

struct Coordinator_AddDevice_Response {
  static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_Coordinator_AddDevice_ResponseTable;
  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;

  uint64_t local_device_id = {};
};

extern "C" const fidl_type_t v1_fuchsia_device_manager_Coordinator_AddDeviceInvisible_ResponseTable;

struct Coordinator_AddDeviceInvisible_Response {
  static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_Coordinator_AddDeviceInvisible_ResponseTable;
  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;

  uint64_t local_device_id = {};
};

extern "C" const fidl_type_t v1_fuchsia_device_manager_DeviceMetadataTable;

// Metadata that can be added to a device
struct DeviceMetadata {
  static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_DeviceMetadataTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 24;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 8192;
  static constexpr bool HasPointer = true;

  uint32_t key = {};

  ::fidl::VectorView<uint8_t> data = {};
};

extern "C" const fidl_type_t v1_fuchsia_device_manager_DeviceController_Unbind_ResponseTable;

struct DeviceController_Unbind_Response {
  static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_DeviceController_Unbind_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_manager_DeviceController_CompleteRemoval_ResponseTable;

struct DeviceController_CompleteRemoval_Response {
  static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_DeviceController_CompleteRemoval_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 = {};
};

// Maximum number of bytes in a path
constexpr uint32_t DEVICE_PATH_MAX = 1024u;

// This definition must match `ZX_DEVICE_NAME_MAX` and is checked by a static assert.
constexpr uint32_t DEVICE_NAME_MAX = 31u;

// Maximum instructions in a match program
constexpr uint32_t DEVICE_COMPONENT_PART_INSTRUCTIONS_MAX = 32u;

// Maximum number of parts that a composite device component can have
constexpr uint32_t DEVICE_COMPONENT_PARTS_MAX = 16u;

// Maximum number of bytes in a device arguments string.
constexpr uint32_t DEVICE_ARGS_MAX = 1024u;

extern "C" const fidl_type_t v1_fuchsia_device_manager_Coordinator_RunCompatibilityTests_ResponseTable;

struct Coordinator_RunCompatibilityTests_Response {
  static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_Coordinator_RunCompatibilityTests_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_manager_Coordinator_PublishMetadata_ResponseTable;

struct Coordinator_PublishMetadata_Response {
  static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_Coordinator_PublishMetadata_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_manager_Coordinator_MakeVisible_ResponseTable;

struct Coordinator_MakeVisible_Response {
  static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_Coordinator_MakeVisible_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_manager_Coordinator_LoadFirmware_ResponseTable;

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

  ::zx::vmo vmo = {};

  uint64_t size = {};
};

extern "C" const fidl_type_t v1_fuchsia_device_manager_Coordinator_GetTopologicalPath_ResponseTable;

struct Coordinator_GetTopologicalPath_Response {
  static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_Coordinator_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_manager_Coordinator_GetMetadata_ResponseTable;

struct Coordinator_GetMetadata_Response {
  static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_Coordinator_GetMetadata_ResponseTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 16;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 8192;
  static constexpr bool HasPointer = true;

  ::fidl::VectorView<uint8_t> data = {};
};

extern "C" const fidl_type_t v1_fuchsia_device_manager_Coordinator_GetMetadataSize_ResponseTable;

struct Coordinator_GetMetadataSize_Response {
  static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_Coordinator_GetMetadataSize_ResponseTable;
  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;

  uint64_t size = {};
};

extern "C" const fidl_type_t v1_fuchsia_device_manager_Coordinator_DirectoryWatch_ResponseTable;

struct Coordinator_DirectoryWatch_Response {
  static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_Coordinator_DirectoryWatch_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_manager_Coordinator_BindDevice_ResponseTable;

struct Coordinator_BindDevice_Response {
  static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_Coordinator_BindDevice_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_manager_Coordinator_AddMetadata_ResponseTable;

struct Coordinator_AddMetadata_Response {
  static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_Coordinator_AddMetadata_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_manager_Coordinator_AddCompositeDevice_ResponseTable;

struct Coordinator_AddCompositeDevice_Response {
  static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_Coordinator_AddCompositeDevice_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_manager_DeviceControllerBindDriverRequestTable;
extern "C" const fidl_type_t v1_fuchsia_device_manager_DeviceControllerBindDriverResponseTable;
extern "C" const fidl_type_t v1_fuchsia_device_manager_DeviceControllerConnectProxyRequestTable;
extern "C" const fidl_type_t v1_fuchsia_device_manager_DeviceControllerConnectProxyResponseTable;
extern "C" const fidl_type_t v1_fuchsia_device_manager_DeviceControllerInitRequestTable;
extern "C" const fidl_type_t v1_fuchsia_device_manager_DeviceControllerInitResponseTable;
extern "C" const fidl_type_t v1_fuchsia_device_manager_DeviceControllerUnbindRequestTable;
extern "C" const fidl_type_t v1_fuchsia_device_manager_DeviceControllerUnbindResponseTable;
extern "C" const fidl_type_t v1_fuchsia_device_manager_DeviceControllerCompleteRemovalRequestTable;
extern "C" const fidl_type_t v1_fuchsia_device_manager_DeviceControllerCompleteRemovalResponseTable;
extern "C" const fidl_type_t v1_fuchsia_device_manager_DeviceControllerSuspendRequestTable;
extern "C" const fidl_type_t v1_fuchsia_device_manager_DeviceControllerSuspendResponseTable;
extern "C" const fidl_type_t v1_fuchsia_device_manager_DeviceControllerResumeRequestTable;
extern "C" const fidl_type_t v1_fuchsia_device_manager_DeviceControllerResumeResponseTable;
extern "C" const fidl_type_t v1_fuchsia_device_manager_DeviceControllerCompleteCompatibilityTestsRequestTable;
extern "C" const fidl_type_t v1_fuchsia_device_manager_DeviceControllerCompleteCompatibilityTestsResponseTable;

// Protocol for controlling devices in a devhost process from the devcoordinator
class DeviceController final {
  DeviceController() = delete;
 public:

  struct BindDriverResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t status;
    ::zx::channel test_output;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_DeviceControllerBindDriverResponseTable;
    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;
  };
  struct BindDriverRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::fidl::StringView driver_path;
    ::zx::vmo driver;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_DeviceControllerBindDriverRequestTable;
    static constexpr uint32_t MaxNumHandles = 1;
    static constexpr uint32_t PrimarySize = 40;
    static constexpr uint32_t MaxOutOfLine = 1024;
    static constexpr uint32_t AltPrimarySize = 40;
    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 = BindDriverResponse;
  };

  struct ConnectProxyRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::zx::channel shadow;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_DeviceControllerConnectProxyRequestTable;
    static constexpr uint32_t MaxNumHandles = 1;
    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;
  };

  struct InitResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t status;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_DeviceControllerInitResponseTable;
    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 InitRequest = ::fidl::AnyZeroArgMessage;

  struct UnbindResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::llcpp::fuchsia::device::manager::DeviceController_Unbind_Result result;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_DeviceControllerUnbindResponseTable;
    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 UnbindRequest = ::fidl::AnyZeroArgMessage;

  struct CompleteRemovalResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::llcpp::fuchsia::device::manager::DeviceController_CompleteRemoval_Result result;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_DeviceControllerCompleteRemovalResponseTable;
    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 CompleteRemovalRequest = ::fidl::AnyZeroArgMessage;

  struct SuspendResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t status;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_DeviceControllerSuspendResponseTable;
    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;
    uint32_t flags;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_DeviceControllerSuspendRequestTable;
    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;
    int32_t status;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_DeviceControllerResumeResponseTable;
    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 ResumeRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    uint32_t target_system_state;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_DeviceControllerResumeRequestTable;
    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 CompleteCompatibilityTestsRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::llcpp::fuchsia::device::manager::CompatibilityTestStatus status;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_DeviceControllerCompleteCompatibilityTestsRequestTable;
    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;
  };


  // Collection of return types of FIDL calls in this interface.
  class ResultOf final {
    ResultOf() = delete;
   private:
    template <typename ResponseType>
    class BindDriver_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      BindDriver_Impl(::zx::unowned_channel _client_end, ::fidl::StringView driver_path, ::zx::vmo driver);
      ~BindDriver_Impl() = default;
      BindDriver_Impl(BindDriver_Impl&& other) = default;
      BindDriver_Impl& operator=(BindDriver_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    class ConnectProxy_Impl final : private ::fidl::internal::StatusAndError {
      using Super = ::fidl::internal::StatusAndError;
     public:
      ConnectProxy_Impl(::zx::unowned_channel _client_end, ::zx::channel shadow);
      ~ConnectProxy_Impl() = default;
      ConnectProxy_Impl(ConnectProxy_Impl&& other) = default;
      ConnectProxy_Impl& operator=(ConnectProxy_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
    };
    template <typename ResponseType>
    class Init_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      Init_Impl(::zx::unowned_channel _client_end);
      ~Init_Impl() = default;
      Init_Impl(Init_Impl&& other) = default;
      Init_Impl& operator=(Init_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 Unbind_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      Unbind_Impl(::zx::unowned_channel _client_end);
      ~Unbind_Impl() = default;
      Unbind_Impl(Unbind_Impl&& other) = default;
      Unbind_Impl& operator=(Unbind_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 CompleteRemoval_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      CompleteRemoval_Impl(::zx::unowned_channel _client_end);
      ~CompleteRemoval_Impl() = default;
      CompleteRemoval_Impl(CompleteRemoval_Impl&& other) = default;
      CompleteRemoval_Impl& operator=(CompleteRemoval_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, uint32_t flags);
      ~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, uint32_t target_system_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*;
    };
    class CompleteCompatibilityTests_Impl final : private ::fidl::internal::StatusAndError {
      using Super = ::fidl::internal::StatusAndError;
     public:
      CompleteCompatibilityTests_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::manager::CompatibilityTestStatus status);
      ~CompleteCompatibilityTests_Impl() = default;
      CompleteCompatibilityTests_Impl(CompleteCompatibilityTests_Impl&& other) = default;
      CompleteCompatibilityTests_Impl& operator=(CompleteCompatibilityTests_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
    };

   public:
    using BindDriver = BindDriver_Impl<BindDriverResponse>;
    using ConnectProxy = ConnectProxy_Impl;
    using Init = Init_Impl<InitResponse>;
    using Unbind = Unbind_Impl<UnbindResponse>;
    using CompleteRemoval = CompleteRemoval_Impl<CompleteRemovalResponse>;
    using Suspend = Suspend_Impl<SuspendResponse>;
    using Resume = Resume_Impl<ResumeResponse>;
    using CompleteCompatibilityTests = CompleteCompatibilityTests_Impl;
  };

  // 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 BindDriver_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      BindDriver_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView driver_path, ::zx::vmo driver, ::fidl::BytePart _response_buffer);
      ~BindDriver_Impl() = default;
      BindDriver_Impl(BindDriver_Impl&& other) = default;
      BindDriver_Impl& operator=(BindDriver_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    class ConnectProxy_Impl final : private ::fidl::internal::StatusAndError {
      using Super = ::fidl::internal::StatusAndError;
     public:
      ConnectProxy_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel shadow);
      ~ConnectProxy_Impl() = default;
      ConnectProxy_Impl(ConnectProxy_Impl&& other) = default;
      ConnectProxy_Impl& operator=(ConnectProxy_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
    };
    template <typename ResponseType>
    class Init_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      Init_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
      ~Init_Impl() = default;
      Init_Impl(Init_Impl&& other) = default;
      Init_Impl& operator=(Init_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 Unbind_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      Unbind_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
      ~Unbind_Impl() = default;
      Unbind_Impl(Unbind_Impl&& other) = default;
      Unbind_Impl& operator=(Unbind_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 CompleteRemoval_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      CompleteRemoval_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
      ~CompleteRemoval_Impl() = default;
      CompleteRemoval_Impl(CompleteRemoval_Impl&& other) = default;
      CompleteRemoval_Impl& operator=(CompleteRemoval_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, uint32_t flags, ::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, uint32_t target_system_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*;
    };
    class CompleteCompatibilityTests_Impl final : private ::fidl::internal::StatusAndError {
      using Super = ::fidl::internal::StatusAndError;
     public:
      CompleteCompatibilityTests_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::manager::CompatibilityTestStatus status);
      ~CompleteCompatibilityTests_Impl() = default;
      CompleteCompatibilityTests_Impl(CompleteCompatibilityTests_Impl&& other) = default;
      CompleteCompatibilityTests_Impl& operator=(CompleteCompatibilityTests_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
    };

   public:
    using BindDriver = BindDriver_Impl<BindDriverResponse>;
    using ConnectProxy = ConnectProxy_Impl;
    using Init = Init_Impl<InitResponse>;
    using Unbind = Unbind_Impl<UnbindResponse>;
    using CompleteRemoval = CompleteRemoval_Impl<CompleteRemovalResponse>;
    using Suspend = Suspend_Impl<SuspendResponse>;
    using Resume = Resume_Impl<ResumeResponse>;
    using CompleteCompatibilityTests = CompleteCompatibilityTests_Impl;
  };

  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_; }

    // Bind the requested driver to this device.  `driver_path` is informational,
    // but all calls to BindDriver/CreateDevice should use the same `driver_path`
    // each time they use a `driver` VMO with the same contents. Returns a `status`
    // and optionally a channel to the driver's test output. `test_output` will be
    // not present unless the driver is configured to run its run_unit_tests hook, in
    // which case the other end of the channel will have been passed to the driver.
    // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
    ResultOf::BindDriver BindDriver(::fidl::StringView driver_path, ::zx::vmo driver);

    // Bind the requested driver to this device.  `driver_path` is informational,
    // but all calls to BindDriver/CreateDevice should use the same `driver_path`
    // each time they use a `driver` VMO with the same contents. Returns a `status`
    // and optionally a channel to the driver's test output. `test_output` will be
    // not present unless the driver is configured to run its run_unit_tests hook, in
    // which case the other end of the channel will have been passed to the driver.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::BindDriver BindDriver(::fidl::BytePart _request_buffer, ::fidl::StringView driver_path, ::zx::vmo driver, ::fidl::BytePart _response_buffer);

    // Give this device a channel to its shadow in another process.
    // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::ConnectProxy ConnectProxy(::zx::channel shadow);

    // Give this device a channel to its shadow in another process.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::ConnectProxy ConnectProxy(::fidl::BytePart _request_buffer, ::zx::channel shadow);

    // Ask devhost to call the device init hook.
    // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::Init Init();

    // Ask devhost to call the device init hook.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::Init Init(::fidl::BytePart _response_buffer);

    // Ask devhost to unbind this device. On success, the remote end of this
    // interface channel will close instead of returning a result.
    // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::Unbind Unbind();

    // Ask devhost to unbind this device. On success, the remote end of this
    // interface channel will close instead of returning a result.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::Unbind Unbind(::fidl::BytePart _response_buffer);

    // Ask the devhost to complete the removal of this device, which previously had
    // invoked |ScheduleRemove|. This is a special case that can be removed
    // once |device_remove| invokes |unbind|.
    // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::CompleteRemoval CompleteRemoval();

    // Ask the devhost to complete the removal of this device, which previously had
    // invoked |ScheduleRemove|. This is a special case that can be removed
    // once |device_remove| invokes |unbind|.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::CompleteRemoval CompleteRemoval(::fidl::BytePart _response_buffer);

    // Ask devhost to suspend this device, using the target state indicated by `flags`.
    // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::Suspend Suspend(uint32_t flags);

    // Ask devhost to suspend this device, using the target state indicated by `flags`.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::Suspend Suspend(::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer);

    // Ask devhost to resume this device, using the target system state indicated by
    // 'target_system_state'.
    // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::Resume Resume(uint32_t target_system_state);

    // Ask devhost to resume this device, using the target system state indicated by
    // 'target_system_state'.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::Resume Resume(::fidl::BytePart _request_buffer, uint32_t target_system_state, ::fidl::BytePart _response_buffer);

    // Inform devhost about the compatibility test status when compatibility tests
    // fail or complete successfully.
    // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::CompleteCompatibilityTests CompleteCompatibilityTests(::llcpp::fuchsia::device::manager::CompatibilityTestStatus status);

    // Inform devhost about the compatibility test status when compatibility tests
    // fail or complete successfully.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::CompleteCompatibilityTests CompleteCompatibilityTests(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::manager::CompatibilityTestStatus status);

   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:

    // Bind the requested driver to this device.  `driver_path` is informational,
    // but all calls to BindDriver/CreateDevice should use the same `driver_path`
    // each time they use a `driver` VMO with the same contents. Returns a `status`
    // and optionally a channel to the driver's test output. `test_output` will be
    // not present unless the driver is configured to run its run_unit_tests hook, in
    // which case the other end of the channel will have been passed to the driver.
    // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
    static ResultOf::BindDriver BindDriver(::zx::unowned_channel _client_end, ::fidl::StringView driver_path, ::zx::vmo driver);

    // Bind the requested driver to this device.  `driver_path` is informational,
    // but all calls to BindDriver/CreateDevice should use the same `driver_path`
    // each time they use a `driver` VMO with the same contents. Returns a `status`
    // and optionally a channel to the driver's test output. `test_output` will be
    // not present unless the driver is configured to run its run_unit_tests hook, in
    // which case the other end of the channel will have been passed to the driver.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::BindDriver BindDriver(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView driver_path, ::zx::vmo driver, ::fidl::BytePart _response_buffer);

    // Give this device a channel to its shadow in another process.
    // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::ConnectProxy ConnectProxy(::zx::unowned_channel _client_end, ::zx::channel shadow);

    // Give this device a channel to its shadow in another process.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::ConnectProxy ConnectProxy(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel shadow);

    // Ask devhost to call the device init hook.
    // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::Init Init(::zx::unowned_channel _client_end);

    // Ask devhost to call the device init hook.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::Init Init(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);

    // Ask devhost to unbind this device. On success, the remote end of this
    // interface channel will close instead of returning a result.
    // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::Unbind Unbind(::zx::unowned_channel _client_end);

    // Ask devhost to unbind this device. On success, the remote end of this
    // interface channel will close instead of returning a result.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::Unbind Unbind(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);

    // Ask the devhost to complete the removal of this device, which previously had
    // invoked |ScheduleRemove|. This is a special case that can be removed
    // once |device_remove| invokes |unbind|.
    // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::CompleteRemoval CompleteRemoval(::zx::unowned_channel _client_end);

    // Ask the devhost to complete the removal of this device, which previously had
    // invoked |ScheduleRemove|. This is a special case that can be removed
    // once |device_remove| invokes |unbind|.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::CompleteRemoval CompleteRemoval(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);

    // Ask devhost to suspend this device, using the target state indicated by `flags`.
    // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::Suspend Suspend(::zx::unowned_channel _client_end, uint32_t flags);

    // Ask devhost to suspend this device, using the target state indicated by `flags`.
    // 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, uint32_t flags, ::fidl::BytePart _response_buffer);

    // Ask devhost to resume this device, using the target system state indicated by
    // 'target_system_state'.
    // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::Resume Resume(::zx::unowned_channel _client_end, uint32_t target_system_state);

    // Ask devhost to resume this device, using the target system state indicated by
    // 'target_system_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, uint32_t target_system_state, ::fidl::BytePart _response_buffer);

    // Inform devhost about the compatibility test status when compatibility tests
    // fail or complete successfully.
    // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::CompleteCompatibilityTests CompleteCompatibilityTests(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::manager::CompatibilityTestStatus status);

    // Inform devhost about the compatibility test status when compatibility tests
    // fail or complete successfully.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::CompleteCompatibilityTests CompleteCompatibilityTests(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::manager::CompatibilityTestStatus status);

  };

  // 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:

    // Bind the requested driver to this device.  `driver_path` is informational,
    // but all calls to BindDriver/CreateDevice should use the same `driver_path`
    // each time they use a `driver` VMO with the same contents. Returns a `status`
    // and optionally a channel to the driver's test output. `test_output` will be
    // not present unless the driver is configured to run its run_unit_tests hook, in
    // which case the other end of the channel will have been passed to the driver.
    static ::fidl::DecodeResult<BindDriverResponse> BindDriver(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<BindDriverRequest> params, ::fidl::BytePart response_buffer);

    // Give this device a channel to its shadow in another process.
    static ::fidl::internal::StatusAndError ConnectProxy(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ConnectProxyRequest> params);

    // Ask devhost to call the device init hook.
    static ::fidl::DecodeResult<InitResponse> Init(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);

    // Ask devhost to unbind this device. On success, the remote end of this
    // interface channel will close instead of returning a result.
    static ::fidl::DecodeResult<UnbindResponse> Unbind(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);

    // Ask the devhost to complete the removal of this device, which previously had
    // invoked |ScheduleRemove|. This is a special case that can be removed
    // once |device_remove| invokes |unbind|.
    static ::fidl::DecodeResult<CompleteRemovalResponse> CompleteRemoval(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);

    // Ask devhost to suspend this device, using the target state indicated by `flags`.
    static ::fidl::DecodeResult<SuspendResponse> Suspend(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SuspendRequest> params, ::fidl::BytePart response_buffer);

    // Ask devhost to resume this device, using the target system state indicated by
    // 'target_system_state'.
    static ::fidl::DecodeResult<ResumeResponse> Resume(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ResumeRequest> params, ::fidl::BytePart response_buffer);

    // Inform devhost about the compatibility test status when compatibility tests
    // fail or complete successfully.
    static ::fidl::internal::StatusAndError CompleteCompatibilityTests(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CompleteCompatibilityTestsRequest> params);

  };

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

    class BindDriverCompleterBase : public _Base {
     public:
      void Reply(int32_t status, ::zx::channel test_output);
      void Reply(::fidl::BytePart _buffer, int32_t status, ::zx::channel test_output);
      void Reply(::fidl::DecodedMessage<BindDriverResponse> params);

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

    using BindDriverCompleter = ::fidl::Completer<BindDriverCompleterBase>;

    virtual void BindDriver(::fidl::StringView driver_path, ::zx::vmo driver, BindDriverCompleter::Sync _completer) = 0;

    using ConnectProxyCompleter = ::fidl::Completer<>;

    virtual void ConnectProxy(::zx::channel shadow, ConnectProxyCompleter::Sync _completer) = 0;

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

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

    using InitCompleter = ::fidl::Completer<InitCompleterBase>;

    virtual void Init(InitCompleter::Sync _completer) = 0;

    class UnbindCompleterBase : public _Base {
     public:
      void Reply(::llcpp::fuchsia::device::manager::DeviceController_Unbind_Result result);
      void ReplySuccess();
      void ReplyError(int32_t error);
      void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::manager::DeviceController_Unbind_Result result);
      void ReplySuccess(::fidl::BytePart _buffer);
      void Reply(::fidl::DecodedMessage<UnbindResponse> params);

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

    using UnbindCompleter = ::fidl::Completer<UnbindCompleterBase>;

    virtual void Unbind(UnbindCompleter::Sync _completer) = 0;

    class CompleteRemovalCompleterBase : public _Base {
     public:
      void Reply(::llcpp::fuchsia::device::manager::DeviceController_CompleteRemoval_Result result);
      void ReplySuccess();
      void ReplyError(int32_t error);
      void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::manager::DeviceController_CompleteRemoval_Result result);
      void ReplySuccess(::fidl::BytePart _buffer);
      void Reply(::fidl::DecodedMessage<CompleteRemovalResponse> params);

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

    using CompleteRemovalCompleter = ::fidl::Completer<CompleteRemovalCompleterBase>;

    virtual void CompleteRemoval(CompleteRemovalCompleter::Sync _completer) = 0;

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

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

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

    virtual void Suspend(uint32_t flags, SuspendCompleter::Sync _completer) = 0;

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

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

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

    virtual void Resume(uint32_t target_system_state, ResumeCompleter::Sync _completer) = 0;

    using CompleteCompatibilityTestsCompleter = ::fidl::Completer<>;

    virtual void CompleteCompatibilityTests(::llcpp::fuchsia::device::manager::CompatibilityTestStatus status, CompleteCompatibilityTestsCompleter::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 BindDriverRequest(const ::fidl::DecodedMessage<DeviceController::BindDriverRequest>& _msg);
    static void BindDriverResponse(const ::fidl::DecodedMessage<DeviceController::BindDriverResponse>& _msg);
    static void ConnectProxyRequest(const ::fidl::DecodedMessage<DeviceController::ConnectProxyRequest>& _msg);
    static void InitRequest(const ::fidl::DecodedMessage<DeviceController::InitRequest>& _msg);
    static void InitResponse(const ::fidl::DecodedMessage<DeviceController::InitResponse>& _msg);
    static void UnbindRequest(const ::fidl::DecodedMessage<DeviceController::UnbindRequest>& _msg);
    static void UnbindResponse(const ::fidl::DecodedMessage<DeviceController::UnbindResponse>& _msg);
    static void CompleteRemovalRequest(const ::fidl::DecodedMessage<DeviceController::CompleteRemovalRequest>& _msg);
    static void CompleteRemovalResponse(const ::fidl::DecodedMessage<DeviceController::CompleteRemovalResponse>& _msg);
    static void SuspendRequest(const ::fidl::DecodedMessage<DeviceController::SuspendRequest>& _msg);
    static void SuspendResponse(const ::fidl::DecodedMessage<DeviceController::SuspendResponse>& _msg);
    static void ResumeRequest(const ::fidl::DecodedMessage<DeviceController::ResumeRequest>& _msg);
    static void ResumeResponse(const ::fidl::DecodedMessage<DeviceController::ResumeResponse>& _msg);
    static void CompleteCompatibilityTestsRequest(const ::fidl::DecodedMessage<DeviceController::CompleteCompatibilityTestsRequest>& _msg);
  };
};

// Maximum number of components that a composite device can have
constexpr uint32_t COMPONENTS_MAX = 16u;

extern "C" const fidl_type_t v1_fuchsia_device_manager_BindInstructionTable;

struct BindInstruction {
  static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_BindInstructionTable;
  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;

  // bitfield that encodes the operation and execution conditions
  uint32_t op = {};

  // bitfield that encodes the arguments
  uint32_t arg = {};
};

extern "C" const fidl_type_t v1_fuchsia_device_manager_DeviceComponentPartTable;

// A part of a description of a DeviceComponent
struct DeviceComponentPart {
  static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_DeviceComponentPartTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 260;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 0;
  static constexpr bool HasPointer = false;

  uint32_t match_program_count = {};

  ::fidl::Array<::llcpp::fuchsia::device::manager::BindInstruction, 32> match_program = {};
};

extern "C" const fidl_type_t v1_fuchsia_device_manager_DeviceComponentTable;

// A piece of a composite device
struct DeviceComponent {
  static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_DeviceComponentTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 4164;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 0;
  static constexpr bool HasPointer = false;

  uint32_t parts_count = {};

  ::fidl::Array<::llcpp::fuchsia::device::manager::DeviceComponentPart, 16> parts = {};
};

extern "C" const fidl_type_t v1_fuchsia_device_manager_CompositeDeviceDescriptorTable;

// Composite device parts and properties
struct CompositeDeviceDescriptor {
  static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_CompositeDeviceDescriptorTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 56;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 331584;
  static constexpr bool HasPointer = true;

  ::fidl::VectorView<uint64_t> props = {};

  ::fidl::VectorView<::llcpp::fuchsia::device::manager::DeviceComponent> components = {};

  uint32_t coresident_device_index = {};

  ::fidl::VectorView<::llcpp::fuchsia::device::manager::DeviceMetadata> metadata = {};
};

extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorAddDeviceRequestTable;
extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorAddDeviceResponseTable;
extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorAddDeviceInvisibleRequestTable;
extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorAddDeviceInvisibleResponseTable;
extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorScheduleRemoveRequestTable;
extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorScheduleRemoveResponseTable;
extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorScheduleUnbindChildrenRequestTable;
extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorScheduleUnbindChildrenResponseTable;
extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorMakeVisibleRequestTable;
extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorMakeVisibleResponseTable;
extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorBindDeviceRequestTable;
extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorBindDeviceResponseTable;
extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorGetTopologicalPathRequestTable;
extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorGetTopologicalPathResponseTable;
extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorLoadFirmwareRequestTable;
extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorLoadFirmwareResponseTable;
extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorGetMetadataRequestTable;
extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorGetMetadataResponseTable;
extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorGetMetadataSizeRequestTable;
extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorGetMetadataSizeResponseTable;
extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorAddMetadataRequestTable;
extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorAddMetadataResponseTable;
extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorPublishMetadataRequestTable;
extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorPublishMetadataResponseTable;
extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorAddCompositeDeviceRequestTable;
extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorAddCompositeDeviceResponseTable;
extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorDirectoryWatchRequestTable;
extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorDirectoryWatchResponseTable;
extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorRunCompatibilityTestsRequestTable;
extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorRunCompatibilityTestsResponseTable;

// Interface for the devices in devhosts to coordinate with the devcoordinator.
class Coordinator final {
  Coordinator() = delete;
 public:

  struct AddDeviceResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::llcpp::fuchsia::device::manager::Coordinator_AddDevice_Result result;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_CoordinatorAddDeviceResponseTable;
    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 AddDeviceRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::zx::channel coordinator;
    ::zx::channel device_controller;
    ::fidl::VectorView<uint64_t> props;
    ::fidl::StringView name;
    uint32_t protocol_id;
    ::fidl::StringView driver_path;
    ::fidl::StringView args;
    ::llcpp::fuchsia::device::manager::AddDeviceConfig device_add_config;
    bool has_init;
    ::zx::channel client_remote;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_CoordinatorAddDeviceRequestTable;
    static constexpr uint32_t MaxNumHandles = 3;
    static constexpr uint32_t PrimarySize = 112;
    static constexpr uint32_t MaxOutOfLine = 4128;
    static constexpr uint32_t AltPrimarySize = 112;
    static constexpr uint32_t AltMaxOutOfLine = 4128;
    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 = AddDeviceResponse;
  };

  struct AddDeviceInvisibleResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::llcpp::fuchsia::device::manager::Coordinator_AddDeviceInvisible_Result result;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_CoordinatorAddDeviceInvisibleResponseTable;
    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 AddDeviceInvisibleRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::zx::channel coordinator;
    ::zx::channel device_controller;
    ::fidl::VectorView<uint64_t> props;
    ::fidl::StringView name;
    uint32_t protocol_id;
    ::fidl::StringView driver_path;
    ::fidl::StringView args;
    bool has_init;
    ::zx::channel client_remote;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_CoordinatorAddDeviceInvisibleRequestTable;
    static constexpr uint32_t MaxNumHandles = 3;
    static constexpr uint32_t PrimarySize = 104;
    static constexpr uint32_t MaxOutOfLine = 4128;
    static constexpr uint32_t AltPrimarySize = 104;
    static constexpr uint32_t AltMaxOutOfLine = 4128;
    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 = AddDeviceInvisibleResponse;
  };

  struct ScheduleRemoveRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    bool unbind_self;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_CoordinatorScheduleRemoveRequestTable;
    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 ScheduleUnbindChildrenRequest = ::fidl::AnyZeroArgMessage;

  struct MakeVisibleResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::llcpp::fuchsia::device::manager::Coordinator_MakeVisible_Result result;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_CoordinatorMakeVisibleResponseTable;
    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 MakeVisibleRequest = ::fidl::AnyZeroArgMessage;

  struct BindDeviceResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::llcpp::fuchsia::device::manager::Coordinator_BindDevice_Result result;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_CoordinatorBindDeviceResponseTable;
    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 BindDeviceRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::fidl::StringView driver_path;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_CoordinatorBindDeviceRequestTable;
    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 = BindDeviceResponse;
  };

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

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_CoordinatorGetTopologicalPathResponseTable;
    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 LoadFirmwareResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::llcpp::fuchsia::device::manager::Coordinator_LoadFirmware_Result result;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_CoordinatorLoadFirmwareResponseTable;
    static constexpr uint32_t MaxNumHandles = 1;
    static constexpr uint32_t PrimarySize = 40;
    static constexpr uint32_t MaxOutOfLine = 16;
    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 LoadFirmwareRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::fidl::StringView fw_path;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_CoordinatorLoadFirmwareRequestTable;
    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 = LoadFirmwareResponse;
  };

  struct GetMetadataResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::llcpp::fuchsia::device::manager::Coordinator_GetMetadata_Result result;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_CoordinatorGetMetadataResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 40;
    static constexpr uint32_t MaxOutOfLine = 8208;
    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 GetMetadataRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    uint32_t key;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_CoordinatorGetMetadataRequestTable;
    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 = GetMetadataResponse;
  };

  struct GetMetadataSizeResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::llcpp::fuchsia::device::manager::Coordinator_GetMetadataSize_Result result;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_CoordinatorGetMetadataSizeResponseTable;
    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 GetMetadataSizeRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    uint32_t key;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_CoordinatorGetMetadataSizeRequestTable;
    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 = GetMetadataSizeResponse;
  };

  struct AddMetadataResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::llcpp::fuchsia::device::manager::Coordinator_AddMetadata_Result result;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_CoordinatorAddMetadataResponseTable;
    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 AddMetadataRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    uint32_t key;
    ::fidl::VectorView<uint8_t> data;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_CoordinatorAddMetadataRequestTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 40;
    static constexpr uint32_t MaxOutOfLine = 8192;
    static constexpr uint32_t AltPrimarySize = 40;
    static constexpr uint32_t AltMaxOutOfLine = 8192;
    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 = AddMetadataResponse;
  };

  struct PublishMetadataResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::llcpp::fuchsia::device::manager::Coordinator_PublishMetadata_Result result;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_CoordinatorPublishMetadataResponseTable;
    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 PublishMetadataRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::fidl::StringView device_path;
    uint32_t key;
    ::fidl::VectorView<uint8_t> data;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_CoordinatorPublishMetadataRequestTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 56;
    static constexpr uint32_t MaxOutOfLine = 9216;
    static constexpr uint32_t AltPrimarySize = 56;
    static constexpr uint32_t AltMaxOutOfLine = 9216;
    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 = PublishMetadataResponse;
  };

  struct AddCompositeDeviceResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::llcpp::fuchsia::device::manager::Coordinator_AddCompositeDevice_Result result;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_CoordinatorAddCompositeDeviceResponseTable;
    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 AddCompositeDeviceRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::fidl::StringView name;
    ::llcpp::fuchsia::device::manager::CompositeDeviceDescriptor comp_desc;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_CoordinatorAddCompositeDeviceRequestTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 88;
    static constexpr uint32_t MaxOutOfLine = 331616;
    static constexpr uint32_t AltPrimarySize = 88;
    static constexpr uint32_t AltMaxOutOfLine = 331616;
    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 = AddCompositeDeviceResponse;
  };

  struct DirectoryWatchResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::llcpp::fuchsia::device::manager::Coordinator_DirectoryWatch_Result result;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_CoordinatorDirectoryWatchResponseTable;
    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 DirectoryWatchRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    uint32_t mask;
    uint32_t options;
    ::zx::channel watcher;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_CoordinatorDirectoryWatchRequestTable;
    static constexpr uint32_t MaxNumHandles = 1;
    static constexpr uint32_t PrimarySize = 32;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr uint32_t AltPrimarySize = 32;
    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 = DirectoryWatchResponse;
  };

  struct RunCompatibilityTestsResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::llcpp::fuchsia::device::manager::Coordinator_RunCompatibilityTests_Result result;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_CoordinatorRunCompatibilityTestsResponseTable;
    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 RunCompatibilityTestsRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int64_t hook_wait_time;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_CoordinatorRunCompatibilityTestsRequestTable;
    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;
  };


  // Collection of return types of FIDL calls in this interface.
  class ResultOf final {
    ResultOf() = delete;
   private:
    template <typename ResponseType>
    class AddDevice_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      AddDevice_Impl(::zx::unowned_channel _client_end, ::zx::channel coordinator, ::zx::channel device_controller, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, ::llcpp::fuchsia::device::manager::AddDeviceConfig device_add_config, bool has_init, ::zx::channel client_remote);
      ~AddDevice_Impl() = default;
      AddDevice_Impl(AddDevice_Impl&& other) = default;
      AddDevice_Impl& operator=(AddDevice_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 AddDeviceInvisible_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      AddDeviceInvisible_Impl(::zx::unowned_channel _client_end, ::zx::channel coordinator, ::zx::channel device_controller, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, bool has_init, ::zx::channel client_remote);
      ~AddDeviceInvisible_Impl() = default;
      AddDeviceInvisible_Impl(AddDeviceInvisible_Impl&& other) = default;
      AddDeviceInvisible_Impl& operator=(AddDeviceInvisible_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    class ScheduleRemove_Impl final : private ::fidl::internal::StatusAndError {
      using Super = ::fidl::internal::StatusAndError;
     public:
      ScheduleRemove_Impl(::zx::unowned_channel _client_end, bool unbind_self);
      ~ScheduleRemove_Impl() = default;
      ScheduleRemove_Impl(ScheduleRemove_Impl&& other) = default;
      ScheduleRemove_Impl& operator=(ScheduleRemove_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
    };
    class ScheduleUnbindChildren_Impl final : private ::fidl::internal::StatusAndError {
      using Super = ::fidl::internal::StatusAndError;
     public:
      ScheduleUnbindChildren_Impl(::zx::unowned_channel _client_end);
      ~ScheduleUnbindChildren_Impl() = default;
      ScheduleUnbindChildren_Impl(ScheduleUnbindChildren_Impl&& other) = default;
      ScheduleUnbindChildren_Impl& operator=(ScheduleUnbindChildren_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
    };
    template <typename ResponseType>
    class MakeVisible_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      MakeVisible_Impl(::zx::unowned_channel _client_end);
      ~MakeVisible_Impl() = default;
      MakeVisible_Impl(MakeVisible_Impl&& other) = default;
      MakeVisible_Impl& operator=(MakeVisible_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 BindDevice_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      BindDevice_Impl(::zx::unowned_channel _client_end, ::fidl::StringView driver_path);
      ~BindDevice_Impl() = default;
      BindDevice_Impl(BindDevice_Impl&& other) = default;
      BindDevice_Impl& operator=(BindDevice_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 LoadFirmware_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      LoadFirmware_Impl(::zx::unowned_channel _client_end, ::fidl::StringView fw_path);
      ~LoadFirmware_Impl() = default;
      LoadFirmware_Impl(LoadFirmware_Impl&& other) = default;
      LoadFirmware_Impl& operator=(LoadFirmware_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 GetMetadata_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      GetMetadata_Impl(::zx::unowned_channel _client_end, uint32_t key);
      ~GetMetadata_Impl() = default;
      GetMetadata_Impl(GetMetadata_Impl&& other) = default;
      GetMetadata_Impl& operator=(GetMetadata_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 GetMetadataSize_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      GetMetadataSize_Impl(::zx::unowned_channel _client_end, uint32_t key);
      ~GetMetadataSize_Impl() = default;
      GetMetadataSize_Impl(GetMetadataSize_Impl&& other) = default;
      GetMetadataSize_Impl& operator=(GetMetadataSize_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 AddMetadata_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      AddMetadata_Impl(::zx::unowned_channel _client_end, uint32_t key, ::fidl::VectorView<uint8_t> data);
      ~AddMetadata_Impl() = default;
      AddMetadata_Impl(AddMetadata_Impl&& other) = default;
      AddMetadata_Impl& operator=(AddMetadata_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 PublishMetadata_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      PublishMetadata_Impl(::zx::unowned_channel _client_end, ::fidl::StringView device_path, uint32_t key, ::fidl::VectorView<uint8_t> data);
      ~PublishMetadata_Impl() = default;
      PublishMetadata_Impl(PublishMetadata_Impl&& other) = default;
      PublishMetadata_Impl& operator=(PublishMetadata_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 AddCompositeDevice_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      AddCompositeDevice_Impl(::zx::unowned_channel _client_end, ::fidl::StringView name, ::llcpp::fuchsia::device::manager::CompositeDeviceDescriptor comp_desc);
      ~AddCompositeDevice_Impl() = default;
      AddCompositeDevice_Impl(AddCompositeDevice_Impl&& other) = default;
      AddCompositeDevice_Impl& operator=(AddCompositeDevice_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 DirectoryWatch_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      DirectoryWatch_Impl(::zx::unowned_channel _client_end, uint32_t mask, uint32_t options, ::zx::channel watcher);
      ~DirectoryWatch_Impl() = default;
      DirectoryWatch_Impl(DirectoryWatch_Impl&& other) = default;
      DirectoryWatch_Impl& operator=(DirectoryWatch_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*;
    };

   public:
    using AddDevice = AddDevice_Impl<AddDeviceResponse>;
    using AddDeviceInvisible = AddDeviceInvisible_Impl<AddDeviceInvisibleResponse>;
    using ScheduleRemove = ScheduleRemove_Impl;
    using ScheduleUnbindChildren = ScheduleUnbindChildren_Impl;
    using MakeVisible = MakeVisible_Impl<MakeVisibleResponse>;
    using BindDevice = BindDevice_Impl<BindDeviceResponse>;
    using GetTopologicalPath = GetTopologicalPath_Impl<GetTopologicalPathResponse>;
    using LoadFirmware = LoadFirmware_Impl<LoadFirmwareResponse>;
    using GetMetadata = GetMetadata_Impl<GetMetadataResponse>;
    using GetMetadataSize = GetMetadataSize_Impl<GetMetadataSizeResponse>;
    using AddMetadata = AddMetadata_Impl<AddMetadataResponse>;
    using PublishMetadata = PublishMetadata_Impl<PublishMetadataResponse>;
    using AddCompositeDevice = AddCompositeDevice_Impl<AddCompositeDeviceResponse>;
    using DirectoryWatch = DirectoryWatch_Impl<DirectoryWatchResponse>;
    using RunCompatibilityTests = RunCompatibilityTests_Impl<RunCompatibilityTestsResponse>;
  };

  // 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 AddDevice_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      AddDevice_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel coordinator, ::zx::channel device_controller, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, ::llcpp::fuchsia::device::manager::AddDeviceConfig device_add_config, bool has_init, ::zx::channel client_remote, ::fidl::BytePart _response_buffer);
      ~AddDevice_Impl() = default;
      AddDevice_Impl(AddDevice_Impl&& other) = default;
      AddDevice_Impl& operator=(AddDevice_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 AddDeviceInvisible_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      AddDeviceInvisible_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel coordinator, ::zx::channel device_controller, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, bool has_init, ::zx::channel client_remote, ::fidl::BytePart _response_buffer);
      ~AddDeviceInvisible_Impl() = default;
      AddDeviceInvisible_Impl(AddDeviceInvisible_Impl&& other) = default;
      AddDeviceInvisible_Impl& operator=(AddDeviceInvisible_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
      using Super::Unwrap;
      using Super::value;
      using Super::operator->;
      using Super::operator*;
    };
    class ScheduleRemove_Impl final : private ::fidl::internal::StatusAndError {
      using Super = ::fidl::internal::StatusAndError;
     public:
      ScheduleRemove_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool unbind_self);
      ~ScheduleRemove_Impl() = default;
      ScheduleRemove_Impl(ScheduleRemove_Impl&& other) = default;
      ScheduleRemove_Impl& operator=(ScheduleRemove_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
    };
    class ScheduleUnbindChildren_Impl final : private ::fidl::internal::StatusAndError {
      using Super = ::fidl::internal::StatusAndError;
     public:
      ScheduleUnbindChildren_Impl(::zx::unowned_channel _client_end);
      ~ScheduleUnbindChildren_Impl() = default;
      ScheduleUnbindChildren_Impl(ScheduleUnbindChildren_Impl&& other) = default;
      ScheduleUnbindChildren_Impl& operator=(ScheduleUnbindChildren_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
    };
    template <typename ResponseType>
    class MakeVisible_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      MakeVisible_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
      ~MakeVisible_Impl() = default;
      MakeVisible_Impl(MakeVisible_Impl&& other) = default;
      MakeVisible_Impl& operator=(MakeVisible_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 BindDevice_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      BindDevice_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView driver_path, ::fidl::BytePart _response_buffer);
      ~BindDevice_Impl() = default;
      BindDevice_Impl(BindDevice_Impl&& other) = default;
      BindDevice_Impl& operator=(BindDevice_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 LoadFirmware_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      LoadFirmware_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView fw_path, ::fidl::BytePart _response_buffer);
      ~LoadFirmware_Impl() = default;
      LoadFirmware_Impl(LoadFirmware_Impl&& other) = default;
      LoadFirmware_Impl& operator=(LoadFirmware_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 GetMetadata_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      GetMetadata_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t key, ::fidl::BytePart _response_buffer);
      ~GetMetadata_Impl() = default;
      GetMetadata_Impl(GetMetadata_Impl&& other) = default;
      GetMetadata_Impl& operator=(GetMetadata_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 GetMetadataSize_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      GetMetadataSize_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t key, ::fidl::BytePart _response_buffer);
      ~GetMetadataSize_Impl() = default;
      GetMetadataSize_Impl(GetMetadataSize_Impl&& other) = default;
      GetMetadataSize_Impl& operator=(GetMetadataSize_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 AddMetadata_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      AddMetadata_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t key, ::fidl::VectorView<uint8_t> data, ::fidl::BytePart _response_buffer);
      ~AddMetadata_Impl() = default;
      AddMetadata_Impl(AddMetadata_Impl&& other) = default;
      AddMetadata_Impl& operator=(AddMetadata_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 PublishMetadata_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      PublishMetadata_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView device_path, uint32_t key, ::fidl::VectorView<uint8_t> data, ::fidl::BytePart _response_buffer);
      ~PublishMetadata_Impl() = default;
      PublishMetadata_Impl(PublishMetadata_Impl&& other) = default;
      PublishMetadata_Impl& operator=(PublishMetadata_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 AddCompositeDevice_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      AddCompositeDevice_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView name, ::llcpp::fuchsia::device::manager::CompositeDeviceDescriptor comp_desc, ::fidl::BytePart _response_buffer);
      ~AddCompositeDevice_Impl() = default;
      AddCompositeDevice_Impl(AddCompositeDevice_Impl&& other) = default;
      AddCompositeDevice_Impl& operator=(AddCompositeDevice_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 DirectoryWatch_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      DirectoryWatch_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t mask, uint32_t options, ::zx::channel watcher, ::fidl::BytePart _response_buffer);
      ~DirectoryWatch_Impl() = default;
      DirectoryWatch_Impl(DirectoryWatch_Impl&& other) = default;
      DirectoryWatch_Impl& operator=(DirectoryWatch_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*;
    };

   public:
    using AddDevice = AddDevice_Impl<AddDeviceResponse>;
    using AddDeviceInvisible = AddDeviceInvisible_Impl<AddDeviceInvisibleResponse>;
    using ScheduleRemove = ScheduleRemove_Impl;
    using ScheduleUnbindChildren = ScheduleUnbindChildren_Impl;
    using MakeVisible = MakeVisible_Impl<MakeVisibleResponse>;
    using BindDevice = BindDevice_Impl<BindDeviceResponse>;
    using GetTopologicalPath = GetTopologicalPath_Impl<GetTopologicalPathResponse>;
    using LoadFirmware = LoadFirmware_Impl<LoadFirmwareResponse>;
    using GetMetadata = GetMetadata_Impl<GetMetadataResponse>;
    using GetMetadataSize = GetMetadataSize_Impl<GetMetadataSizeResponse>;
    using AddMetadata = AddMetadata_Impl<AddMetadataResponse>;
    using PublishMetadata = PublishMetadata_Impl<PublishMetadataResponse>;
    using AddCompositeDevice = AddCompositeDevice_Impl<AddCompositeDeviceResponse>;
    using DirectoryWatch = DirectoryWatch_Impl<DirectoryWatchResponse>;
    using RunCompatibilityTests = RunCompatibilityTests_Impl<RunCompatibilityTestsResponse>;
  };

  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_; }

    // Record the addition of a new device that can be communicated with via `rpc`.
    // For binding purposes, it is has properties `props`. `name` and `driver_path`
    // are informational and used for debugging.  The device will have `protocol_id`
    // as its primary protocol id.  `args` should only be used for shadowed devices,
    // and will be forwarded to the shadow device. `client_remote`, if present,
    // will be passed to the device as an open connection for the client.
    // On success, the returned `local_device_id` is the identifier assigned by devmgr.
    // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated.
    ResultOf::AddDevice AddDevice(::zx::channel coordinator, ::zx::channel device_controller, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, ::llcpp::fuchsia::device::manager::AddDeviceConfig device_add_config, bool has_init, ::zx::channel client_remote);

    // Record the addition of a new device that can be communicated with via `rpc`.
    // For binding purposes, it is has properties `props`. `name` and `driver_path`
    // are informational and used for debugging.  The device will have `protocol_id`
    // as its primary protocol id.  `args` should only be used for shadowed devices,
    // and will be forwarded to the shadow device. `client_remote`, if present,
    // will be passed to the device as an open connection for the client.
    // On success, the returned `local_device_id` is the identifier assigned by devmgr.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::AddDevice AddDevice(::fidl::BytePart _request_buffer, ::zx::channel coordinator, ::zx::channel device_controller, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, ::llcpp::fuchsia::device::manager::AddDeviceConfig device_add_config, bool has_init, ::zx::channel client_remote, ::fidl::BytePart _response_buffer);

    // Behaves as AddDevice, but marks the device as initially invisible.  This means
    // that it will not be visible to other devices or the devfs until it is later marked
    // visible (via MakeVisible).
    // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated.
    ResultOf::AddDeviceInvisible AddDeviceInvisible(::zx::channel coordinator, ::zx::channel device_controller, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, bool has_init, ::zx::channel client_remote);

    // Behaves as AddDevice, but marks the device as initially invisible.  This means
    // that it will not be visible to other devices or the devfs until it is later marked
    // visible (via MakeVisible).
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::AddDeviceInvisible AddDeviceInvisible(::fidl::BytePart _request_buffer, ::zx::channel coordinator, ::zx::channel device_controller, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, bool has_init, ::zx::channel client_remote, ::fidl::BytePart _response_buffer);

    // Requests the devcoordinator schedule the removal of this device,
    // and the unbinding of its children.
    // If |unbind_self| is true, the unbind hook for this device will also be called.
    // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::ScheduleRemove ScheduleRemove(bool unbind_self);

    // Requests the devcoordinator schedule the removal of this device,
    // and the unbinding of its children.
    // If |unbind_self| is true, the unbind hook for this device will also be called.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::ScheduleRemove ScheduleRemove(::fidl::BytePart _request_buffer, bool unbind_self);

    // Requests the devcoordinator schedule the unbinding of this device's children.
    // Allocates 16 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::ScheduleUnbindChildren ScheduleUnbindChildren();


    // Mark this device as visible.
    // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::MakeVisible MakeVisible();

    // Mark this device as visible.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::MakeVisible MakeVisible(::fidl::BytePart _response_buffer);

    // Attempt to bind a driver against this device.  If `driver_path` is null,
    // this will initiate the driver matching algorithm.
    // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated.
    ResultOf::BindDevice BindDevice(::fidl::StringView driver_path);

    // Attempt to bind a driver against this device.  If `driver_path` is null,
    // this will initiate the driver matching algorithm.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::BindDevice BindDevice(::fidl::BytePart _request_buffer, ::fidl::StringView driver_path, ::fidl::BytePart _response_buffer);

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

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

    // Requests that the firmware at the given path be loaded and returned.
    // Allocates 56 bytes of response buffer on the stack. Request is heap-allocated.
    ResultOf::LoadFirmware LoadFirmware(::fidl::StringView fw_path);

    // Requests that the firmware at the given path be loaded and returned.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::LoadFirmware LoadFirmware(::fidl::BytePart _request_buffer, ::fidl::StringView fw_path, ::fidl::BytePart _response_buffer);

    // Retrieve the metadata blob associated with this device and the given key.
    // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
    ResultOf::GetMetadata GetMetadata(uint32_t key);

    // Retrieve the metadata blob associated with this device and the given key.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::GetMetadata GetMetadata(::fidl::BytePart _request_buffer, uint32_t key, ::fidl::BytePart _response_buffer);

    // Retrieve the metadata size associated with this device and the given key.
    // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::GetMetadataSize GetMetadataSize(uint32_t key);

    // Retrieve the metadata size associated with this device and the given key.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::GetMetadataSize GetMetadataSize(::fidl::BytePart _request_buffer, uint32_t key, ::fidl::BytePart _response_buffer);

    // Add metadata blob associated with this device and the given key.
    // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated.
    ResultOf::AddMetadata AddMetadata(uint32_t key, ::fidl::VectorView<uint8_t> data);

    // Add metadata blob associated with this device and the given key.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::AddMetadata AddMetadata(::fidl::BytePart _request_buffer, uint32_t key, ::fidl::VectorView<uint8_t> data, ::fidl::BytePart _response_buffer);

    // Behaves like AddMetadata, but instead of associating it with the
    // requesting device, associates it with the device at `device_path`.  If
    // the device at `device_path` is not a child of the requesting device AND
    // the requesting device is not running in the sys devhost, then this will
    // fail.
    // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated.
    ResultOf::PublishMetadata PublishMetadata(::fidl::StringView device_path, uint32_t key, ::fidl::VectorView<uint8_t> data);

    // Behaves like AddMetadata, but instead of associating it with the
    // requesting device, associates it with the device at `device_path`.  If
    // the device at `device_path` is not a child of the requesting device AND
    // the requesting device is not running in the sys devhost, then this will
    // fail.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::PublishMetadata PublishMetadata(::fidl::BytePart _request_buffer, ::fidl::StringView device_path, uint32_t key, ::fidl::VectorView<uint8_t> data, ::fidl::BytePart _response_buffer);

    // Adds the given composite device.  This causes the devcoordinator to try to match the
    // components against the existing device tree, and to monitor all new device additions
    // in order to find the components as they are created.
    // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated.
    ResultOf::AddCompositeDevice AddCompositeDevice(::fidl::StringView name, ::llcpp::fuchsia::device::manager::CompositeDeviceDescriptor comp_desc);

    // Adds the given composite device.  This causes the devcoordinator to try to match the
    // components against the existing device tree, and to monitor all new device additions
    // in order to find the components as they are created.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::AddCompositeDevice AddCompositeDevice(::fidl::BytePart _request_buffer, ::fidl::StringView name, ::llcpp::fuchsia::device::manager::CompositeDeviceDescriptor comp_desc, ::fidl::BytePart _response_buffer);

    // Watches a directory, receiving events of added messages on the
    // watcher request channel.
    // See fuchsia.io.Directory for more information.
    // Allocates 80 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::DirectoryWatch DirectoryWatch(uint32_t mask, uint32_t options, ::zx::channel watcher);

    // Watches a directory, receiving events of added messages on the
    // watcher request channel.
    // See fuchsia.io.Directory for more information.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::DirectoryWatch DirectoryWatch(::fidl::BytePart _request_buffer, uint32_t mask, uint32_t options, ::zx::channel watcher, ::fidl::BytePart _response_buffer);

    // Run 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 compatibility tests started, and does not convey
    // anything about the status of the test.
    // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::RunCompatibilityTests RunCompatibilityTests(int64_t hook_wait_time);

    // Run 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 compatibility tests started, and does not convey
    // anything about the status of the test.
    // 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);

   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:

    // Record the addition of a new device that can be communicated with via `rpc`.
    // For binding purposes, it is has properties `props`. `name` and `driver_path`
    // are informational and used for debugging.  The device will have `protocol_id`
    // as its primary protocol id.  `args` should only be used for shadowed devices,
    // and will be forwarded to the shadow device. `client_remote`, if present,
    // will be passed to the device as an open connection for the client.
    // On success, the returned `local_device_id` is the identifier assigned by devmgr.
    // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated.
    static ResultOf::AddDevice AddDevice(::zx::unowned_channel _client_end, ::zx::channel coordinator, ::zx::channel device_controller, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, ::llcpp::fuchsia::device::manager::AddDeviceConfig device_add_config, bool has_init, ::zx::channel client_remote);

    // Record the addition of a new device that can be communicated with via `rpc`.
    // For binding purposes, it is has properties `props`. `name` and `driver_path`
    // are informational and used for debugging.  The device will have `protocol_id`
    // as its primary protocol id.  `args` should only be used for shadowed devices,
    // and will be forwarded to the shadow device. `client_remote`, if present,
    // will be passed to the device as an open connection for the client.
    // On success, the returned `local_device_id` is the identifier assigned by devmgr.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::AddDevice AddDevice(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel coordinator, ::zx::channel device_controller, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, ::llcpp::fuchsia::device::manager::AddDeviceConfig device_add_config, bool has_init, ::zx::channel client_remote, ::fidl::BytePart _response_buffer);

    // Behaves as AddDevice, but marks the device as initially invisible.  This means
    // that it will not be visible to other devices or the devfs until it is later marked
    // visible (via MakeVisible).
    // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated.
    static ResultOf::AddDeviceInvisible AddDeviceInvisible(::zx::unowned_channel _client_end, ::zx::channel coordinator, ::zx::channel device_controller, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, bool has_init, ::zx::channel client_remote);

    // Behaves as AddDevice, but marks the device as initially invisible.  This means
    // that it will not be visible to other devices or the devfs until it is later marked
    // visible (via MakeVisible).
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::AddDeviceInvisible AddDeviceInvisible(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel coordinator, ::zx::channel device_controller, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, bool has_init, ::zx::channel client_remote, ::fidl::BytePart _response_buffer);

    // Requests the devcoordinator schedule the removal of this device,
    // and the unbinding of its children.
    // If |unbind_self| is true, the unbind hook for this device will also be called.
    // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::ScheduleRemove ScheduleRemove(::zx::unowned_channel _client_end, bool unbind_self);

    // Requests the devcoordinator schedule the removal of this device,
    // and the unbinding of its children.
    // If |unbind_self| is true, the unbind hook for this device will also be called.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::ScheduleRemove ScheduleRemove(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool unbind_self);

    // Requests the devcoordinator schedule the unbinding of this device's children.
    // Allocates 16 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::ScheduleUnbindChildren ScheduleUnbindChildren(::zx::unowned_channel _client_end);


    // Mark this device as visible.
    // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::MakeVisible MakeVisible(::zx::unowned_channel _client_end);

    // Mark this device as visible.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::MakeVisible MakeVisible(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);

    // Attempt to bind a driver against this device.  If `driver_path` is null,
    // this will initiate the driver matching algorithm.
    // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated.
    static ResultOf::BindDevice BindDevice(::zx::unowned_channel _client_end, ::fidl::StringView driver_path);

    // Attempt to bind a driver against this device.  If `driver_path` is null,
    // this will initiate the driver matching algorithm.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::BindDevice BindDevice(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView driver_path, ::fidl::BytePart _response_buffer);

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

    // Returns the topological path of 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);

    // Requests that the firmware at the given path be loaded and returned.
    // Allocates 56 bytes of response buffer on the stack. Request is heap-allocated.
    static ResultOf::LoadFirmware LoadFirmware(::zx::unowned_channel _client_end, ::fidl::StringView fw_path);

    // Requests that the firmware at the given path be loaded and returned.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::LoadFirmware LoadFirmware(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView fw_path, ::fidl::BytePart _response_buffer);

    // Retrieve the metadata blob associated with this device and the given key.
    // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
    static ResultOf::GetMetadata GetMetadata(::zx::unowned_channel _client_end, uint32_t key);

    // Retrieve the metadata blob associated with this device and the given key.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::GetMetadata GetMetadata(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t key, ::fidl::BytePart _response_buffer);

    // Retrieve the metadata size associated with this device and the given key.
    // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::GetMetadataSize GetMetadataSize(::zx::unowned_channel _client_end, uint32_t key);

    // Retrieve the metadata size associated with this device and the given key.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::GetMetadataSize GetMetadataSize(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t key, ::fidl::BytePart _response_buffer);

    // Add metadata blob associated with this device and the given key.
    // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated.
    static ResultOf::AddMetadata AddMetadata(::zx::unowned_channel _client_end, uint32_t key, ::fidl::VectorView<uint8_t> data);

    // Add metadata blob associated with this device and the given key.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::AddMetadata AddMetadata(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t key, ::fidl::VectorView<uint8_t> data, ::fidl::BytePart _response_buffer);

    // Behaves like AddMetadata, but instead of associating it with the
    // requesting device, associates it with the device at `device_path`.  If
    // the device at `device_path` is not a child of the requesting device AND
    // the requesting device is not running in the sys devhost, then this will
    // fail.
    // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated.
    static ResultOf::PublishMetadata PublishMetadata(::zx::unowned_channel _client_end, ::fidl::StringView device_path, uint32_t key, ::fidl::VectorView<uint8_t> data);

    // Behaves like AddMetadata, but instead of associating it with the
    // requesting device, associates it with the device at `device_path`.  If
    // the device at `device_path` is not a child of the requesting device AND
    // the requesting device is not running in the sys devhost, then this will
    // fail.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::PublishMetadata PublishMetadata(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView device_path, uint32_t key, ::fidl::VectorView<uint8_t> data, ::fidl::BytePart _response_buffer);

    // Adds the given composite device.  This causes the devcoordinator to try to match the
    // components against the existing device tree, and to monitor all new device additions
    // in order to find the components as they are created.
    // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated.
    static ResultOf::AddCompositeDevice AddCompositeDevice(::zx::unowned_channel _client_end, ::fidl::StringView name, ::llcpp::fuchsia::device::manager::CompositeDeviceDescriptor comp_desc);

    // Adds the given composite device.  This causes the devcoordinator to try to match the
    // components against the existing device tree, and to monitor all new device additions
    // in order to find the components as they are created.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::AddCompositeDevice AddCompositeDevice(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView name, ::llcpp::fuchsia::device::manager::CompositeDeviceDescriptor comp_desc, ::fidl::BytePart _response_buffer);

    // Watches a directory, receiving events of added messages on the
    // watcher request channel.
    // See fuchsia.io.Directory for more information.
    // Allocates 80 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::DirectoryWatch DirectoryWatch(::zx::unowned_channel _client_end, uint32_t mask, uint32_t options, ::zx::channel watcher);

    // Watches a directory, receiving events of added messages on the
    // watcher request channel.
    // See fuchsia.io.Directory for more information.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::DirectoryWatch DirectoryWatch(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t mask, uint32_t options, ::zx::channel watcher, ::fidl::BytePart _response_buffer);

    // Run 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 compatibility tests started, and does not convey
    // anything about the status of the test.
    // Allocates 72 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);

    // Run 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 compatibility tests started, and does not convey
    // anything about the status of the test.
    // 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);

  };

  // 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:

    // Record the addition of a new device that can be communicated with via `rpc`.
    // For binding purposes, it is has properties `props`. `name` and `driver_path`
    // are informational and used for debugging.  The device will have `protocol_id`
    // as its primary protocol id.  `args` should only be used for shadowed devices,
    // and will be forwarded to the shadow device. `client_remote`, if present,
    // will be passed to the device as an open connection for the client.
    // On success, the returned `local_device_id` is the identifier assigned by devmgr.
    static ::fidl::DecodeResult<AddDeviceResponse> AddDevice(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<AddDeviceRequest> params, ::fidl::BytePart response_buffer);

    // Behaves as AddDevice, but marks the device as initially invisible.  This means
    // that it will not be visible to other devices or the devfs until it is later marked
    // visible (via MakeVisible).
    static ::fidl::DecodeResult<AddDeviceInvisibleResponse> AddDeviceInvisible(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<AddDeviceInvisibleRequest> params, ::fidl::BytePart response_buffer);

    // Requests the devcoordinator schedule the removal of this device,
    // and the unbinding of its children.
    // If |unbind_self| is true, the unbind hook for this device will also be called.
    static ::fidl::internal::StatusAndError ScheduleRemove(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ScheduleRemoveRequest> params);

    // Requests the devcoordinator schedule the unbinding of this device's children.
    static ::fidl::internal::StatusAndError ScheduleUnbindChildren(::zx::unowned_channel _client_end);

    // Mark this device as visible.
    static ::fidl::DecodeResult<MakeVisibleResponse> MakeVisible(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);

    // Attempt to bind a driver against this device.  If `driver_path` is null,
    // this will initiate the driver matching algorithm.
    static ::fidl::DecodeResult<BindDeviceResponse> BindDevice(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<BindDeviceRequest> params, ::fidl::BytePart response_buffer);

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

    // Requests that the firmware at the given path be loaded and returned.
    static ::fidl::DecodeResult<LoadFirmwareResponse> LoadFirmware(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<LoadFirmwareRequest> params, ::fidl::BytePart response_buffer);

    // Retrieve the metadata blob associated with this device and the given key.
    static ::fidl::DecodeResult<GetMetadataResponse> GetMetadata(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetMetadataRequest> params, ::fidl::BytePart response_buffer);

    // Retrieve the metadata size associated with this device and the given key.
    static ::fidl::DecodeResult<GetMetadataSizeResponse> GetMetadataSize(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetMetadataSizeRequest> params, ::fidl::BytePart response_buffer);

    // Add metadata blob associated with this device and the given key.
    static ::fidl::DecodeResult<AddMetadataResponse> AddMetadata(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<AddMetadataRequest> params, ::fidl::BytePart response_buffer);

    // Behaves like AddMetadata, but instead of associating it with the
    // requesting device, associates it with the device at `device_path`.  If
    // the device at `device_path` is not a child of the requesting device AND
    // the requesting device is not running in the sys devhost, then this will
    // fail.
    static ::fidl::DecodeResult<PublishMetadataResponse> PublishMetadata(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<PublishMetadataRequest> params, ::fidl::BytePart response_buffer);

    // Adds the given composite device.  This causes the devcoordinator to try to match the
    // components against the existing device tree, and to monitor all new device additions
    // in order to find the components as they are created.
    static ::fidl::DecodeResult<AddCompositeDeviceResponse> AddCompositeDevice(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<AddCompositeDeviceRequest> params, ::fidl::BytePart response_buffer);

    // Watches a directory, receiving events of added messages on the
    // watcher request channel.
    // See fuchsia.io.Directory for more information.
    static ::fidl::DecodeResult<DirectoryWatchResponse> DirectoryWatch(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<DirectoryWatchRequest> params, ::fidl::BytePart response_buffer);

    // Run 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 compatibility tests started, and does not convey
    // anything about the status of the test.
    static ::fidl::DecodeResult<RunCompatibilityTestsResponse> RunCompatibilityTests(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<RunCompatibilityTestsRequest> params, ::fidl::BytePart response_buffer);

  };

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

    class AddDeviceCompleterBase : public _Base {
     public:
      void Reply(::llcpp::fuchsia::device::manager::Coordinator_AddDevice_Result result);
      void ReplySuccess(uint64_t local_device_id);
      void ReplyError(int32_t error);
      void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::manager::Coordinator_AddDevice_Result result);
      void ReplySuccess(::fidl::BytePart _buffer, uint64_t local_device_id);
      void Reply(::fidl::DecodedMessage<AddDeviceResponse> params);

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

    using AddDeviceCompleter = ::fidl::Completer<AddDeviceCompleterBase>;

    virtual void AddDevice(::zx::channel coordinator, ::zx::channel device_controller, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, ::llcpp::fuchsia::device::manager::AddDeviceConfig device_add_config, bool has_init, ::zx::channel client_remote, AddDeviceCompleter::Sync _completer) = 0;

    class AddDeviceInvisibleCompleterBase : public _Base {
     public:
      void Reply(::llcpp::fuchsia::device::manager::Coordinator_AddDeviceInvisible_Result result);
      void ReplySuccess(uint64_t local_device_id);
      void ReplyError(int32_t error);
      void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::manager::Coordinator_AddDeviceInvisible_Result result);
      void ReplySuccess(::fidl::BytePart _buffer, uint64_t local_device_id);
      void Reply(::fidl::DecodedMessage<AddDeviceInvisibleResponse> params);

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

    using AddDeviceInvisibleCompleter = ::fidl::Completer<AddDeviceInvisibleCompleterBase>;

    virtual void AddDeviceInvisible(::zx::channel coordinator, ::zx::channel device_controller, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, bool has_init, ::zx::channel client_remote, AddDeviceInvisibleCompleter::Sync _completer) = 0;

    using ScheduleRemoveCompleter = ::fidl::Completer<>;

    virtual void ScheduleRemove(bool unbind_self, ScheduleRemoveCompleter::Sync _completer) = 0;

    using ScheduleUnbindChildrenCompleter = ::fidl::Completer<>;

    virtual void ScheduleUnbindChildren(ScheduleUnbindChildrenCompleter::Sync _completer) = 0;

    class MakeVisibleCompleterBase : public _Base {
     public:
      void Reply(::llcpp::fuchsia::device::manager::Coordinator_MakeVisible_Result result);
      void ReplySuccess();
      void ReplyError(int32_t error);
      void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::manager::Coordinator_MakeVisible_Result result);
      void ReplySuccess(::fidl::BytePart _buffer);
      void Reply(::fidl::DecodedMessage<MakeVisibleResponse> params);

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

    using MakeVisibleCompleter = ::fidl::Completer<MakeVisibleCompleterBase>;

    virtual void MakeVisible(MakeVisibleCompleter::Sync _completer) = 0;

    class BindDeviceCompleterBase : public _Base {
     public:
      void Reply(::llcpp::fuchsia::device::manager::Coordinator_BindDevice_Result result);
      void ReplySuccess();
      void ReplyError(int32_t error);
      void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::manager::Coordinator_BindDevice_Result result);
      void ReplySuccess(::fidl::BytePart _buffer);
      void Reply(::fidl::DecodedMessage<BindDeviceResponse> params);

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

    using BindDeviceCompleter = ::fidl::Completer<BindDeviceCompleterBase>;

    virtual void BindDevice(::fidl::StringView driver_path, BindDeviceCompleter::Sync _completer) = 0;

    class GetTopologicalPathCompleterBase : public _Base {
     public:
      void Reply(::llcpp::fuchsia::device::manager::Coordinator_GetTopologicalPath_Result result);
      void ReplySuccess(::fidl::StringView path);
      void ReplyError(int32_t error);
      void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::manager::Coordinator_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 LoadFirmwareCompleterBase : public _Base {
     public:
      void Reply(::llcpp::fuchsia::device::manager::Coordinator_LoadFirmware_Result result);
      void ReplySuccess(::zx::vmo vmo, uint64_t size);
      void ReplyError(int32_t error);
      void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::manager::Coordinator_LoadFirmware_Result result);
      void ReplySuccess(::fidl::BytePart _buffer, ::zx::vmo vmo, uint64_t size);
      void Reply(::fidl::DecodedMessage<LoadFirmwareResponse> params);

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

    using LoadFirmwareCompleter = ::fidl::Completer<LoadFirmwareCompleterBase>;

    virtual void LoadFirmware(::fidl::StringView fw_path, LoadFirmwareCompleter::Sync _completer) = 0;

    class GetMetadataCompleterBase : public _Base {
     public:
      void Reply(::llcpp::fuchsia::device::manager::Coordinator_GetMetadata_Result result);
      void ReplySuccess(::fidl::VectorView<uint8_t> data);
      void ReplyError(int32_t error);
      void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::manager::Coordinator_GetMetadata_Result result);
      void ReplySuccess(::fidl::BytePart _buffer, ::fidl::VectorView<uint8_t> data);
      void Reply(::fidl::DecodedMessage<GetMetadataResponse> params);

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

    using GetMetadataCompleter = ::fidl::Completer<GetMetadataCompleterBase>;

    virtual void GetMetadata(uint32_t key, GetMetadataCompleter::Sync _completer) = 0;

    class GetMetadataSizeCompleterBase : public _Base {
     public:
      void Reply(::llcpp::fuchsia::device::manager::Coordinator_GetMetadataSize_Result result);
      void ReplySuccess(uint64_t size);
      void ReplyError(int32_t error);
      void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::manager::Coordinator_GetMetadataSize_Result result);
      void ReplySuccess(::fidl::BytePart _buffer, uint64_t size);
      void Reply(::fidl::DecodedMessage<GetMetadataSizeResponse> params);

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

    using GetMetadataSizeCompleter = ::fidl::Completer<GetMetadataSizeCompleterBase>;

    virtual void GetMetadataSize(uint32_t key, GetMetadataSizeCompleter::Sync _completer) = 0;

    class AddMetadataCompleterBase : public _Base {
     public:
      void Reply(::llcpp::fuchsia::device::manager::Coordinator_AddMetadata_Result result);
      void ReplySuccess();
      void ReplyError(int32_t error);
      void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::manager::Coordinator_AddMetadata_Result result);
      void ReplySuccess(::fidl::BytePart _buffer);
      void Reply(::fidl::DecodedMessage<AddMetadataResponse> params);

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

    using AddMetadataCompleter = ::fidl::Completer<AddMetadataCompleterBase>;

    virtual void AddMetadata(uint32_t key, ::fidl::VectorView<uint8_t> data, AddMetadataCompleter::Sync _completer) = 0;

    class PublishMetadataCompleterBase : public _Base {
     public:
      void Reply(::llcpp::fuchsia::device::manager::Coordinator_PublishMetadata_Result result);
      void ReplySuccess();
      void ReplyError(int32_t error);
      void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::manager::Coordinator_PublishMetadata_Result result);
      void ReplySuccess(::fidl::BytePart _buffer);
      void Reply(::fidl::DecodedMessage<PublishMetadataResponse> params);

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

    using PublishMetadataCompleter = ::fidl::Completer<PublishMetadataCompleterBase>;

    virtual void PublishMetadata(::fidl::StringView device_path, uint32_t key, ::fidl::VectorView<uint8_t> data, PublishMetadataCompleter::Sync _completer) = 0;

    class AddCompositeDeviceCompleterBase : public _Base {
     public:
      void Reply(::llcpp::fuchsia::device::manager::Coordinator_AddCompositeDevice_Result result);
      void ReplySuccess();
      void ReplyError(int32_t error);
      void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::manager::Coordinator_AddCompositeDevice_Result result);
      void ReplySuccess(::fidl::BytePart _buffer);
      void Reply(::fidl::DecodedMessage<AddCompositeDeviceResponse> params);

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

    using AddCompositeDeviceCompleter = ::fidl::Completer<AddCompositeDeviceCompleterBase>;

    virtual void AddCompositeDevice(::fidl::StringView name, ::llcpp::fuchsia::device::manager::CompositeDeviceDescriptor comp_desc, AddCompositeDeviceCompleter::Sync _completer) = 0;

    class DirectoryWatchCompleterBase : public _Base {
     public:
      void Reply(::llcpp::fuchsia::device::manager::Coordinator_DirectoryWatch_Result result);
      void ReplySuccess();
      void ReplyError(int32_t error);
      void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::manager::Coordinator_DirectoryWatch_Result result);
      void ReplySuccess(::fidl::BytePart _buffer);
      void Reply(::fidl::DecodedMessage<DirectoryWatchResponse> params);

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

    using DirectoryWatchCompleter = ::fidl::Completer<DirectoryWatchCompleterBase>;

    virtual void DirectoryWatch(uint32_t mask, uint32_t options, ::zx::channel watcher, DirectoryWatchCompleter::Sync _completer) = 0;

    class RunCompatibilityTestsCompleterBase : public _Base {
     public:
      void Reply(::llcpp::fuchsia::device::manager::Coordinator_RunCompatibilityTests_Result result);
      void ReplySuccess();
      void ReplyError(int32_t error);
      void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::manager::Coordinator_RunCompatibilityTests_Result result);
      void ReplySuccess(::fidl::BytePart _buffer);
      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;

  };

  // 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 AddDeviceRequest(const ::fidl::DecodedMessage<Coordinator::AddDeviceRequest>& _msg);
    static void AddDeviceResponse(const ::fidl::DecodedMessage<Coordinator::AddDeviceResponse>& _msg);
    static void AddDeviceInvisibleRequest(const ::fidl::DecodedMessage<Coordinator::AddDeviceInvisibleRequest>& _msg);
    static void AddDeviceInvisibleResponse(const ::fidl::DecodedMessage<Coordinator::AddDeviceInvisibleResponse>& _msg);
    static void ScheduleRemoveRequest(const ::fidl::DecodedMessage<Coordinator::ScheduleRemoveRequest>& _msg);
    static void ScheduleUnbindChildrenRequest(const ::fidl::DecodedMessage<Coordinator::ScheduleUnbindChildrenRequest>& _msg);
    static void MakeVisibleRequest(const ::fidl::DecodedMessage<Coordinator::MakeVisibleRequest>& _msg);
    static void MakeVisibleResponse(const ::fidl::DecodedMessage<Coordinator::MakeVisibleResponse>& _msg);
    static void BindDeviceRequest(const ::fidl::DecodedMessage<Coordinator::BindDeviceRequest>& _msg);
    static void BindDeviceResponse(const ::fidl::DecodedMessage<Coordinator::BindDeviceResponse>& _msg);
    static void GetTopologicalPathRequest(const ::fidl::DecodedMessage<Coordinator::GetTopologicalPathRequest>& _msg);
    static void GetTopologicalPathResponse(const ::fidl::DecodedMessage<Coordinator::GetTopologicalPathResponse>& _msg);
    static void LoadFirmwareRequest(const ::fidl::DecodedMessage<Coordinator::LoadFirmwareRequest>& _msg);
    static void LoadFirmwareResponse(const ::fidl::DecodedMessage<Coordinator::LoadFirmwareResponse>& _msg);
    static void GetMetadataRequest(const ::fidl::DecodedMessage<Coordinator::GetMetadataRequest>& _msg);
    static void GetMetadataResponse(const ::fidl::DecodedMessage<Coordinator::GetMetadataResponse>& _msg);
    static void GetMetadataSizeRequest(const ::fidl::DecodedMessage<Coordinator::GetMetadataSizeRequest>& _msg);
    static void GetMetadataSizeResponse(const ::fidl::DecodedMessage<Coordinator::GetMetadataSizeResponse>& _msg);
    static void AddMetadataRequest(const ::fidl::DecodedMessage<Coordinator::AddMetadataRequest>& _msg);
    static void AddMetadataResponse(const ::fidl::DecodedMessage<Coordinator::AddMetadataResponse>& _msg);
    static void PublishMetadataRequest(const ::fidl::DecodedMessage<Coordinator::PublishMetadataRequest>& _msg);
    static void PublishMetadataResponse(const ::fidl::DecodedMessage<Coordinator::PublishMetadataResponse>& _msg);
    static void AddCompositeDeviceRequest(const ::fidl::DecodedMessage<Coordinator::AddCompositeDeviceRequest>& _msg);
    static void AddCompositeDeviceResponse(const ::fidl::DecodedMessage<Coordinator::AddCompositeDeviceResponse>& _msg);
    static void DirectoryWatchRequest(const ::fidl::DecodedMessage<Coordinator::DirectoryWatchRequest>& _msg);
    static void DirectoryWatchResponse(const ::fidl::DecodedMessage<Coordinator::DirectoryWatchResponse>& _msg);
    static void RunCompatibilityTestsRequest(const ::fidl::DecodedMessage<Coordinator::RunCompatibilityTestsRequest>& _msg);
    static void RunCompatibilityTestsResponse(const ::fidl::DecodedMessage<Coordinator::RunCompatibilityTestsResponse>& _msg);
  };
};

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

namespace fidl {

template <>
struct IsFidlType<::llcpp::fuchsia::device::manager::DebugDumper::DumpTreeRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::device::manager::DebugDumper::DumpTreeRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::device::manager::DebugDumper::DumpTreeRequest)
    == ::llcpp::fuchsia::device::manager::DebugDumper::DumpTreeRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::device::manager::DebugDumper::DumpTreeRequest, output) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::device::manager::DebugDumper::DumpTreeResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::device::manager::DebugDumper::DumpTreeResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::device::manager::DebugDumper::DumpTreeResponse)
    == ::llcpp::fuchsia::device::manager::DebugDumper::DumpTreeResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::device::manager::DebugDumper::DumpTreeResponse, status) == 16);
static_assert(offsetof(::llcpp::fuchsia::device::manager::DebugDumper::DumpTreeResponse, written) == 24);
static_assert(offsetof(::llcpp::fuchsia::device::manager::DebugDumper::DumpTreeResponse, available) == 32);

template <>
struct IsFidlType<::llcpp::fuchsia::device::manager::DebugDumper::DumpDriversRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::device::manager::DebugDumper::DumpDriversRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::device::manager::DebugDumper::DumpDriversRequest)
    == ::llcpp::fuchsia::device::manager::DebugDumper::DumpDriversRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::device::manager::DebugDumper::DumpDriversRequest, output) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::device::manager::DebugDumper::DumpDriversResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::device::manager::DebugDumper::DumpDriversResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::device::manager::DebugDumper::DumpDriversResponse)
    == ::llcpp::fuchsia::device::manager::DebugDumper::DumpDriversResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::device::manager::DebugDumper::DumpDriversResponse, status) == 16);
static_assert(offsetof(::llcpp::fuchsia::device::manager::DebugDumper::DumpDriversResponse, written) == 24);
static_assert(offsetof(::llcpp::fuchsia::device::manager::DebugDumper::DumpDriversResponse, available) == 32);

template <>
struct IsFidlType<::llcpp::fuchsia::device::manager::DebugDumper::DumpBindingPropertiesRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::device::manager::DebugDumper::DumpBindingPropertiesRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::device::manager::DebugDumper::DumpBindingPropertiesRequest)
    == ::llcpp::fuchsia::device::manager::DebugDumper::DumpBindingPropertiesRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::device::manager::DebugDumper::DumpBindingPropertiesRequest, output) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::device::manager::DebugDumper::DumpBindingPropertiesResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::device::manager::DebugDumper::DumpBindingPropertiesResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::device::manager::DebugDumper::DumpBindingPropertiesResponse)
    == ::llcpp::fuchsia::device::manager::DebugDumper::DumpBindingPropertiesResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::device::manager::DebugDumper::DumpBindingPropertiesResponse, status) == 16);
static_assert(offsetof(::llcpp::fuchsia::device::manager::DebugDumper::DumpBindingPropertiesResponse, written) == 24);
static_assert(offsetof(::llcpp::fuchsia::device::manager::DebugDumper::DumpBindingPropertiesResponse, available) == 32);

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

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

template <>
struct IsFidlType<::llcpp::fuchsia::device::manager::DevhostController::CreateDeviceStubRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::device::manager::DevhostController::CreateDeviceStubRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::device::manager::DevhostController::CreateDeviceStubRequest)
    == ::llcpp::fuchsia::device::manager::DevhostController::CreateDeviceStubRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::device::manager::DevhostController::CreateDeviceStubRequest, coordinator_rpc) == 16);
static_assert(offsetof(::llcpp::fuchsia::device::manager::DevhostController::CreateDeviceStubRequest, device_controller_rpc) == 20);
static_assert(offsetof(::llcpp::fuchsia::device::manager::DevhostController::CreateDeviceStubRequest, protocol_id) == 24);
static_assert(offsetof(::llcpp::fuchsia::device::manager::DevhostController::CreateDeviceStubRequest, local_device_id) == 32);

template <>
struct IsFidlType<::llcpp::fuchsia::device::manager::DevhostController::CreateDeviceRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::device::manager::DevhostController::CreateDeviceRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::device::manager::DevhostController::CreateDeviceRequest)
    == ::llcpp::fuchsia::device::manager::DevhostController::CreateDeviceRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::device::manager::DevhostController::CreateDeviceRequest, coordinator_rpc) == 16);
static_assert(offsetof(::llcpp::fuchsia::device::manager::DevhostController::CreateDeviceRequest, device_controller_rpc) == 20);
static_assert(offsetof(::llcpp::fuchsia::device::manager::DevhostController::CreateDeviceRequest, driver_path) == 24);
static_assert(offsetof(::llcpp::fuchsia::device::manager::DevhostController::CreateDeviceRequest, driver) == 40);
static_assert(offsetof(::llcpp::fuchsia::device::manager::DevhostController::CreateDeviceRequest, parent_proxy) == 44);
static_assert(offsetof(::llcpp::fuchsia::device::manager::DevhostController::CreateDeviceRequest, proxy_args) == 48);
static_assert(offsetof(::llcpp::fuchsia::device::manager::DevhostController::CreateDeviceRequest, local_device_id) == 64);

template <>
struct IsFidlType<::llcpp::fuchsia::device::manager::DevhostController::CreateCompositeDeviceRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::device::manager::DevhostController::CreateCompositeDeviceRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::device::manager::DevhostController::CreateCompositeDeviceRequest)
    == ::llcpp::fuchsia::device::manager::DevhostController::CreateCompositeDeviceRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::device::manager::DevhostController::CreateCompositeDeviceRequest, coordinator_rpc) == 16);
static_assert(offsetof(::llcpp::fuchsia::device::manager::DevhostController::CreateCompositeDeviceRequest, device_controller_rpc) == 20);
static_assert(offsetof(::llcpp::fuchsia::device::manager::DevhostController::CreateCompositeDeviceRequest, components) == 24);
static_assert(offsetof(::llcpp::fuchsia::device::manager::DevhostController::CreateCompositeDeviceRequest, name) == 40);
static_assert(offsetof(::llcpp::fuchsia::device::manager::DevhostController::CreateCompositeDeviceRequest, local_device_id) == 56);

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

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

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

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

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

template <>
struct IsFidlType<::llcpp::fuchsia::device::manager::DeviceMetadata> : public std::true_type {};
static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::manager::DeviceMetadata>);
static_assert(offsetof(::llcpp::fuchsia::device::manager::DeviceMetadata, key) == 0);
static_assert(offsetof(::llcpp::fuchsia::device::manager::DeviceMetadata, data) == 8);
static_assert(sizeof(::llcpp::fuchsia::device::manager::DeviceMetadata) == ::llcpp::fuchsia::device::manager::DeviceMetadata::PrimarySize);

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

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

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

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

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

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

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

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

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

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

template <>
struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator_LoadFirmware_Response> : public std::true_type {};
static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::manager::Coordinator_LoadFirmware_Response>);
static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_LoadFirmware_Response, vmo) == 0);
static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_LoadFirmware_Response, size) == 8);
static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator_LoadFirmware_Response) == ::llcpp::fuchsia::device::manager::Coordinator_LoadFirmware_Response::PrimarySize);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

template <>
struct IsFidlType<::llcpp::fuchsia::device::manager::DeviceController::BindDriverRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::device::manager::DeviceController::BindDriverRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::device::manager::DeviceController::BindDriverRequest)
    == ::llcpp::fuchsia::device::manager::DeviceController::BindDriverRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::device::manager::DeviceController::BindDriverRequest, driver_path) == 16);
static_assert(offsetof(::llcpp::fuchsia::device::manager::DeviceController::BindDriverRequest, driver) == 32);

template <>
struct IsFidlType<::llcpp::fuchsia::device::manager::DeviceController::BindDriverResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::device::manager::DeviceController::BindDriverResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::device::manager::DeviceController::BindDriverResponse)
    == ::llcpp::fuchsia::device::manager::DeviceController::BindDriverResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::device::manager::DeviceController::BindDriverResponse, status) == 16);
static_assert(offsetof(::llcpp::fuchsia::device::manager::DeviceController::BindDriverResponse, test_output) == 20);

template <>
struct IsFidlType<::llcpp::fuchsia::device::manager::DeviceController::ConnectProxyRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::device::manager::DeviceController::ConnectProxyRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::device::manager::DeviceController::ConnectProxyRequest)
    == ::llcpp::fuchsia::device::manager::DeviceController::ConnectProxyRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::device::manager::DeviceController::ConnectProxyRequest, shadow) == 16);

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

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

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

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

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

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

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

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

template <>
struct IsFidlType<::llcpp::fuchsia::device::manager::BindInstruction> : public std::true_type {};
static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::manager::BindInstruction>);
static_assert(offsetof(::llcpp::fuchsia::device::manager::BindInstruction, op) == 0);
static_assert(offsetof(::llcpp::fuchsia::device::manager::BindInstruction, arg) == 4);
static_assert(sizeof(::llcpp::fuchsia::device::manager::BindInstruction) == ::llcpp::fuchsia::device::manager::BindInstruction::PrimarySize);

template <>
struct IsFidlType<::llcpp::fuchsia::device::manager::DeviceComponentPart> : public std::true_type {};
static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::manager::DeviceComponentPart>);
static_assert(offsetof(::llcpp::fuchsia::device::manager::DeviceComponentPart, match_program_count) == 0);
static_assert(offsetof(::llcpp::fuchsia::device::manager::DeviceComponentPart, match_program) == 4);
static_assert(sizeof(::llcpp::fuchsia::device::manager::DeviceComponentPart) == ::llcpp::fuchsia::device::manager::DeviceComponentPart::PrimarySize);

template <>
struct IsFidlType<::llcpp::fuchsia::device::manager::DeviceComponent> : public std::true_type {};
static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::manager::DeviceComponent>);
static_assert(offsetof(::llcpp::fuchsia::device::manager::DeviceComponent, parts_count) == 0);
static_assert(offsetof(::llcpp::fuchsia::device::manager::DeviceComponent, parts) == 4);
static_assert(sizeof(::llcpp::fuchsia::device::manager::DeviceComponent) == ::llcpp::fuchsia::device::manager::DeviceComponent::PrimarySize);

template <>
struct IsFidlType<::llcpp::fuchsia::device::manager::CompositeDeviceDescriptor> : public std::true_type {};
static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::manager::CompositeDeviceDescriptor>);
static_assert(offsetof(::llcpp::fuchsia::device::manager::CompositeDeviceDescriptor, props) == 0);
static_assert(offsetof(::llcpp::fuchsia::device::manager::CompositeDeviceDescriptor, components) == 16);
static_assert(offsetof(::llcpp::fuchsia::device::manager::CompositeDeviceDescriptor, coresident_device_index) == 32);
static_assert(offsetof(::llcpp::fuchsia::device::manager::CompositeDeviceDescriptor, metadata) == 40);
static_assert(sizeof(::llcpp::fuchsia::device::manager::CompositeDeviceDescriptor) == ::llcpp::fuchsia::device::manager::CompositeDeviceDescriptor::PrimarySize);

template <>
struct IsFidlType<::llcpp::fuchsia::device::manager::AddDeviceConfig> : public std::true_type {};
static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::manager::AddDeviceConfig>);
static_assert(sizeof(::llcpp::fuchsia::device::manager::AddDeviceConfig) == sizeof(uint32_t));

template <>
struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator::AddDeviceRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::device::manager::Coordinator::AddDeviceRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator::AddDeviceRequest)
    == ::llcpp::fuchsia::device::manager::Coordinator::AddDeviceRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::AddDeviceRequest, coordinator) == 16);
static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::AddDeviceRequest, device_controller) == 20);
static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::AddDeviceRequest, props) == 24);
static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::AddDeviceRequest, name) == 40);
static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::AddDeviceRequest, protocol_id) == 56);
static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::AddDeviceRequest, driver_path) == 64);
static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::AddDeviceRequest, args) == 80);
static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::AddDeviceRequest, device_add_config) == 96);
static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::AddDeviceRequest, has_init) == 100);
static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::AddDeviceRequest, client_remote) == 104);

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

template <>
struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator::AddDeviceInvisibleRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::device::manager::Coordinator::AddDeviceInvisibleRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator::AddDeviceInvisibleRequest)
    == ::llcpp::fuchsia::device::manager::Coordinator::AddDeviceInvisibleRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::AddDeviceInvisibleRequest, coordinator) == 16);
static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::AddDeviceInvisibleRequest, device_controller) == 20);
static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::AddDeviceInvisibleRequest, props) == 24);
static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::AddDeviceInvisibleRequest, name) == 40);
static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::AddDeviceInvisibleRequest, protocol_id) == 56);
static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::AddDeviceInvisibleRequest, driver_path) == 64);
static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::AddDeviceInvisibleRequest, args) == 80);
static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::AddDeviceInvisibleRequest, has_init) == 96);
static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::AddDeviceInvisibleRequest, client_remote) == 100);

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

template <>
struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator::ScheduleRemoveRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::device::manager::Coordinator::ScheduleRemoveRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator::ScheduleRemoveRequest)
    == ::llcpp::fuchsia::device::manager::Coordinator::ScheduleRemoveRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::ScheduleRemoveRequest, unbind_self) == 16);

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

template <>
struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator::BindDeviceRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::device::manager::Coordinator::BindDeviceRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator::BindDeviceRequest)
    == ::llcpp::fuchsia::device::manager::Coordinator::BindDeviceRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::BindDeviceRequest, driver_path) == 16);

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

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

template <>
struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator::LoadFirmwareRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::device::manager::Coordinator::LoadFirmwareRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator::LoadFirmwareRequest)
    == ::llcpp::fuchsia::device::manager::Coordinator::LoadFirmwareRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::LoadFirmwareRequest, fw_path) == 16);

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

template <>
struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator::GetMetadataRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::device::manager::Coordinator::GetMetadataRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator::GetMetadataRequest)
    == ::llcpp::fuchsia::device::manager::Coordinator::GetMetadataRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::GetMetadataRequest, key) == 16);

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

template <>
struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator::GetMetadataSizeRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::device::manager::Coordinator::GetMetadataSizeRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator::GetMetadataSizeRequest)
    == ::llcpp::fuchsia::device::manager::Coordinator::GetMetadataSizeRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::GetMetadataSizeRequest, key) == 16);

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

template <>
struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator::AddMetadataRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::device::manager::Coordinator::AddMetadataRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator::AddMetadataRequest)
    == ::llcpp::fuchsia::device::manager::Coordinator::AddMetadataRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::AddMetadataRequest, key) == 16);
static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::AddMetadataRequest, data) == 24);

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

template <>
struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator::PublishMetadataRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::device::manager::Coordinator::PublishMetadataRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator::PublishMetadataRequest)
    == ::llcpp::fuchsia::device::manager::Coordinator::PublishMetadataRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::PublishMetadataRequest, device_path) == 16);
static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::PublishMetadataRequest, key) == 32);
static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::PublishMetadataRequest, data) == 40);

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

template <>
struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator::AddCompositeDeviceRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::device::manager::Coordinator::AddCompositeDeviceRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator::AddCompositeDeviceRequest)
    == ::llcpp::fuchsia::device::manager::Coordinator::AddCompositeDeviceRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::AddCompositeDeviceRequest, name) == 16);
static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::AddCompositeDeviceRequest, comp_desc) == 32);

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

template <>
struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator::DirectoryWatchRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::device::manager::Coordinator::DirectoryWatchRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator::DirectoryWatchRequest)
    == ::llcpp::fuchsia::device::manager::Coordinator::DirectoryWatchRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::DirectoryWatchRequest, mask) == 16);
static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::DirectoryWatchRequest, options) == 20);
static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::DirectoryWatchRequest, watcher) == 24);

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

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

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

}  // namespace fidl