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

#pragma once

#include <lib/fidl/internal.h>
#include <lib/fidl/llcpp/array.h>
#include <lib/fidl/llcpp/coding.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_REBOOT = 0u,
  SYSTEM_POWER_STATE_REBOOT_BOOTLOADER = 1u,
  SYSTEM_POWER_STATE_REBOOT_RECOVERY = 2u,
  SYSTEM_POWER_STATE_POWEROFF = 3u,
  SYSTEM_POWER_STATE_MEXEC = 4u,
  SYSTEM_POWER_STATE_SUSPEND_RAM = 5u,
};


class DebugDumper;
class Administrator;
class DevhostController;
struct Coordinator_AddDevice_Response;
struct Coordinator_AddDevice_Result;
struct Coordinator_AddDeviceInvisible_Response;
struct Coordinator_AddDeviceInvisible_Result;
struct Coordinator_UnbindDone_Response;
struct Coordinator_UnbindDone_Result;
struct Coordinator_RunCompatibilityTests_Response;
struct Coordinator_RunCompatibilityTests_Result;
struct Coordinator_RemoveDone_Response;
struct Coordinator_RemoveDone_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;
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_; }
  constexpr inline operator bool() const { return 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 fuchsia_device_manager_DebugDumperDumpTreeRequestTable;
extern "C" const fidl_type_t fuchsia_device_manager_DebugDumperDumpTreeResponseTable;
extern "C" const fidl_type_t fuchsia_device_manager_DebugDumperDumpDriversRequestTable;
extern "C" const fidl_type_t fuchsia_device_manager_DebugDumperDumpDriversResponseTable;
extern "C" const fidl_type_t fuchsia_device_manager_DebugDumperDumpBindingPropertiesRequestTable;
extern "C" const fidl_type_t 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 = &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 ::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 = &fuchsia_device_manager_DebugDumperDumpTreeRequestTable;
    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 ::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 = &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 ::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 = &fuchsia_device_manager_DebugDumperDumpDriversRequestTable;
    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 ::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 = &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 ::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 = &fuchsia_device_manager_DebugDumperDumpBindingPropertiesRequestTable;
    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 ::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);
  }

};

extern "C" const fidl_type_t fuchsia_device_manager_AdministratorSuspendRequestTable;
extern "C" const fidl_type_t 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 = &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 ::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 = &fuchsia_device_manager_AdministratorSuspendRequestTable;
    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 ::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);
  }

};

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 bytes in a metadata payload
constexpr uint32_t METADATA_MAX = 8192u;

constexpr uint32_t MAX_SYSTEM_POWER_STATES = 6u;

extern "C" const fidl_type_t fuchsia_device_manager_DevhostControllerCreateDeviceStubRequestTable;
extern "C" const fidl_type_t fuchsia_device_manager_DevhostControllerCreateDeviceRequestTable;
extern "C" const fidl_type_t fuchsia_device_manager_DevhostControllerCreateCompositeDeviceRequestTable;
extern "C" const fidl_type_t 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 rpc;
    uint32_t protocol_id;
    uint64_t local_device_id;

    static constexpr const fidl_type_t* Type = &fuchsia_device_manager_DevhostControllerCreateDeviceStubRequestTable;
    static constexpr uint32_t MaxNumHandles = 1;
    static constexpr uint32_t PrimarySize = 32;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kRequest;
  };

  struct CreateDeviceRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::zx::channel 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 = &fuchsia_device_manager_DevhostControllerCreateDeviceRequestTable;
    static constexpr uint32_t MaxNumHandles = 3;
    static constexpr uint32_t PrimarySize = 72;
    static constexpr uint32_t MaxOutOfLine = 2048;
    static constexpr bool HasFlexibleEnvelope = 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 = &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 ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  struct CreateCompositeDeviceRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::zx::channel rpc;
    ::fidl::VectorView<uint64_t> components;
    ::fidl::StringView name;
    uint64_t local_device_id;

    static constexpr const fidl_type_t* Type = &fuchsia_device_manager_DevhostControllerCreateCompositeDeviceRequestTable;
    static constexpr uint32_t MaxNumHandles = 1;
    static constexpr uint32_t PrimarySize = 64;
    static constexpr uint32_t MaxOutOfLine = 160;
    static constexpr bool HasFlexibleEnvelope = 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 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 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 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 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 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 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 `rpc`.
    // Allocates 32 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::CreateDeviceStub CreateDeviceStub(::zx::channel 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 `rpc`.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::CreateDeviceStub CreateDeviceStub(::fidl::BytePart _request_buffer, ::zx::channel 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 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 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 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 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 `rpc`.
    // Allocates 32 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::CreateDeviceStub CreateDeviceStub(zx::unowned_channel _client_end, ::zx::channel 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 `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 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 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 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 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 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 `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 rpc, uint32_t protocol_id, uint64_t local_device_id, CreateDeviceStubCompleter::Sync _completer) = 0;

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

    virtual void CreateDevice(::zx::channel 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 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);
  }

};


struct Coordinator_AddDevice_Response {
  static constexpr const fidl_type_t* Type = nullptr;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 8;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 0;

  uint64_t local_device_id = {};
};

extern "C" const fidl_type_t fuchsia_device_manager_Coordinator_AddDevice_ResultTable;

struct Coordinator_AddDevice_Result {
  enum class Tag : fidl_union_tag_t {
    kResponse = 0,
    kErr = 1,
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

  Coordinator_AddDevice_Result();
  ~Coordinator_AddDevice_Result();

  Coordinator_AddDevice_Result(Coordinator_AddDevice_Result&& other) {
    tag_ = Tag::Invalid;
    if (this != &other) {
      MoveImpl_(std::move(other));
    }
  }

  Coordinator_AddDevice_Result& operator=(Coordinator_AddDevice_Result&& other) {
    if (this != &other) {
      MoveImpl_(std::move(other));
    }
    return *this;
  }

  bool has_invalid_tag() const { return tag_ == Tag::Invalid; }

  bool is_response() const { return tag_ == Tag::kResponse; }

  static Coordinator_AddDevice_Result WithResponse(Coordinator_AddDevice_Response&& val) {
    Coordinator_AddDevice_Result result;
    result.set_response(std::move(val));
    return result;
  }

  Coordinator_AddDevice_Response& mutable_response();

  template <typename T>
  std::enable_if_t<std::is_convertible<T, Coordinator_AddDevice_Response>::value && std::is_copy_assignable<T>::value>
  set_response(const T& v) {
    mutable_response() = v;
  }

  template <typename T>
  std::enable_if_t<std::is_convertible<T, Coordinator_AddDevice_Response>::value && std::is_move_assignable<T>::value>
  set_response(T&& v) {
    mutable_response() = std::move(v);
  }

  Coordinator_AddDevice_Response const & response() const { return response_; }

  bool is_err() const { return tag_ == Tag::kErr; }

  static Coordinator_AddDevice_Result WithErr(int32_t&& val) {
    Coordinator_AddDevice_Result result;
    result.set_err(std::move(val));
    return result;
  }

  int32_t& mutable_err();

  template <typename T>
  std::enable_if_t<std::is_convertible<T, int32_t>::value && std::is_copy_assignable<T>::value>
  set_err(const T& v) {
    mutable_err() = v;
  }

  template <typename T>
  std::enable_if_t<std::is_convertible<T, int32_t>::value && std::is_move_assignable<T>::value>
  set_err(T&& v) {
    mutable_err() = std::move(v);
  }

  int32_t const & err() const { return err_; }

  Tag which() const { return tag_; }

  static constexpr const fidl_type_t* Type = &fuchsia_device_manager_Coordinator_AddDevice_ResultTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 16;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 0;

 private:
  void Destroy();
  void MoveImpl_(Coordinator_AddDevice_Result&& other);
  static void SizeAndOffsetAssertionHelper();
  Tag tag_;
  union {
    Coordinator_AddDevice_Response response_;
    int32_t err_;
  };
};


struct Coordinator_AddDeviceInvisible_Response {
  static constexpr const fidl_type_t* Type = nullptr;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 8;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 0;

  uint64_t local_device_id = {};
};

extern "C" const fidl_type_t fuchsia_device_manager_Coordinator_AddDeviceInvisible_ResultTable;

struct Coordinator_AddDeviceInvisible_Result {
  enum class Tag : fidl_union_tag_t {
    kResponse = 0,
    kErr = 1,
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

  Coordinator_AddDeviceInvisible_Result();
  ~Coordinator_AddDeviceInvisible_Result();

  Coordinator_AddDeviceInvisible_Result(Coordinator_AddDeviceInvisible_Result&& other) {
    tag_ = Tag::Invalid;
    if (this != &other) {
      MoveImpl_(std::move(other));
    }
  }

  Coordinator_AddDeviceInvisible_Result& operator=(Coordinator_AddDeviceInvisible_Result&& other) {
    if (this != &other) {
      MoveImpl_(std::move(other));
    }
    return *this;
  }

  bool has_invalid_tag() const { return tag_ == Tag::Invalid; }

  bool is_response() const { return tag_ == Tag::kResponse; }

  static Coordinator_AddDeviceInvisible_Result WithResponse(Coordinator_AddDeviceInvisible_Response&& val) {
    Coordinator_AddDeviceInvisible_Result result;
    result.set_response(std::move(val));
    return result;
  }

  Coordinator_AddDeviceInvisible_Response& mutable_response();

  template <typename T>
  std::enable_if_t<std::is_convertible<T, Coordinator_AddDeviceInvisible_Response>::value && std::is_copy_assignable<T>::value>
  set_response(const T& v) {
    mutable_response() = v;
  }

  template <typename T>
  std::enable_if_t<std::is_convertible<T, Coordinator_AddDeviceInvisible_Response>::value && std::is_move_assignable<T>::value>
  set_response(T&& v) {
    mutable_response() = std::move(v);
  }

  Coordinator_AddDeviceInvisible_Response const & response() const { return response_; }

  bool is_err() const { return tag_ == Tag::kErr; }

  static Coordinator_AddDeviceInvisible_Result WithErr(int32_t&& val) {
    Coordinator_AddDeviceInvisible_Result result;
    result.set_err(std::move(val));
    return result;
  }

  int32_t& mutable_err();

  template <typename T>
  std::enable_if_t<std::is_convertible<T, int32_t>::value && std::is_copy_assignable<T>::value>
  set_err(const T& v) {
    mutable_err() = v;
  }

  template <typename T>
  std::enable_if_t<std::is_convertible<T, int32_t>::value && std::is_move_assignable<T>::value>
  set_err(T&& v) {
    mutable_err() = std::move(v);
  }

  int32_t const & err() const { return err_; }

  Tag which() const { return tag_; }

  static constexpr const fidl_type_t* Type = &fuchsia_device_manager_Coordinator_AddDeviceInvisible_ResultTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 16;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 0;

 private:
  void Destroy();
  void MoveImpl_(Coordinator_AddDeviceInvisible_Result&& other);
  static void SizeAndOffsetAssertionHelper();
  Tag tag_;
  union {
    Coordinator_AddDeviceInvisible_Response response_;
    int32_t err_;
  };
};

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


struct Coordinator_UnbindDone_Response {
  static constexpr const fidl_type_t* Type = nullptr;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 1;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 0;

  uint8_t __reserved = {};
};

extern "C" const fidl_type_t fuchsia_device_manager_Coordinator_UnbindDone_ResultTable;

struct Coordinator_UnbindDone_Result {
  enum class Tag : fidl_union_tag_t {
    kResponse = 0,
    kErr = 1,
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

  Coordinator_UnbindDone_Result();
  ~Coordinator_UnbindDone_Result();

  Coordinator_UnbindDone_Result(Coordinator_UnbindDone_Result&& other) {
    tag_ = Tag::Invalid;
    if (this != &other) {
      MoveImpl_(std::move(other));
    }
  }

  Coordinator_UnbindDone_Result& operator=(Coordinator_UnbindDone_Result&& other) {
    if (this != &other) {
      MoveImpl_(std::move(other));
    }
    return *this;
  }

  bool has_invalid_tag() const { return tag_ == Tag::Invalid; }

  bool is_response() const { return tag_ == Tag::kResponse; }

  static Coordinator_UnbindDone_Result WithResponse(Coordinator_UnbindDone_Response&& val) {
    Coordinator_UnbindDone_Result result;
    result.set_response(std::move(val));
    return result;
  }

  Coordinator_UnbindDone_Response& mutable_response();

  template <typename T>
  std::enable_if_t<std::is_convertible<T, Coordinator_UnbindDone_Response>::value && std::is_copy_assignable<T>::value>
  set_response(const T& v) {
    mutable_response() = v;
  }

  template <typename T>
  std::enable_if_t<std::is_convertible<T, Coordinator_UnbindDone_Response>::value && std::is_move_assignable<T>::value>
  set_response(T&& v) {
    mutable_response() = std::move(v);
  }

  Coordinator_UnbindDone_Response const & response() const { return response_; }

  bool is_err() const { return tag_ == Tag::kErr; }

  static Coordinator_UnbindDone_Result WithErr(int32_t&& val) {
    Coordinator_UnbindDone_Result result;
    result.set_err(std::move(val));
    return result;
  }

  int32_t& mutable_err();

  template <typename T>
  std::enable_if_t<std::is_convertible<T, int32_t>::value && std::is_copy_assignable<T>::value>
  set_err(const T& v) {
    mutable_err() = v;
  }

  template <typename T>
  std::enable_if_t<std::is_convertible<T, int32_t>::value && std::is_move_assignable<T>::value>
  set_err(T&& v) {
    mutable_err() = std::move(v);
  }

  int32_t const & err() const { return err_; }

  Tag which() const { return tag_; }

  static constexpr const fidl_type_t* Type = &fuchsia_device_manager_Coordinator_UnbindDone_ResultTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 8;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 0;

 private:
  void Destroy();
  void MoveImpl_(Coordinator_UnbindDone_Result&& other);
  static void SizeAndOffsetAssertionHelper();
  Tag tag_;
  union {
    Coordinator_UnbindDone_Response response_;
    int32_t err_;
  };
};


struct Coordinator_RunCompatibilityTests_Response {
  static constexpr const fidl_type_t* Type = nullptr;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 1;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 0;

  uint8_t __reserved = {};
};

extern "C" const fidl_type_t fuchsia_device_manager_Coordinator_RunCompatibilityTests_ResultTable;

struct Coordinator_RunCompatibilityTests_Result {
  enum class Tag : fidl_union_tag_t {
    kResponse = 0,
    kErr = 1,
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

  Coordinator_RunCompatibilityTests_Result();
  ~Coordinator_RunCompatibilityTests_Result();

  Coordinator_RunCompatibilityTests_Result(Coordinator_RunCompatibilityTests_Result&& other) {
    tag_ = Tag::Invalid;
    if (this != &other) {
      MoveImpl_(std::move(other));
    }
  }

  Coordinator_RunCompatibilityTests_Result& operator=(Coordinator_RunCompatibilityTests_Result&& other) {
    if (this != &other) {
      MoveImpl_(std::move(other));
    }
    return *this;
  }

  bool has_invalid_tag() const { return tag_ == Tag::Invalid; }

  bool is_response() const { return tag_ == Tag::kResponse; }

  static Coordinator_RunCompatibilityTests_Result WithResponse(Coordinator_RunCompatibilityTests_Response&& val) {
    Coordinator_RunCompatibilityTests_Result result;
    result.set_response(std::move(val));
    return result;
  }

  Coordinator_RunCompatibilityTests_Response& mutable_response();

  template <typename T>
  std::enable_if_t<std::is_convertible<T, Coordinator_RunCompatibilityTests_Response>::value && std::is_copy_assignable<T>::value>
  set_response(const T& v) {
    mutable_response() = v;
  }

  template <typename T>
  std::enable_if_t<std::is_convertible<T, Coordinator_RunCompatibilityTests_Response>::value && std::is_move_assignable<T>::value>
  set_response(T&& v) {
    mutable_response() = std::move(v);
  }

  Coordinator_RunCompatibilityTests_Response const & response() const { return response_; }

  bool is_err() const { return tag_ == Tag::kErr; }

  static Coordinator_RunCompatibilityTests_Result WithErr(int32_t&& val) {
    Coordinator_RunCompatibilityTests_Result result;
    result.set_err(std::move(val));
    return result;
  }

  int32_t& mutable_err();

  template <typename T>
  std::enable_if_t<std::is_convertible<T, int32_t>::value && std::is_copy_assignable<T>::value>
  set_err(const T& v) {
    mutable_err() = v;
  }

  template <typename T>
  std::enable_if_t<std::is_convertible<T, int32_t>::value && std::is_move_assignable<T>::value>
  set_err(T&& v) {
    mutable_err() = std::move(v);
  }

  int32_t const & err() const { return err_; }

  Tag which() const { return tag_; }

  static constexpr const fidl_type_t* Type = &fuchsia_device_manager_Coordinator_RunCompatibilityTests_ResultTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 8;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 0;

 private:
  void Destroy();
  void MoveImpl_(Coordinator_RunCompatibilityTests_Result&& other);
  static void SizeAndOffsetAssertionHelper();
  Tag tag_;
  union {
    Coordinator_RunCompatibilityTests_Response response_;
    int32_t err_;
  };
};


struct Coordinator_RemoveDone_Response {
  static constexpr const fidl_type_t* Type = nullptr;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 1;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 0;

  uint8_t __reserved = {};
};

extern "C" const fidl_type_t fuchsia_device_manager_Coordinator_RemoveDone_ResultTable;

struct Coordinator_RemoveDone_Result {
  enum class Tag : fidl_union_tag_t {
    kResponse = 0,
    kErr = 1,
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

  Coordinator_RemoveDone_Result();
  ~Coordinator_RemoveDone_Result();

  Coordinator_RemoveDone_Result(Coordinator_RemoveDone_Result&& other) {
    tag_ = Tag::Invalid;
    if (this != &other) {
      MoveImpl_(std::move(other));
    }
  }

  Coordinator_RemoveDone_Result& operator=(Coordinator_RemoveDone_Result&& other) {
    if (this != &other) {
      MoveImpl_(std::move(other));
    }
    return *this;
  }

  bool has_invalid_tag() const { return tag_ == Tag::Invalid; }

  bool is_response() const { return tag_ == Tag::kResponse; }

  static Coordinator_RemoveDone_Result WithResponse(Coordinator_RemoveDone_Response&& val) {
    Coordinator_RemoveDone_Result result;
    result.set_response(std::move(val));
    return result;
  }

  Coordinator_RemoveDone_Response& mutable_response();

  template <typename T>
  std::enable_if_t<std::is_convertible<T, Coordinator_RemoveDone_Response>::value && std::is_copy_assignable<T>::value>
  set_response(const T& v) {
    mutable_response() = v;
  }

  template <typename T>
  std::enable_if_t<std::is_convertible<T, Coordinator_RemoveDone_Response>::value && std::is_move_assignable<T>::value>
  set_response(T&& v) {
    mutable_response() = std::move(v);
  }

  Coordinator_RemoveDone_Response const & response() const { return response_; }

  bool is_err() const { return tag_ == Tag::kErr; }

  static Coordinator_RemoveDone_Result WithErr(int32_t&& val) {
    Coordinator_RemoveDone_Result result;
    result.set_err(std::move(val));
    return result;
  }

  int32_t& mutable_err();

  template <typename T>
  std::enable_if_t<std::is_convertible<T, int32_t>::value && std::is_copy_assignable<T>::value>
  set_err(const T& v) {
    mutable_err() = v;
  }

  template <typename T>
  std::enable_if_t<std::is_convertible<T, int32_t>::value && std::is_move_assignable<T>::value>
  set_err(T&& v) {
    mutable_err() = std::move(v);
  }

  int32_t const & err() const { return err_; }

  Tag which() const { return tag_; }

  static constexpr const fidl_type_t* Type = &fuchsia_device_manager_Coordinator_RemoveDone_ResultTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 8;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 0;

 private:
  void Destroy();
  void MoveImpl_(Coordinator_RemoveDone_Result&& other);
  static void SizeAndOffsetAssertionHelper();
  Tag tag_;
  union {
    Coordinator_RemoveDone_Response response_;
    int32_t err_;
  };
};


struct Coordinator_PublishMetadata_Response {
  static constexpr const fidl_type_t* Type = nullptr;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 1;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 0;

  uint8_t __reserved = {};
};

extern "C" const fidl_type_t fuchsia_device_manager_Coordinator_PublishMetadata_ResultTable;

struct Coordinator_PublishMetadata_Result {
  enum class Tag : fidl_union_tag_t {
    kResponse = 0,
    kErr = 1,
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

  Coordinator_PublishMetadata_Result();
  ~Coordinator_PublishMetadata_Result();

  Coordinator_PublishMetadata_Result(Coordinator_PublishMetadata_Result&& other) {
    tag_ = Tag::Invalid;
    if (this != &other) {
      MoveImpl_(std::move(other));
    }
  }

  Coordinator_PublishMetadata_Result& operator=(Coordinator_PublishMetadata_Result&& other) {
    if (this != &other) {
      MoveImpl_(std::move(other));
    }
    return *this;
  }

  bool has_invalid_tag() const { return tag_ == Tag::Invalid; }

  bool is_response() const { return tag_ == Tag::kResponse; }

  static Coordinator_PublishMetadata_Result WithResponse(Coordinator_PublishMetadata_Response&& val) {
    Coordinator_PublishMetadata_Result result;
    result.set_response(std::move(val));
    return result;
  }

  Coordinator_PublishMetadata_Response& mutable_response();

  template <typename T>
  std::enable_if_t<std::is_convertible<T, Coordinator_PublishMetadata_Response>::value && std::is_copy_assignable<T>::value>
  set_response(const T& v) {
    mutable_response() = v;
  }

  template <typename T>
  std::enable_if_t<std::is_convertible<T, Coordinator_PublishMetadata_Response>::value && std::is_move_assignable<T>::value>
  set_response(T&& v) {
    mutable_response() = std::move(v);
  }

  Coordinator_PublishMetadata_Response const & response() const { return response_; }

  bool is_err() const { return tag_ == Tag::kErr; }

  static Coordinator_PublishMetadata_Result WithErr(int32_t&& val) {
    Coordinator_PublishMetadata_Result result;
    result.set_err(std::move(val));
    return result;
  }

  int32_t& mutable_err();

  template <typename T>
  std::enable_if_t<std::is_convertible<T, int32_t>::value && std::is_copy_assignable<T>::value>
  set_err(const T& v) {
    mutable_err() = v;
  }

  template <typename T>
  std::enable_if_t<std::is_convertible<T, int32_t>::value && std::is_move_assignable<T>::value>
  set_err(T&& v) {
    mutable_err() = std::move(v);
  }

  int32_t const & err() const { return err_; }

  Tag which() const { return tag_; }

  static constexpr const fidl_type_t* Type = &fuchsia_device_manager_Coordinator_PublishMetadata_ResultTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 8;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 0;

 private:
  void Destroy();
  void MoveImpl_(Coordinator_PublishMetadata_Result&& other);
  static void SizeAndOffsetAssertionHelper();
  Tag tag_;
  union {
    Coordinator_PublishMetadata_Response response_;
    int32_t err_;
  };
};


struct Coordinator_MakeVisible_Response {
  static constexpr const fidl_type_t* Type = nullptr;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 1;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 0;

  uint8_t __reserved = {};
};

extern "C" const fidl_type_t fuchsia_device_manager_Coordinator_MakeVisible_ResultTable;

struct Coordinator_MakeVisible_Result {
  enum class Tag : fidl_union_tag_t {
    kResponse = 0,
    kErr = 1,
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

  Coordinator_MakeVisible_Result();
  ~Coordinator_MakeVisible_Result();

  Coordinator_MakeVisible_Result(Coordinator_MakeVisible_Result&& other) {
    tag_ = Tag::Invalid;
    if (this != &other) {
      MoveImpl_(std::move(other));
    }
  }

  Coordinator_MakeVisible_Result& operator=(Coordinator_MakeVisible_Result&& other) {
    if (this != &other) {
      MoveImpl_(std::move(other));
    }
    return *this;
  }

  bool has_invalid_tag() const { return tag_ == Tag::Invalid; }

  bool is_response() const { return tag_ == Tag::kResponse; }

  static Coordinator_MakeVisible_Result WithResponse(Coordinator_MakeVisible_Response&& val) {
    Coordinator_MakeVisible_Result result;
    result.set_response(std::move(val));
    return result;
  }

  Coordinator_MakeVisible_Response& mutable_response();

  template <typename T>
  std::enable_if_t<std::is_convertible<T, Coordinator_MakeVisible_Response>::value && std::is_copy_assignable<T>::value>
  set_response(const T& v) {
    mutable_response() = v;
  }

  template <typename T>
  std::enable_if_t<std::is_convertible<T, Coordinator_MakeVisible_Response>::value && std::is_move_assignable<T>::value>
  set_response(T&& v) {
    mutable_response() = std::move(v);
  }

  Coordinator_MakeVisible_Response const & response() const { return response_; }

  bool is_err() const { return tag_ == Tag::kErr; }

  static Coordinator_MakeVisible_Result WithErr(int32_t&& val) {
    Coordinator_MakeVisible_Result result;
    result.set_err(std::move(val));
    return result;
  }

  int32_t& mutable_err();

  template <typename T>
  std::enable_if_t<std::is_convertible<T, int32_t>::value && std::is_copy_assignable<T>::value>
  set_err(const T& v) {
    mutable_err() = v;
  }

  template <typename T>
  std::enable_if_t<std::is_convertible<T, int32_t>::value && std::is_move_assignable<T>::value>
  set_err(T&& v) {
    mutable_err() = std::move(v);
  }

  int32_t const & err() const { return err_; }

  Tag which() const { return tag_; }

  static constexpr const fidl_type_t* Type = &fuchsia_device_manager_Coordinator_MakeVisible_ResultTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 8;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 0;

 private:
  void Destroy();
  void MoveImpl_(Coordinator_MakeVisible_Result&& other);
  static void SizeAndOffsetAssertionHelper();
  Tag tag_;
  union {
    Coordinator_MakeVisible_Response response_;
    int32_t err_;
  };
};

extern "C" const fidl_type_t fuchsia_device_manager_Coordinator_LoadFirmware_ResponseTable;

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

  ::zx::vmo vmo = {};

  uint64_t size = {};
};

extern "C" const fidl_type_t fuchsia_device_manager_Coordinator_LoadFirmware_ResultTable;

struct Coordinator_LoadFirmware_Result {
  enum class Tag : fidl_union_tag_t {
    kResponse = 0,
    kErr = 1,
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

  Coordinator_LoadFirmware_Result();
  ~Coordinator_LoadFirmware_Result();

  Coordinator_LoadFirmware_Result(Coordinator_LoadFirmware_Result&& other) {
    tag_ = Tag::Invalid;
    if (this != &other) {
      MoveImpl_(std::move(other));
    }
  }

  Coordinator_LoadFirmware_Result& operator=(Coordinator_LoadFirmware_Result&& other) {
    if (this != &other) {
      MoveImpl_(std::move(other));
    }
    return *this;
  }

  bool has_invalid_tag() const { return tag_ == Tag::Invalid; }

  bool is_response() const { return tag_ == Tag::kResponse; }

  static Coordinator_LoadFirmware_Result WithResponse(Coordinator_LoadFirmware_Response&& val) {
    Coordinator_LoadFirmware_Result result;
    result.set_response(std::move(val));
    return result;
  }

  Coordinator_LoadFirmware_Response& mutable_response();

  template <typename T>
  std::enable_if_t<std::is_convertible<T, Coordinator_LoadFirmware_Response>::value && std::is_copy_assignable<T>::value>
  set_response(const T& v) {
    mutable_response() = v;
  }

  template <typename T>
  std::enable_if_t<std::is_convertible<T, Coordinator_LoadFirmware_Response>::value && std::is_move_assignable<T>::value>
  set_response(T&& v) {
    mutable_response() = std::move(v);
  }

  Coordinator_LoadFirmware_Response const & response() const { return response_; }

  bool is_err() const { return tag_ == Tag::kErr; }

  static Coordinator_LoadFirmware_Result WithErr(int32_t&& val) {
    Coordinator_LoadFirmware_Result result;
    result.set_err(std::move(val));
    return result;
  }

  int32_t& mutable_err();

  template <typename T>
  std::enable_if_t<std::is_convertible<T, int32_t>::value && std::is_copy_assignable<T>::value>
  set_err(const T& v) {
    mutable_err() = v;
  }

  template <typename T>
  std::enable_if_t<std::is_convertible<T, int32_t>::value && std::is_move_assignable<T>::value>
  set_err(T&& v) {
    mutable_err() = std::move(v);
  }

  int32_t const & err() const { return err_; }

  Tag which() const { return tag_; }

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

 private:
  void Destroy();
  void MoveImpl_(Coordinator_LoadFirmware_Result&& other);
  static void SizeAndOffsetAssertionHelper();
  Tag tag_;
  union {
    Coordinator_LoadFirmware_Response response_;
    int32_t err_;
  };
};

extern "C" const fidl_type_t fuchsia_device_manager_Coordinator_GetTopologicalPath_ResponseTable;

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

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

extern "C" const fidl_type_t fuchsia_device_manager_Coordinator_GetTopologicalPath_ResultTable;

struct Coordinator_GetTopologicalPath_Result {
  enum class Tag : fidl_union_tag_t {
    kResponse = 0,
    kErr = 1,
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

  Coordinator_GetTopologicalPath_Result();
  ~Coordinator_GetTopologicalPath_Result();

  Coordinator_GetTopologicalPath_Result(Coordinator_GetTopologicalPath_Result&& other) {
    tag_ = Tag::Invalid;
    if (this != &other) {
      MoveImpl_(std::move(other));
    }
  }

  Coordinator_GetTopologicalPath_Result& operator=(Coordinator_GetTopologicalPath_Result&& other) {
    if (this != &other) {
      MoveImpl_(std::move(other));
    }
    return *this;
  }

  bool has_invalid_tag() const { return tag_ == Tag::Invalid; }

  bool is_response() const { return tag_ == Tag::kResponse; }

  static Coordinator_GetTopologicalPath_Result WithResponse(Coordinator_GetTopologicalPath_Response&& val) {
    Coordinator_GetTopologicalPath_Result result;
    result.set_response(std::move(val));
    return result;
  }

  Coordinator_GetTopologicalPath_Response& mutable_response();

  template <typename T>
  std::enable_if_t<std::is_convertible<T, Coordinator_GetTopologicalPath_Response>::value && std::is_copy_assignable<T>::value>
  set_response(const T& v) {
    mutable_response() = v;
  }

  template <typename T>
  std::enable_if_t<std::is_convertible<T, Coordinator_GetTopologicalPath_Response>::value && std::is_move_assignable<T>::value>
  set_response(T&& v) {
    mutable_response() = std::move(v);
  }

  Coordinator_GetTopologicalPath_Response const & response() const { return response_; }

  bool is_err() const { return tag_ == Tag::kErr; }

  static Coordinator_GetTopologicalPath_Result WithErr(int32_t&& val) {
    Coordinator_GetTopologicalPath_Result result;
    result.set_err(std::move(val));
    return result;
  }

  int32_t& mutable_err();

  template <typename T>
  std::enable_if_t<std::is_convertible<T, int32_t>::value && std::is_copy_assignable<T>::value>
  set_err(const T& v) {
    mutable_err() = v;
  }

  template <typename T>
  std::enable_if_t<std::is_convertible<T, int32_t>::value && std::is_move_assignable<T>::value>
  set_err(T&& v) {
    mutable_err() = std::move(v);
  }

  int32_t const & err() const { return err_; }

  Tag which() const { return tag_; }

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

 private:
  void Destroy();
  void MoveImpl_(Coordinator_GetTopologicalPath_Result&& other);
  static void SizeAndOffsetAssertionHelper();
  Tag tag_;
  union {
    Coordinator_GetTopologicalPath_Response response_;
    int32_t err_;
  };
};

extern "C" const fidl_type_t fuchsia_device_manager_Coordinator_GetMetadata_ResponseTable;

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

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

extern "C" const fidl_type_t fuchsia_device_manager_Coordinator_GetMetadata_ResultTable;

struct Coordinator_GetMetadata_Result {
  enum class Tag : fidl_union_tag_t {
    kResponse = 0,
    kErr = 1,
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

  Coordinator_GetMetadata_Result();
  ~Coordinator_GetMetadata_Result();

  Coordinator_GetMetadata_Result(Coordinator_GetMetadata_Result&& other) {
    tag_ = Tag::Invalid;
    if (this != &other) {
      MoveImpl_(std::move(other));
    }
  }

  Coordinator_GetMetadata_Result& operator=(Coordinator_GetMetadata_Result&& other) {
    if (this != &other) {
      MoveImpl_(std::move(other));
    }
    return *this;
  }

  bool has_invalid_tag() const { return tag_ == Tag::Invalid; }

  bool is_response() const { return tag_ == Tag::kResponse; }

  static Coordinator_GetMetadata_Result WithResponse(Coordinator_GetMetadata_Response&& val) {
    Coordinator_GetMetadata_Result result;
    result.set_response(std::move(val));
    return result;
  }

  Coordinator_GetMetadata_Response& mutable_response();

  template <typename T>
  std::enable_if_t<std::is_convertible<T, Coordinator_GetMetadata_Response>::value && std::is_copy_assignable<T>::value>
  set_response(const T& v) {
    mutable_response() = v;
  }

  template <typename T>
  std::enable_if_t<std::is_convertible<T, Coordinator_GetMetadata_Response>::value && std::is_move_assignable<T>::value>
  set_response(T&& v) {
    mutable_response() = std::move(v);
  }

  Coordinator_GetMetadata_Response const & response() const { return response_; }

  bool is_err() const { return tag_ == Tag::kErr; }

  static Coordinator_GetMetadata_Result WithErr(int32_t&& val) {
    Coordinator_GetMetadata_Result result;
    result.set_err(std::move(val));
    return result;
  }

  int32_t& mutable_err();

  template <typename T>
  std::enable_if_t<std::is_convertible<T, int32_t>::value && std::is_copy_assignable<T>::value>
  set_err(const T& v) {
    mutable_err() = v;
  }

  template <typename T>
  std::enable_if_t<std::is_convertible<T, int32_t>::value && std::is_move_assignable<T>::value>
  set_err(T&& v) {
    mutable_err() = std::move(v);
  }

  int32_t const & err() const { return err_; }

  Tag which() const { return tag_; }

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

 private:
  void Destroy();
  void MoveImpl_(Coordinator_GetMetadata_Result&& other);
  static void SizeAndOffsetAssertionHelper();
  Tag tag_;
  union {
    Coordinator_GetMetadata_Response response_;
    int32_t err_;
  };
};


struct Coordinator_GetMetadataSize_Response {
  static constexpr const fidl_type_t* Type = nullptr;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 8;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 0;

  uint64_t size = {};
};

extern "C" const fidl_type_t fuchsia_device_manager_Coordinator_GetMetadataSize_ResultTable;

struct Coordinator_GetMetadataSize_Result {
  enum class Tag : fidl_union_tag_t {
    kResponse = 0,
    kErr = 1,
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

  Coordinator_GetMetadataSize_Result();
  ~Coordinator_GetMetadataSize_Result();

  Coordinator_GetMetadataSize_Result(Coordinator_GetMetadataSize_Result&& other) {
    tag_ = Tag::Invalid;
    if (this != &other) {
      MoveImpl_(std::move(other));
    }
  }

  Coordinator_GetMetadataSize_Result& operator=(Coordinator_GetMetadataSize_Result&& other) {
    if (this != &other) {
      MoveImpl_(std::move(other));
    }
    return *this;
  }

  bool has_invalid_tag() const { return tag_ == Tag::Invalid; }

  bool is_response() const { return tag_ == Tag::kResponse; }

  static Coordinator_GetMetadataSize_Result WithResponse(Coordinator_GetMetadataSize_Response&& val) {
    Coordinator_GetMetadataSize_Result result;
    result.set_response(std::move(val));
    return result;
  }

  Coordinator_GetMetadataSize_Response& mutable_response();

  template <typename T>
  std::enable_if_t<std::is_convertible<T, Coordinator_GetMetadataSize_Response>::value && std::is_copy_assignable<T>::value>
  set_response(const T& v) {
    mutable_response() = v;
  }

  template <typename T>
  std::enable_if_t<std::is_convertible<T, Coordinator_GetMetadataSize_Response>::value && std::is_move_assignable<T>::value>
  set_response(T&& v) {
    mutable_response() = std::move(v);
  }

  Coordinator_GetMetadataSize_Response const & response() const { return response_; }

  bool is_err() const { return tag_ == Tag::kErr; }

  static Coordinator_GetMetadataSize_Result WithErr(int32_t&& val) {
    Coordinator_GetMetadataSize_Result result;
    result.set_err(std::move(val));
    return result;
  }

  int32_t& mutable_err();

  template <typename T>
  std::enable_if_t<std::is_convertible<T, int32_t>::value && std::is_copy_assignable<T>::value>
  set_err(const T& v) {
    mutable_err() = v;
  }

  template <typename T>
  std::enable_if_t<std::is_convertible<T, int32_t>::value && std::is_move_assignable<T>::value>
  set_err(T&& v) {
    mutable_err() = std::move(v);
  }

  int32_t const & err() const { return err_; }

  Tag which() const { return tag_; }

  static constexpr const fidl_type_t* Type = &fuchsia_device_manager_Coordinator_GetMetadataSize_ResultTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 16;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 0;

 private:
  void Destroy();
  void MoveImpl_(Coordinator_GetMetadataSize_Result&& other);
  static void SizeAndOffsetAssertionHelper();
  Tag tag_;
  union {
    Coordinator_GetMetadataSize_Response response_;
    int32_t err_;
  };
};


struct Coordinator_DirectoryWatch_Response {
  static constexpr const fidl_type_t* Type = nullptr;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 1;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 0;

  uint8_t __reserved = {};
};

extern "C" const fidl_type_t fuchsia_device_manager_Coordinator_DirectoryWatch_ResultTable;

struct Coordinator_DirectoryWatch_Result {
  enum class Tag : fidl_union_tag_t {
    kResponse = 0,
    kErr = 1,
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

  Coordinator_DirectoryWatch_Result();
  ~Coordinator_DirectoryWatch_Result();

  Coordinator_DirectoryWatch_Result(Coordinator_DirectoryWatch_Result&& other) {
    tag_ = Tag::Invalid;
    if (this != &other) {
      MoveImpl_(std::move(other));
    }
  }

  Coordinator_DirectoryWatch_Result& operator=(Coordinator_DirectoryWatch_Result&& other) {
    if (this != &other) {
      MoveImpl_(std::move(other));
    }
    return *this;
  }

  bool has_invalid_tag() const { return tag_ == Tag::Invalid; }

  bool is_response() const { return tag_ == Tag::kResponse; }

  static Coordinator_DirectoryWatch_Result WithResponse(Coordinator_DirectoryWatch_Response&& val) {
    Coordinator_DirectoryWatch_Result result;
    result.set_response(std::move(val));
    return result;
  }

  Coordinator_DirectoryWatch_Response& mutable_response();

  template <typename T>
  std::enable_if_t<std::is_convertible<T, Coordinator_DirectoryWatch_Response>::value && std::is_copy_assignable<T>::value>
  set_response(const T& v) {
    mutable_response() = v;
  }

  template <typename T>
  std::enable_if_t<std::is_convertible<T, Coordinator_DirectoryWatch_Response>::value && std::is_move_assignable<T>::value>
  set_response(T&& v) {
    mutable_response() = std::move(v);
  }

  Coordinator_DirectoryWatch_Response const & response() const { return response_; }

  bool is_err() const { return tag_ == Tag::kErr; }

  static Coordinator_DirectoryWatch_Result WithErr(int32_t&& val) {
    Coordinator_DirectoryWatch_Result result;
    result.set_err(std::move(val));
    return result;
  }

  int32_t& mutable_err();

  template <typename T>
  std::enable_if_t<std::is_convertible<T, int32_t>::value && std::is_copy_assignable<T>::value>
  set_err(const T& v) {
    mutable_err() = v;
  }

  template <typename T>
  std::enable_if_t<std::is_convertible<T, int32_t>::value && std::is_move_assignable<T>::value>
  set_err(T&& v) {
    mutable_err() = std::move(v);
  }

  int32_t const & err() const { return err_; }

  Tag which() const { return tag_; }

  static constexpr const fidl_type_t* Type = &fuchsia_device_manager_Coordinator_DirectoryWatch_ResultTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 8;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 0;

 private:
  void Destroy();
  void MoveImpl_(Coordinator_DirectoryWatch_Result&& other);
  static void SizeAndOffsetAssertionHelper();
  Tag tag_;
  union {
    Coordinator_DirectoryWatch_Response response_;
    int32_t err_;
  };
};


struct Coordinator_BindDevice_Response {
  static constexpr const fidl_type_t* Type = nullptr;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 1;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 0;

  uint8_t __reserved = {};
};

extern "C" const fidl_type_t fuchsia_device_manager_Coordinator_BindDevice_ResultTable;

struct Coordinator_BindDevice_Result {
  enum class Tag : fidl_union_tag_t {
    kResponse = 0,
    kErr = 1,
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

  Coordinator_BindDevice_Result();
  ~Coordinator_BindDevice_Result();

  Coordinator_BindDevice_Result(Coordinator_BindDevice_Result&& other) {
    tag_ = Tag::Invalid;
    if (this != &other) {
      MoveImpl_(std::move(other));
    }
  }

  Coordinator_BindDevice_Result& operator=(Coordinator_BindDevice_Result&& other) {
    if (this != &other) {
      MoveImpl_(std::move(other));
    }
    return *this;
  }

  bool has_invalid_tag() const { return tag_ == Tag::Invalid; }

  bool is_response() const { return tag_ == Tag::kResponse; }

  static Coordinator_BindDevice_Result WithResponse(Coordinator_BindDevice_Response&& val) {
    Coordinator_BindDevice_Result result;
    result.set_response(std::move(val));
    return result;
  }

  Coordinator_BindDevice_Response& mutable_response();

  template <typename T>
  std::enable_if_t<std::is_convertible<T, Coordinator_BindDevice_Response>::value && std::is_copy_assignable<T>::value>
  set_response(const T& v) {
    mutable_response() = v;
  }

  template <typename T>
  std::enable_if_t<std::is_convertible<T, Coordinator_BindDevice_Response>::value && std::is_move_assignable<T>::value>
  set_response(T&& v) {
    mutable_response() = std::move(v);
  }

  Coordinator_BindDevice_Response const & response() const { return response_; }

  bool is_err() const { return tag_ == Tag::kErr; }

  static Coordinator_BindDevice_Result WithErr(int32_t&& val) {
    Coordinator_BindDevice_Result result;
    result.set_err(std::move(val));
    return result;
  }

  int32_t& mutable_err();

  template <typename T>
  std::enable_if_t<std::is_convertible<T, int32_t>::value && std::is_copy_assignable<T>::value>
  set_err(const T& v) {
    mutable_err() = v;
  }

  template <typename T>
  std::enable_if_t<std::is_convertible<T, int32_t>::value && std::is_move_assignable<T>::value>
  set_err(T&& v) {
    mutable_err() = std::move(v);
  }

  int32_t const & err() const { return err_; }

  Tag which() const { return tag_; }

  static constexpr const fidl_type_t* Type = &fuchsia_device_manager_Coordinator_BindDevice_ResultTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 8;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 0;

 private:
  void Destroy();
  void MoveImpl_(Coordinator_BindDevice_Result&& other);
  static void SizeAndOffsetAssertionHelper();
  Tag tag_;
  union {
    Coordinator_BindDevice_Response response_;
    int32_t err_;
  };
};


struct Coordinator_AddMetadata_Response {
  static constexpr const fidl_type_t* Type = nullptr;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 1;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 0;

  uint8_t __reserved = {};
};

extern "C" const fidl_type_t fuchsia_device_manager_Coordinator_AddMetadata_ResultTable;

struct Coordinator_AddMetadata_Result {
  enum class Tag : fidl_union_tag_t {
    kResponse = 0,
    kErr = 1,
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

  Coordinator_AddMetadata_Result();
  ~Coordinator_AddMetadata_Result();

  Coordinator_AddMetadata_Result(Coordinator_AddMetadata_Result&& other) {
    tag_ = Tag::Invalid;
    if (this != &other) {
      MoveImpl_(std::move(other));
    }
  }

  Coordinator_AddMetadata_Result& operator=(Coordinator_AddMetadata_Result&& other) {
    if (this != &other) {
      MoveImpl_(std::move(other));
    }
    return *this;
  }

  bool has_invalid_tag() const { return tag_ == Tag::Invalid; }

  bool is_response() const { return tag_ == Tag::kResponse; }

  static Coordinator_AddMetadata_Result WithResponse(Coordinator_AddMetadata_Response&& val) {
    Coordinator_AddMetadata_Result result;
    result.set_response(std::move(val));
    return result;
  }

  Coordinator_AddMetadata_Response& mutable_response();

  template <typename T>
  std::enable_if_t<std::is_convertible<T, Coordinator_AddMetadata_Response>::value && std::is_copy_assignable<T>::value>
  set_response(const T& v) {
    mutable_response() = v;
  }

  template <typename T>
  std::enable_if_t<std::is_convertible<T, Coordinator_AddMetadata_Response>::value && std::is_move_assignable<T>::value>
  set_response(T&& v) {
    mutable_response() = std::move(v);
  }

  Coordinator_AddMetadata_Response const & response() const { return response_; }

  bool is_err() const { return tag_ == Tag::kErr; }

  static Coordinator_AddMetadata_Result WithErr(int32_t&& val) {
    Coordinator_AddMetadata_Result result;
    result.set_err(std::move(val));
    return result;
  }

  int32_t& mutable_err();

  template <typename T>
  std::enable_if_t<std::is_convertible<T, int32_t>::value && std::is_copy_assignable<T>::value>
  set_err(const T& v) {
    mutable_err() = v;
  }

  template <typename T>
  std::enable_if_t<std::is_convertible<T, int32_t>::value && std::is_move_assignable<T>::value>
  set_err(T&& v) {
    mutable_err() = std::move(v);
  }

  int32_t const & err() const { return err_; }

  Tag which() const { return tag_; }

  static constexpr const fidl_type_t* Type = &fuchsia_device_manager_Coordinator_AddMetadata_ResultTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 8;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 0;

 private:
  void Destroy();
  void MoveImpl_(Coordinator_AddMetadata_Result&& other);
  static void SizeAndOffsetAssertionHelper();
  Tag tag_;
  union {
    Coordinator_AddMetadata_Response response_;
    int32_t err_;
  };
};


struct Coordinator_AddCompositeDevice_Response {
  static constexpr const fidl_type_t* Type = nullptr;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 1;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 0;

  uint8_t __reserved = {};
};

extern "C" const fidl_type_t fuchsia_device_manager_Coordinator_AddCompositeDevice_ResultTable;

struct Coordinator_AddCompositeDevice_Result {
  enum class Tag : fidl_union_tag_t {
    kResponse = 0,
    kErr = 1,
    Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(),
  };

  Coordinator_AddCompositeDevice_Result();
  ~Coordinator_AddCompositeDevice_Result();

  Coordinator_AddCompositeDevice_Result(Coordinator_AddCompositeDevice_Result&& other) {
    tag_ = Tag::Invalid;
    if (this != &other) {
      MoveImpl_(std::move(other));
    }
  }

  Coordinator_AddCompositeDevice_Result& operator=(Coordinator_AddCompositeDevice_Result&& other) {
    if (this != &other) {
      MoveImpl_(std::move(other));
    }
    return *this;
  }

  bool has_invalid_tag() const { return tag_ == Tag::Invalid; }

  bool is_response() const { return tag_ == Tag::kResponse; }

  static Coordinator_AddCompositeDevice_Result WithResponse(Coordinator_AddCompositeDevice_Response&& val) {
    Coordinator_AddCompositeDevice_Result result;
    result.set_response(std::move(val));
    return result;
  }

  Coordinator_AddCompositeDevice_Response& mutable_response();

  template <typename T>
  std::enable_if_t<std::is_convertible<T, Coordinator_AddCompositeDevice_Response>::value && std::is_copy_assignable<T>::value>
  set_response(const T& v) {
    mutable_response() = v;
  }

  template <typename T>
  std::enable_if_t<std::is_convertible<T, Coordinator_AddCompositeDevice_Response>::value && std::is_move_assignable<T>::value>
  set_response(T&& v) {
    mutable_response() = std::move(v);
  }

  Coordinator_AddCompositeDevice_Response const & response() const { return response_; }

  bool is_err() const { return tag_ == Tag::kErr; }

  static Coordinator_AddCompositeDevice_Result WithErr(int32_t&& val) {
    Coordinator_AddCompositeDevice_Result result;
    result.set_err(std::move(val));
    return result;
  }

  int32_t& mutable_err();

  template <typename T>
  std::enable_if_t<std::is_convertible<T, int32_t>::value && std::is_copy_assignable<T>::value>
  set_err(const T& v) {
    mutable_err() = v;
  }

  template <typename T>
  std::enable_if_t<std::is_convertible<T, int32_t>::value && std::is_move_assignable<T>::value>
  set_err(T&& v) {
    mutable_err() = std::move(v);
  }

  int32_t const & err() const { return err_; }

  Tag which() const { return tag_; }

  static constexpr const fidl_type_t* Type = &fuchsia_device_manager_Coordinator_AddCompositeDevice_ResultTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 8;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 0;

 private:
  void Destroy();
  void MoveImpl_(Coordinator_AddCompositeDevice_Result&& other);
  static void SizeAndOffsetAssertionHelper();
  Tag tag_;
  union {
    Coordinator_AddCompositeDevice_Response response_;
    int32_t err_;
  };
};

extern "C" const fidl_type_t fuchsia_device_manager_DeviceControllerBindDriverRequestTable;
extern "C" const fidl_type_t fuchsia_device_manager_DeviceControllerBindDriverResponseTable;
extern "C" const fidl_type_t fuchsia_device_manager_DeviceControllerConnectProxyRequestTable;
extern "C" const fidl_type_t fuchsia_device_manager_DeviceControllerSuspendRequestTable;
extern "C" const fidl_type_t fuchsia_device_manager_DeviceControllerSuspendResponseTable;
extern "C" const fidl_type_t fuchsia_device_manager_DeviceControllerCompleteCompatibilityTestsRequestTable;

// 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 = &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 ::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 = &fuchsia_device_manager_DeviceControllerBindDriverRequestTable;
    static constexpr uint32_t MaxNumHandles = 1;
    static constexpr uint32_t PrimarySize = 40;
    static constexpr uint32_t MaxOutOfLine = 1024;
    static constexpr bool HasFlexibleEnvelope = 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 = &fuchsia_device_manager_DeviceControllerConnectProxyRequestTable;
    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 ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kRequest;
  };

  using UnbindRequest = ::fidl::AnyZeroArgMessage;

  using CompleteRemovalRequest = ::fidl::AnyZeroArgMessage;

  using RemoveDeviceRequest = ::fidl::AnyZeroArgMessage;

  struct SuspendResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t status;

    static constexpr const fidl_type_t* Type = &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 ::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 = &fuchsia_device_manager_DeviceControllerSuspendRequestTable;
    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 ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kRequest;
    using ResponseType = SuspendResponse;
  };

  struct CompleteCompatibilityTestsRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    CompatibilityTestStatus status;

    static constexpr const fidl_type_t* Type = &fuchsia_device_manager_DeviceControllerCompleteCompatibilityTestsRequestTable;
    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 ::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;
    };
    class Unbind_Impl final : private ::fidl::internal::StatusAndError {
      using Super = ::fidl::internal::StatusAndError;
     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;
    };
    class CompleteRemoval_Impl final : private ::fidl::internal::StatusAndError {
      using Super = ::fidl::internal::StatusAndError;
     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;
    };
    class RemoveDevice_Impl final : private ::fidl::internal::StatusAndError {
      using Super = ::fidl::internal::StatusAndError;
     public:
      RemoveDevice_Impl(zx::unowned_channel _client_end);
      ~RemoveDevice_Impl() = default;
      RemoveDevice_Impl(RemoveDevice_Impl&& other) = default;
      RemoveDevice_Impl& operator=(RemoveDevice_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
    };
    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*;
    };
    class CompleteCompatibilityTests_Impl final : private ::fidl::internal::StatusAndError {
      using Super = ::fidl::internal::StatusAndError;
     public:
      CompleteCompatibilityTests_Impl(zx::unowned_channel _client_end, 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 Unbind = Unbind_Impl;
    using CompleteRemoval = CompleteRemoval_Impl;
    using RemoveDevice = RemoveDevice_Impl;
    using Suspend = Suspend_Impl<SuspendResponse>;
    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;
    };
    class Unbind_Impl final : private ::fidl::internal::StatusAndError {
      using Super = ::fidl::internal::StatusAndError;
     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;
    };
    class CompleteRemoval_Impl final : private ::fidl::internal::StatusAndError {
      using Super = ::fidl::internal::StatusAndError;
     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;
    };
    class RemoveDevice_Impl final : private ::fidl::internal::StatusAndError {
      using Super = ::fidl::internal::StatusAndError;
     public:
      RemoveDevice_Impl(zx::unowned_channel _client_end);
      ~RemoveDevice_Impl() = default;
      RemoveDevice_Impl(RemoveDevice_Impl&& other) = default;
      RemoveDevice_Impl& operator=(RemoveDevice_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
    };
    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*;
    };
    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, 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 Unbind = Unbind_Impl;
    using CompleteRemoval = CompleteRemoval_Impl;
    using RemoveDevice = RemoveDevice_Impl;
    using Suspend = Suspend_Impl<SuspendResponse>;
    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 unbind this device. On success, the remote end of this
    // interface channel will close instead of returning a result.
    // Allocates 16 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::Unbind Unbind();


    // 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 16 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::CompleteRemoval CompleteRemoval();


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


    // 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);

    // 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(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, 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 unbind this device. On success, the remote end of this
    // interface channel will close instead of returning a result.
    // Allocates 16 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::Unbind Unbind(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|.
    // Allocates 16 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::CompleteRemoval CompleteRemoval(zx::unowned_channel _client_end);


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


    // 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);

    // 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, 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, 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 unbind this device. On success, the remote end of this
    // interface channel will close instead of returning a result.
    static ::fidl::internal::StatusAndError Unbind(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|.
    static ::fidl::internal::StatusAndError CompleteRemoval(zx::unowned_channel _client_end);

    // Ask the devhost to remove this device.  On success, the remote end of
    // this interface channel will close instead of returning a result.
    static ::fidl::internal::StatusAndError RemoveDevice(zx::unowned_channel _client_end);

    // 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);

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

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

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

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

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

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

    virtual void RemoveDevice(RemoveDeviceCompleter::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;

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

    virtual void CompleteCompatibilityTests(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);
  }

};

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


struct BindInstruction {
  static constexpr const fidl_type_t* Type = nullptr;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 8;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 0;

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

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


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

  uint32_t match_program_count = {};

  ::fidl::Array<BindInstruction, 32> match_program = {};
};


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

  uint32_t parts_count = {};

  ::fidl::Array<DeviceComponentPart, 16> parts = {};
};

extern "C" const fidl_type_t fuchsia_device_manager_CoordinatorAddDeviceRequestTable;
extern "C" const fidl_type_t fuchsia_device_manager_CoordinatorAddDeviceResponseTable;
extern "C" const fidl_type_t fuchsia_device_manager_CoordinatorAddDeviceInvisibleRequestTable;
extern "C" const fidl_type_t fuchsia_device_manager_CoordinatorAddDeviceInvisibleResponseTable;
extern "C" const fidl_type_t fuchsia_device_manager_CoordinatorScheduleRemoveRequestTable;
extern "C" const fidl_type_t fuchsia_device_manager_CoordinatorUnbindDoneResponseTable;
extern "C" const fidl_type_t fuchsia_device_manager_CoordinatorRemoveDoneResponseTable;
extern "C" const fidl_type_t fuchsia_device_manager_CoordinatorMakeVisibleResponseTable;
extern "C" const fidl_type_t fuchsia_device_manager_CoordinatorBindDeviceRequestTable;
extern "C" const fidl_type_t fuchsia_device_manager_CoordinatorBindDeviceResponseTable;
extern "C" const fidl_type_t fuchsia_device_manager_CoordinatorGetTopologicalPathResponseTable;
extern "C" const fidl_type_t fuchsia_device_manager_CoordinatorLoadFirmwareRequestTable;
extern "C" const fidl_type_t fuchsia_device_manager_CoordinatorLoadFirmwareResponseTable;
extern "C" const fidl_type_t fuchsia_device_manager_CoordinatorGetMetadataRequestTable;
extern "C" const fidl_type_t fuchsia_device_manager_CoordinatorGetMetadataResponseTable;
extern "C" const fidl_type_t fuchsia_device_manager_CoordinatorGetMetadataSizeRequestTable;
extern "C" const fidl_type_t fuchsia_device_manager_CoordinatorGetMetadataSizeResponseTable;
extern "C" const fidl_type_t fuchsia_device_manager_CoordinatorAddMetadataRequestTable;
extern "C" const fidl_type_t fuchsia_device_manager_CoordinatorAddMetadataResponseTable;
extern "C" const fidl_type_t fuchsia_device_manager_CoordinatorPublishMetadataRequestTable;
extern "C" const fidl_type_t fuchsia_device_manager_CoordinatorPublishMetadataResponseTable;
extern "C" const fidl_type_t fuchsia_device_manager_CoordinatorAddCompositeDeviceRequestTable;
extern "C" const fidl_type_t fuchsia_device_manager_CoordinatorAddCompositeDeviceResponseTable;
extern "C" const fidl_type_t fuchsia_device_manager_CoordinatorDirectoryWatchRequestTable;
extern "C" const fidl_type_t fuchsia_device_manager_CoordinatorDirectoryWatchResponseTable;
extern "C" const fidl_type_t 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;
    Coordinator_AddDevice_Result result;

    static constexpr const fidl_type_t* Type = &fuchsia_device_manager_CoordinatorAddDeviceResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 32;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  struct AddDeviceRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::zx::channel rpc;
    ::fidl::VectorView<uint64_t> props;
    ::fidl::StringView name;
    uint32_t protocol_id;
    ::fidl::StringView driver_path;
    ::fidl::StringView args;
    AddDeviceConfig device_add_config;
    ::zx::channel client_remote;

    static constexpr const fidl_type_t* Type = &fuchsia_device_manager_CoordinatorAddDeviceRequestTable;
    static constexpr uint32_t MaxNumHandles = 2;
    static constexpr uint32_t PrimarySize = 104;
    static constexpr uint32_t MaxOutOfLine = 4128;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kRequest;
    using ResponseType = AddDeviceResponse;
  };

  struct AddDeviceInvisibleResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    Coordinator_AddDeviceInvisible_Result result;

    static constexpr const fidl_type_t* Type = &fuchsia_device_manager_CoordinatorAddDeviceInvisibleResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 32;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  struct AddDeviceInvisibleRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::zx::channel rpc;
    ::fidl::VectorView<uint64_t> props;
    ::fidl::StringView name;
    uint32_t protocol_id;
    ::fidl::StringView driver_path;
    ::fidl::StringView args;
    ::zx::channel client_remote;

    static constexpr const fidl_type_t* Type = &fuchsia_device_manager_CoordinatorAddDeviceInvisibleRequestTable;
    static constexpr uint32_t MaxNumHandles = 2;
    static constexpr uint32_t PrimarySize = 104;
    static constexpr uint32_t MaxOutOfLine = 4128;
    static constexpr bool HasFlexibleEnvelope = 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 = &fuchsia_device_manager_CoordinatorScheduleRemoveRequestTable;
    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 ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kRequest;
  };

  using ScheduleUnbindChildrenRequest = ::fidl::AnyZeroArgMessage;

  struct UnbindDoneResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    Coordinator_UnbindDone_Result result;

    static constexpr const fidl_type_t* Type = &fuchsia_device_manager_CoordinatorUnbindDoneResponseTable;
    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 ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  using UnbindDoneRequest = ::fidl::AnyZeroArgMessage;

  struct RemoveDoneResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    Coordinator_RemoveDone_Result result;

    static constexpr const fidl_type_t* Type = &fuchsia_device_manager_CoordinatorRemoveDoneResponseTable;
    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 ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  using RemoveDoneRequest = ::fidl::AnyZeroArgMessage;

  struct MakeVisibleResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    Coordinator_MakeVisible_Result result;

    static constexpr const fidl_type_t* Type = &fuchsia_device_manager_CoordinatorMakeVisibleResponseTable;
    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 ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  using MakeVisibleRequest = ::fidl::AnyZeroArgMessage;

  struct BindDeviceResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    Coordinator_BindDevice_Result result;

    static constexpr const fidl_type_t* Type = &fuchsia_device_manager_CoordinatorBindDeviceResponseTable;
    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 ::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 = &fuchsia_device_manager_CoordinatorBindDeviceRequestTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 32;
    static constexpr uint32_t MaxOutOfLine = 1024;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kRequest;
    using ResponseType = BindDeviceResponse;
  };

  struct GetTopologicalPathResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    Coordinator_GetTopologicalPath_Result result;

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

  struct LoadFirmwareResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    Coordinator_LoadFirmware_Result result;

    static constexpr const fidl_type_t* Type = &fuchsia_device_manager_CoordinatorLoadFirmwareResponseTable;
    static constexpr uint32_t MaxNumHandles = 1;
    static constexpr uint32_t PrimarySize = 40;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    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 = &fuchsia_device_manager_CoordinatorLoadFirmwareRequestTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 32;
    static constexpr uint32_t MaxOutOfLine = 1024;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kRequest;
    using ResponseType = LoadFirmwareResponse;
  };

  struct GetMetadataResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    Coordinator_GetMetadata_Result result;

    static constexpr const fidl_type_t* Type = &fuchsia_device_manager_CoordinatorGetMetadataResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 40;
    static constexpr uint32_t MaxOutOfLine = 8192;
    static constexpr bool HasFlexibleEnvelope = false;
    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 = &fuchsia_device_manager_CoordinatorGetMetadataRequestTable;
    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 ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kRequest;
    using ResponseType = GetMetadataResponse;
  };

  struct GetMetadataSizeResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    Coordinator_GetMetadataSize_Result result;

    static constexpr const fidl_type_t* Type = &fuchsia_device_manager_CoordinatorGetMetadataSizeResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 32;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    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 = &fuchsia_device_manager_CoordinatorGetMetadataSizeRequestTable;
    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 ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kRequest;
    using ResponseType = GetMetadataSizeResponse;
  };

  struct AddMetadataResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    Coordinator_AddMetadata_Result result;

    static constexpr const fidl_type_t* Type = &fuchsia_device_manager_CoordinatorAddMetadataResponseTable;
    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 ::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 = &fuchsia_device_manager_CoordinatorAddMetadataRequestTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 40;
    static constexpr uint32_t MaxOutOfLine = 8192;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kRequest;
    using ResponseType = AddMetadataResponse;
  };

  struct PublishMetadataResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    Coordinator_PublishMetadata_Result result;

    static constexpr const fidl_type_t* Type = &fuchsia_device_manager_CoordinatorPublishMetadataResponseTable;
    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 ::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 = &fuchsia_device_manager_CoordinatorPublishMetadataRequestTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 56;
    static constexpr uint32_t MaxOutOfLine = 9216;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kRequest;
    using ResponseType = PublishMetadataResponse;
  };

  struct AddCompositeDeviceResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    Coordinator_AddCompositeDevice_Result result;

    static constexpr const fidl_type_t* Type = &fuchsia_device_manager_CoordinatorAddCompositeDeviceResponseTable;
    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 ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  struct AddCompositeDeviceRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::fidl::StringView name;
    ::fidl::VectorView<uint64_t> props;
    ::fidl::VectorView<DeviceComponent> components;
    uint32_t coresident_device_index;

    static constexpr const fidl_type_t* Type = &fuchsia_device_manager_CoordinatorAddCompositeDeviceRequestTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 72;
    static constexpr uint32_t MaxOutOfLine = 68704;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kRequest;
    using ResponseType = AddCompositeDeviceResponse;
  };

  struct DirectoryWatchResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    Coordinator_DirectoryWatch_Result result;

    static constexpr const fidl_type_t* Type = &fuchsia_device_manager_CoordinatorDirectoryWatchResponseTable;
    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 ::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 = &fuchsia_device_manager_CoordinatorDirectoryWatchRequestTable;
    static constexpr uint32_t MaxNumHandles = 1;
    static constexpr uint32_t PrimarySize = 32;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kRequest;
    using ResponseType = DirectoryWatchResponse;
  };

  struct RunCompatibilityTestsResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    Coordinator_RunCompatibilityTests_Result result;

    static constexpr const fidl_type_t* Type = &fuchsia_device_manager_CoordinatorRunCompatibilityTestsResponseTable;
    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 ::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 = nullptr;
    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 ::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 rpc, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, AddDeviceConfig device_add_config, ::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 rpc, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, ::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 UnbindDone_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      UnbindDone_Impl(zx::unowned_channel _client_end);
      ~UnbindDone_Impl() = default;
      UnbindDone_Impl(UnbindDone_Impl&& other) = default;
      UnbindDone_Impl& operator=(UnbindDone_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 RemoveDone_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      RemoveDone_Impl(zx::unowned_channel _client_end);
      ~RemoveDone_Impl() = default;
      RemoveDone_Impl(RemoveDone_Impl&& other) = default;
      RemoveDone_Impl& operator=(RemoveDone_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 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, ::fidl::VectorView<uint64_t> props, ::fidl::VectorView<DeviceComponent> components, uint32_t coresident_device_index);
      ~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 UnbindDone = UnbindDone_Impl<UnbindDoneResponse>;
    using RemoveDone = RemoveDone_Impl<RemoveDoneResponse>;
    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 rpc, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, AddDeviceConfig device_add_config, ::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 rpc, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, ::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 UnbindDone_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      UnbindDone_Impl(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
      ~UnbindDone_Impl() = default;
      UnbindDone_Impl(UnbindDone_Impl&& other) = default;
      UnbindDone_Impl& operator=(UnbindDone_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 RemoveDone_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      RemoveDone_Impl(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
      ~RemoveDone_Impl() = default;
      RemoveDone_Impl(RemoveDone_Impl&& other) = default;
      RemoveDone_Impl& operator=(RemoveDone_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 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, ::fidl::VectorView<uint64_t> props, ::fidl::VectorView<DeviceComponent> components, uint32_t coresident_device_index, ::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 UnbindDone = UnbindDone_Impl<UnbindDoneResponse>;
    using RemoveDone = RemoveDone_Impl<RemoveDoneResponse>;
    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 32 bytes of response buffer on the stack. Request is heap-allocated.
    ResultOf::AddDevice AddDevice(::zx::channel rpc, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, AddDeviceConfig device_add_config, ::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 rpc, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, AddDeviceConfig device_add_config, ::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 32 bytes of response buffer on the stack. Request is heap-allocated.
    ResultOf::AddDeviceInvisible AddDeviceInvisible(::zx::channel rpc, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, ::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 rpc, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, ::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();


    // Sent as the response to |Unbind|.
    // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::UnbindDone UnbindDone();

    // Sent as the response to |Unbind|.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::UnbindDone UnbindDone(::fidl::BytePart _response_buffer);

    // Sent as the response to |CompleteRemoval|.
    // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::RemoveDone RemoveDone();

    // Sent as the response to |CompleteRemoval|.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::RemoveDone RemoveDone(::fidl::BytePart _response_buffer);

    // Mark this device as visible.
    // Allocates 40 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 24 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 40 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 56 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 24 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 24 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 24 bytes of response buffer on the stack. Request is heap-allocated.
    ResultOf::AddCompositeDevice AddCompositeDevice(::fidl::StringView name, ::fidl::VectorView<uint64_t> props, ::fidl::VectorView<DeviceComponent> components, uint32_t coresident_device_index);

    // 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, ::fidl::VectorView<uint64_t> props, ::fidl::VectorView<DeviceComponent> components, uint32_t coresident_device_index, ::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 56 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 48 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 32 bytes of response buffer on the stack. Request is heap-allocated.
    static ResultOf::AddDevice AddDevice(zx::unowned_channel _client_end, ::zx::channel rpc, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, AddDeviceConfig device_add_config, ::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 rpc, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, AddDeviceConfig device_add_config, ::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 32 bytes of response buffer on the stack. Request is heap-allocated.
    static ResultOf::AddDeviceInvisible AddDeviceInvisible(zx::unowned_channel _client_end, ::zx::channel rpc, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, ::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 rpc, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, ::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);


    // Sent as the response to |Unbind|.
    // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::UnbindDone UnbindDone(zx::unowned_channel _client_end);

    // Sent as the response to |Unbind|.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::UnbindDone UnbindDone(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);

    // Sent as the response to |CompleteRemoval|.
    // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::RemoveDone RemoveDone(zx::unowned_channel _client_end);

    // Sent as the response to |CompleteRemoval|.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::RemoveDone RemoveDone(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);

    // Mark this device as visible.
    // Allocates 40 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 24 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 40 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 56 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 24 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 24 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 24 bytes of response buffer on the stack. Request is heap-allocated.
    static ResultOf::AddCompositeDevice AddCompositeDevice(zx::unowned_channel _client_end, ::fidl::StringView name, ::fidl::VectorView<uint64_t> props, ::fidl::VectorView<DeviceComponent> components, uint32_t coresident_device_index);

    // 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, ::fidl::VectorView<uint64_t> props, ::fidl::VectorView<DeviceComponent> components, uint32_t coresident_device_index, ::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 56 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 48 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::RunCompatibilityTests RunCompatibilityTests(zx::unowned_channel _client_end, int64_t hook_wait_time);

    // 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);

    // Sent as the response to |Unbind|.
    static ::fidl::DecodeResult<UnbindDoneResponse> UnbindDone(zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);

    // Sent as the response to |CompleteRemoval|.
    static ::fidl::DecodeResult<RemoveDoneResponse> RemoveDone(zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);

    // 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(Coordinator_AddDevice_Result result);
      void ReplySuccess(uint64_t local_device_id);
      void ReplyError(int32_t error);
      void Reply(::fidl::BytePart _buffer, 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 rpc, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, AddDeviceConfig device_add_config, ::zx::channel client_remote, AddDeviceCompleter::Sync _completer) = 0;

    class AddDeviceInvisibleCompleterBase : public _Base {
     public:
      void Reply(Coordinator_AddDeviceInvisible_Result result);
      void ReplySuccess(uint64_t local_device_id);
      void ReplyError(int32_t error);
      void Reply(::fidl::BytePart _buffer, 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 rpc, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, ::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 UnbindDoneCompleterBase : public _Base {
     public:
      void Reply(Coordinator_UnbindDone_Result result);
      void ReplySuccess();
      void ReplyError(int32_t error);
      void Reply(::fidl::BytePart _buffer, Coordinator_UnbindDone_Result result);
      void ReplySuccess(::fidl::BytePart _buffer);
      void Reply(::fidl::DecodedMessage<UnbindDoneResponse> params);

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

    using UnbindDoneCompleter = ::fidl::Completer<UnbindDoneCompleterBase>;

    virtual void UnbindDone(UnbindDoneCompleter::Sync _completer) = 0;

    class RemoveDoneCompleterBase : public _Base {
     public:
      void Reply(Coordinator_RemoveDone_Result result);
      void ReplySuccess();
      void ReplyError(int32_t error);
      void Reply(::fidl::BytePart _buffer, Coordinator_RemoveDone_Result result);
      void ReplySuccess(::fidl::BytePart _buffer);
      void Reply(::fidl::DecodedMessage<RemoveDoneResponse> params);

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

    using RemoveDoneCompleter = ::fidl::Completer<RemoveDoneCompleterBase>;

    virtual void RemoveDone(RemoveDoneCompleter::Sync _completer) = 0;

    class MakeVisibleCompleterBase : public _Base {
     public:
      void Reply(Coordinator_MakeVisible_Result result);
      void ReplySuccess();
      void ReplyError(int32_t error);
      void Reply(::fidl::BytePart _buffer, 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(Coordinator_BindDevice_Result result);
      void ReplySuccess();
      void ReplyError(int32_t error);
      void Reply(::fidl::BytePart _buffer, 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(Coordinator_GetTopologicalPath_Result result);
      void ReplySuccess(::fidl::StringView path);
      void ReplyError(int32_t error);
      void Reply(::fidl::BytePart _buffer, 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(Coordinator_LoadFirmware_Result result);
      void ReplySuccess(::zx::vmo vmo, uint64_t size);
      void ReplyError(int32_t error);
      void Reply(::fidl::BytePart _buffer, 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(Coordinator_GetMetadata_Result result);
      void ReplySuccess(::fidl::VectorView<uint8_t> data);
      void ReplyError(int32_t error);
      void Reply(::fidl::BytePart _buffer, 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(Coordinator_GetMetadataSize_Result result);
      void ReplySuccess(uint64_t size);
      void ReplyError(int32_t error);
      void Reply(::fidl::BytePart _buffer, 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(Coordinator_AddMetadata_Result result);
      void ReplySuccess();
      void ReplyError(int32_t error);
      void Reply(::fidl::BytePart _buffer, 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(Coordinator_PublishMetadata_Result result);
      void ReplySuccess();
      void ReplyError(int32_t error);
      void Reply(::fidl::BytePart _buffer, 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(Coordinator_AddCompositeDevice_Result result);
      void ReplySuccess();
      void ReplyError(int32_t error);
      void Reply(::fidl::BytePart _buffer, 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, ::fidl::VectorView<uint64_t> props, ::fidl::VectorView<DeviceComponent> components, uint32_t coresident_device_index, AddCompositeDeviceCompleter::Sync _completer) = 0;

    class DirectoryWatchCompleterBase : public _Base {
     public:
      void Reply(Coordinator_DirectoryWatch_Result result);
      void ReplySuccess();
      void ReplyError(int32_t error);
      void Reply(::fidl::BytePart _buffer, 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(Coordinator_RunCompatibilityTests_Result result);
      void ReplySuccess();
      void ReplyError(int32_t error);
      void Reply(::fidl::BytePart _buffer, 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);
  }

};

}  // 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, rpc) == 16);
static_assert(offsetof(::llcpp::fuchsia::device::manager::DevhostController::CreateDeviceStubRequest, protocol_id) == 20);
static_assert(offsetof(::llcpp::fuchsia::device::manager::DevhostController::CreateDeviceStubRequest, local_device_id) == 24);

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, rpc) == 16);
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, rpc) == 16);
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::Coordinator_UnbindDone_Response> : public std::true_type {};
static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::manager::Coordinator_UnbindDone_Response>);
static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_UnbindDone_Response, __reserved) == 0);
static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator_UnbindDone_Response) == ::llcpp::fuchsia::device::manager::Coordinator_UnbindDone_Response::PrimarySize);

template <>
struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator_UnbindDone_Result> : public std::true_type {};
static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::manager::Coordinator_UnbindDone_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_RemoveDone_Response> : public std::true_type {};
static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::manager::Coordinator_RemoveDone_Response>);
static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_RemoveDone_Response, __reserved) == 0);
static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator_RemoveDone_Response) == ::llcpp::fuchsia::device::manager::Coordinator_RemoveDone_Response::PrimarySize);

template <>
struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator_RemoveDone_Result> : public std::true_type {};
static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::manager::Coordinator_RemoveDone_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::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::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::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, rpc) == 16);
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, client_remote) == 100);

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, rpc) == 16);
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, client_remote) == 96);

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::UnbindDoneResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::device::manager::Coordinator::UnbindDoneResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator::UnbindDoneResponse)
    == ::llcpp::fuchsia::device::manager::Coordinator::UnbindDoneResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::UnbindDoneResponse, result) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator::RemoveDoneResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::device::manager::Coordinator::RemoveDoneResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator::RemoveDoneResponse)
    == ::llcpp::fuchsia::device::manager::Coordinator::RemoveDoneResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::RemoveDoneResponse, result) == 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, props) == 32);
static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::AddCompositeDeviceRequest, components) == 48);
static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::AddCompositeDeviceRequest, coresident_device_index) == 64);

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