zircon/system/fidl/fuchsia-hardware-input/gen/llcpp/include/fuchsia/hardware/input/llcpp/fidl.h

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

#pragma once

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

namespace llcpp {

namespace fuchsia {
namespace hardware {
namespace input {

enum class ReportType : uint8_t {
  INPUT = 1u,
  OUTPUT = 2u,
  FEATURE = 3u,
};


struct DeviceIds;
enum class BootProtocol : uint32_t {
  NONE = 0u,
  KBD = 1u,
  MOUSE = 2u,
};


class Device;

constexpr uint16_t MAX_REPORT_LEN = 8192u;

constexpr uint16_t MAX_REPORT_IDS = 256u;

constexpr uint16_t MAX_REPORT_DATA = 8192u;

constexpr uint16_t MAX_DESC_LEN = 8192u;

extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceIdsTable;

// DeviceIds lets a clients determine the vendor and product id for a device.
// If the device is real HID device, then the id information
// will come from the device itself. Mock HID devices may assign the
// ids in the driver. If the mock HID driver does not assign ids, zeros
// will be used instead.
struct DeviceIds {
  static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_input_DeviceIdsTable;
  static constexpr uint32_t MaxNumHandles = 0;
  static constexpr uint32_t PrimarySize = 12;
  [[maybe_unused]]
  static constexpr uint32_t MaxOutOfLine = 0;
  static constexpr bool HasPointer = false;

  uint32_t vendor_id = {};

  uint32_t product_id = {};

  uint32_t version = {};
};

extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetBootProtocolRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetBootProtocolResponseTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetDeviceIdsRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetDeviceIdsResponseTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetReportDescSizeRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetReportDescSizeResponseTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetReportDescRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetReportDescResponseTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetNumReportsRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetNumReportsResponseTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetReportIdsRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetReportIdsResponseTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetReportSizeRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetReportSizeResponseTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetMaxInputReportSizeRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetMaxInputReportSizeResponseTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetReportsRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetReportsResponseTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetReportsEventRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetReportsEventResponseTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetReportRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetReportResponseTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceSetReportRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceSetReportResponseTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceSetTraceIdRequestTable;
extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceSetTraceIdResponseTable;

class Device final {
  Device() = delete;
 public:

  struct GetBootProtocolResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::llcpp::fuchsia::hardware::input::BootProtocol protocol;

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

  struct GetDeviceIdsResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::llcpp::fuchsia::hardware::input::DeviceIds ids;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_input_DeviceGetDeviceIdsResponseTable;
    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 bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  using GetDeviceIdsRequest = ::fidl::AnyZeroArgMessage;

  struct GetReportDescSizeResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    uint16_t size;

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

  struct GetReportDescResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::fidl::VectorView<uint8_t> desc;

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

  struct GetNumReportsResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    uint16_t count;

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

  struct GetReportIdsResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::fidl::VectorView<uint8_t> ids;

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

  struct GetReportSizeResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t status;
    uint16_t size;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_input_DeviceGetReportSizeResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  struct GetReportSizeRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::llcpp::fuchsia::hardware::input::ReportType type;
    uint8_t id;

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

  struct GetMaxInputReportSizeResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    uint16_t size;

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

  struct GetReportsResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t status;
    ::fidl::VectorView<uint8_t> data;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_input_DeviceGetReportsResponseTable;
    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 bool HasPointer = true;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  using GetReportsRequest = ::fidl::AnyZeroArgMessage;

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

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

  struct GetReportResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t status;
    ::fidl::VectorView<uint8_t> report;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_input_DeviceGetReportResponseTable;
    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 bool HasPointer = true;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  struct GetReportRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::llcpp::fuchsia::hardware::input::ReportType type;
    uint8_t id;

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

  struct SetReportResponse final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    int32_t status;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_input_DeviceSetReportResponseTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 24;
    static constexpr uint32_t MaxOutOfLine = 0;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = false;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kResponse;
  };
  struct SetReportRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    ::llcpp::fuchsia::hardware::input::ReportType type;
    uint8_t id;
    ::fidl::VectorView<uint8_t> report;

    static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_input_DeviceSetReportRequestTable;
    static constexpr uint32_t MaxNumHandles = 0;
    static constexpr uint32_t PrimarySize = 40;
    static constexpr uint32_t MaxOutOfLine = 8192;
    static constexpr uint32_t AltPrimarySize = 40;
    static constexpr uint32_t AltMaxOutOfLine = 8192;
    static constexpr bool HasFlexibleEnvelope = false;
    static constexpr bool HasPointer = true;
    static constexpr bool ContainsUnion = false;
    static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
        ::fidl::internal::TransactionalMessageKind::kRequest;
    using ResponseType = SetReportResponse;
  };

  struct SetTraceIdRequest final {
    FIDL_ALIGNDECL
    fidl_message_header_t _hdr;
    uint32_t id;

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


  // Collection of return types of FIDL calls in this interface.
  class ResultOf final {
    ResultOf() = delete;
   private:
    template <typename ResponseType>
    class GetBootProtocol_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      GetBootProtocol_Impl(::zx::unowned_channel _client_end);
      ~GetBootProtocol_Impl() = default;
      GetBootProtocol_Impl(GetBootProtocol_Impl&& other) = default;
      GetBootProtocol_Impl& operator=(GetBootProtocol_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 GetDeviceIds_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      GetDeviceIds_Impl(::zx::unowned_channel _client_end);
      ~GetDeviceIds_Impl() = default;
      GetDeviceIds_Impl(GetDeviceIds_Impl&& other) = default;
      GetDeviceIds_Impl& operator=(GetDeviceIds_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 GetReportDescSize_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      GetReportDescSize_Impl(::zx::unowned_channel _client_end);
      ~GetReportDescSize_Impl() = default;
      GetReportDescSize_Impl(GetReportDescSize_Impl&& other) = default;
      GetReportDescSize_Impl& operator=(GetReportDescSize_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 GetReportDesc_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      GetReportDesc_Impl(::zx::unowned_channel _client_end);
      ~GetReportDesc_Impl() = default;
      GetReportDesc_Impl(GetReportDesc_Impl&& other) = default;
      GetReportDesc_Impl& operator=(GetReportDesc_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 GetNumReports_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      GetNumReports_Impl(::zx::unowned_channel _client_end);
      ~GetNumReports_Impl() = default;
      GetNumReports_Impl(GetNumReports_Impl&& other) = default;
      GetNumReports_Impl& operator=(GetNumReports_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 GetReportIds_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      GetReportIds_Impl(::zx::unowned_channel _client_end);
      ~GetReportIds_Impl() = default;
      GetReportIds_Impl(GetReportIds_Impl&& other) = default;
      GetReportIds_Impl& operator=(GetReportIds_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 GetReportSize_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      GetReportSize_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id);
      ~GetReportSize_Impl() = default;
      GetReportSize_Impl(GetReportSize_Impl&& other) = default;
      GetReportSize_Impl& operator=(GetReportSize_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 GetMaxInputReportSize_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      GetMaxInputReportSize_Impl(::zx::unowned_channel _client_end);
      ~GetMaxInputReportSize_Impl() = default;
      GetMaxInputReportSize_Impl(GetMaxInputReportSize_Impl&& other) = default;
      GetMaxInputReportSize_Impl& operator=(GetMaxInputReportSize_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 GetReports_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      GetReports_Impl(::zx::unowned_channel _client_end);
      ~GetReports_Impl() = default;
      GetReports_Impl(GetReports_Impl&& other) = default;
      GetReports_Impl& operator=(GetReports_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 GetReportsEvent_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      GetReportsEvent_Impl(::zx::unowned_channel _client_end);
      ~GetReportsEvent_Impl() = default;
      GetReportsEvent_Impl(GetReportsEvent_Impl&& other) = default;
      GetReportsEvent_Impl& operator=(GetReportsEvent_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 GetReport_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      GetReport_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id);
      ~GetReport_Impl() = default;
      GetReport_Impl(GetReport_Impl&& other) = default;
      GetReport_Impl& operator=(GetReport_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 SetReport_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
     public:
      SetReport_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id, ::fidl::VectorView<uint8_t> report);
      ~SetReport_Impl() = default;
      SetReport_Impl(SetReport_Impl&& other) = default;
      SetReport_Impl& operator=(SetReport_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 SetTraceId_Impl final : private ::fidl::internal::StatusAndError {
      using Super = ::fidl::internal::StatusAndError;
     public:
      SetTraceId_Impl(::zx::unowned_channel _client_end, uint32_t id);
      ~SetTraceId_Impl() = default;
      SetTraceId_Impl(SetTraceId_Impl&& other) = default;
      SetTraceId_Impl& operator=(SetTraceId_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
    };

   public:
    using GetBootProtocol = GetBootProtocol_Impl<GetBootProtocolResponse>;
    using GetDeviceIds = GetDeviceIds_Impl<GetDeviceIdsResponse>;
    using GetReportDescSize = GetReportDescSize_Impl<GetReportDescSizeResponse>;
    using GetReportDesc = GetReportDesc_Impl<GetReportDescResponse>;
    using GetNumReports = GetNumReports_Impl<GetNumReportsResponse>;
    using GetReportIds = GetReportIds_Impl<GetReportIdsResponse>;
    using GetReportSize = GetReportSize_Impl<GetReportSizeResponse>;
    using GetMaxInputReportSize = GetMaxInputReportSize_Impl<GetMaxInputReportSizeResponse>;
    using GetReports = GetReports_Impl<GetReportsResponse>;
    using GetReportsEvent = GetReportsEvent_Impl<GetReportsEventResponse>;
    using GetReport = GetReport_Impl<GetReportResponse>;
    using SetReport = SetReport_Impl<SetReportResponse>;
    using SetTraceId = SetTraceId_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 GetBootProtocol_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      GetBootProtocol_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
      ~GetBootProtocol_Impl() = default;
      GetBootProtocol_Impl(GetBootProtocol_Impl&& other) = default;
      GetBootProtocol_Impl& operator=(GetBootProtocol_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 GetDeviceIds_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      GetDeviceIds_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
      ~GetDeviceIds_Impl() = default;
      GetDeviceIds_Impl(GetDeviceIds_Impl&& other) = default;
      GetDeviceIds_Impl& operator=(GetDeviceIds_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 GetReportDescSize_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      GetReportDescSize_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
      ~GetReportDescSize_Impl() = default;
      GetReportDescSize_Impl(GetReportDescSize_Impl&& other) = default;
      GetReportDescSize_Impl& operator=(GetReportDescSize_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 GetReportDesc_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      GetReportDesc_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
      ~GetReportDesc_Impl() = default;
      GetReportDesc_Impl(GetReportDesc_Impl&& other) = default;
      GetReportDesc_Impl& operator=(GetReportDesc_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 GetNumReports_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      GetNumReports_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
      ~GetNumReports_Impl() = default;
      GetNumReports_Impl(GetNumReports_Impl&& other) = default;
      GetNumReports_Impl& operator=(GetNumReports_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 GetReportIds_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      GetReportIds_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
      ~GetReportIds_Impl() = default;
      GetReportIds_Impl(GetReportIds_Impl&& other) = default;
      GetReportIds_Impl& operator=(GetReportIds_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 GetReportSize_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      GetReportSize_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id, ::fidl::BytePart _response_buffer);
      ~GetReportSize_Impl() = default;
      GetReportSize_Impl(GetReportSize_Impl&& other) = default;
      GetReportSize_Impl& operator=(GetReportSize_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 GetMaxInputReportSize_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      GetMaxInputReportSize_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
      ~GetMaxInputReportSize_Impl() = default;
      GetMaxInputReportSize_Impl(GetMaxInputReportSize_Impl&& other) = default;
      GetMaxInputReportSize_Impl& operator=(GetMaxInputReportSize_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 GetReports_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      GetReports_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
      ~GetReports_Impl() = default;
      GetReports_Impl(GetReports_Impl&& other) = default;
      GetReports_Impl& operator=(GetReports_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 GetReportsEvent_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      GetReportsEvent_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
      ~GetReportsEvent_Impl() = default;
      GetReportsEvent_Impl(GetReportsEvent_Impl&& other) = default;
      GetReportsEvent_Impl& operator=(GetReportsEvent_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 GetReport_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      GetReport_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id, ::fidl::BytePart _response_buffer);
      ~GetReport_Impl() = default;
      GetReport_Impl(GetReport_Impl&& other) = default;
      GetReport_Impl& operator=(GetReport_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 SetReport_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
      using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
     public:
      SetReport_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id, ::fidl::VectorView<uint8_t> report, ::fidl::BytePart _response_buffer);
      ~SetReport_Impl() = default;
      SetReport_Impl(SetReport_Impl&& other) = default;
      SetReport_Impl& operator=(SetReport_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 SetTraceId_Impl final : private ::fidl::internal::StatusAndError {
      using Super = ::fidl::internal::StatusAndError;
     public:
      SetTraceId_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t id);
      ~SetTraceId_Impl() = default;
      SetTraceId_Impl(SetTraceId_Impl&& other) = default;
      SetTraceId_Impl& operator=(SetTraceId_Impl&& other) = default;
      using Super::status;
      using Super::error;
      using Super::ok;
    };

   public:
    using GetBootProtocol = GetBootProtocol_Impl<GetBootProtocolResponse>;
    using GetDeviceIds = GetDeviceIds_Impl<GetDeviceIdsResponse>;
    using GetReportDescSize = GetReportDescSize_Impl<GetReportDescSizeResponse>;
    using GetReportDesc = GetReportDesc_Impl<GetReportDescResponse>;
    using GetNumReports = GetNumReports_Impl<GetNumReportsResponse>;
    using GetReportIds = GetReportIds_Impl<GetReportIdsResponse>;
    using GetReportSize = GetReportSize_Impl<GetReportSizeResponse>;
    using GetMaxInputReportSize = GetMaxInputReportSize_Impl<GetMaxInputReportSizeResponse>;
    using GetReports = GetReports_Impl<GetReportsResponse>;
    using GetReportsEvent = GetReportsEvent_Impl<GetReportsEventResponse>;
    using GetReport = GetReport_Impl<GetReportResponse>;
    using SetReport = SetReport_Impl<SetReportResponse>;
    using SetTraceId = SetTraceId_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_; }

    // Get the HID boot interface protocol this device supports
    // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::GetBootProtocol GetBootProtocol();

    // Get the HID boot interface protocol this device supports
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::GetBootProtocol GetBootProtocol(::fidl::BytePart _response_buffer);

    // Get the Device's IDs. If this is a real HID device, the IDs will come from the device.
    // If it is a mock HID decice, the IDs will either be 0's or user defined.
    // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::GetDeviceIds GetDeviceIds();

    // Get the Device's IDs. If this is a real HID device, the IDs will come from the device.
    // If it is a mock HID decice, the IDs will either be 0's or user defined.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::GetDeviceIds GetDeviceIds(::fidl::BytePart _response_buffer);

    // Get the size of the report descriptor
    // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::GetReportDescSize GetReportDescSize();

    // Get the size of the report descriptor
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::GetReportDescSize GetReportDescSize(::fidl::BytePart _response_buffer);

    // Get the report descriptor
    // Allocates 16 bytes of request buffer on the stack. Response is heap-allocated.
    ResultOf::GetReportDesc GetReportDesc();

    // Get the report descriptor
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::GetReportDesc GetReportDesc(::fidl::BytePart _response_buffer);

    // Get the number of reports in the report descriptor
    // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::GetNumReports GetNumReports();

    // Get the number of reports in the report descriptor
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::GetNumReports GetNumReports(::fidl::BytePart _response_buffer);

    // Get the report ids that are used in the report descriptor
    // Allocates 304 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::GetReportIds GetReportIds();

    // Get the report ids that are used in the report descriptor
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::GetReportIds GetReportIds(::fidl::BytePart _response_buffer);

    // Get the size of a single report for the given (type, id) pair.
    // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::GetReportSize GetReportSize(::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id);

    // Get the size of a single report for the given (type, id) pair.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::GetReportSize GetReportSize(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id, ::fidl::BytePart _response_buffer);

    // Get the maximum size of a single input report.
    // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::GetMaxInputReportSize GetMaxInputReportSize();

    // Get the maximum size of a single input report.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::GetMaxInputReportSize GetMaxInputReportSize(::fidl::BytePart _response_buffer);

    // Receive up to MAX_REPORT_DATA bytes of reports that have been sent from a device.
    // This is the interface that is supposed to be used for continuous polling.
    // Multiple reports can be returned from this API at a time, it is up to the client
    // to do the parsing of the reports with the correct sizes and offset.
    // It is guaranteed that only whole reports will be sent.
    // If there are no reports, this will return ZX_ERR_SHOULD_WAIT, and the client can
    // wait on the event from |GetReportsEvent|.
    // Allocates 16 bytes of request buffer on the stack. Response is heap-allocated.
    ResultOf::GetReports GetReports();

    // Receive up to MAX_REPORT_DATA bytes of reports that have been sent from a device.
    // This is the interface that is supposed to be used for continuous polling.
    // Multiple reports can be returned from this API at a time, it is up to the client
    // to do the parsing of the reports with the correct sizes and offset.
    // It is guaranteed that only whole reports will be sent.
    // If there are no reports, this will return ZX_ERR_SHOULD_WAIT, and the client can
    // wait on the event from |GetReportsEvent|.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::GetReports GetReports(::fidl::BytePart _response_buffer);

    // Receive an event that will signal on `ZX_USER_SIGNAL_0` when there are reports in the
    // Device's report FIFO. This signal will be de-asserted when there are no
    // reports in the Device's report FIFO. This event can be re-used each time
    // the client wishes to know if there are reports in the FIFO.
    // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::GetReportsEvent GetReportsEvent();

    // Receive an event that will signal on `ZX_USER_SIGNAL_0` when there are reports in the
    // Device's report FIFO. This signal will be de-asserted when there are no
    // reports in the Device's report FIFO. This event can be re-used each time
    // the client wishes to know if there are reports in the FIFO.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::GetReportsEvent GetReportsEvent(::fidl::BytePart _response_buffer);

    // Get a single report of the given (type, id) pair.  This interface is not intended
    // to be used for continuous polling of the reports.
    // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
    ResultOf::GetReport GetReport(::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id);

    // Get a single report of the given (type, id) pair.  This interface is not intended
    // to be used for continuous polling of the reports.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::GetReport GetReport(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id, ::fidl::BytePart _response_buffer);

    // Set a single report of the given (type, id) pair.
    // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
    ResultOf::SetReport SetReport(::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id, ::fidl::VectorView<uint8_t> report);

    // Set a single report of the given (type, id) pair.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::SetReport SetReport(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id, ::fidl::VectorView<uint8_t> report, ::fidl::BytePart _response_buffer);

    // Set the trace ID that is used for HID report flow events.
    // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
    ResultOf::SetTraceId SetTraceId(uint32_t id);

    // Set the trace ID that is used for HID report flow events.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    UnownedResultOf::SetTraceId SetTraceId(::fidl::BytePart _request_buffer, uint32_t id);

   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:

    // Get the HID boot interface protocol this device supports
    // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::GetBootProtocol GetBootProtocol(::zx::unowned_channel _client_end);

    // Get the HID boot interface protocol this device supports
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::GetBootProtocol GetBootProtocol(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);

    // Get the Device's IDs. If this is a real HID device, the IDs will come from the device.
    // If it is a mock HID decice, the IDs will either be 0's or user defined.
    // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::GetDeviceIds GetDeviceIds(::zx::unowned_channel _client_end);

    // Get the Device's IDs. If this is a real HID device, the IDs will come from the device.
    // If it is a mock HID decice, the IDs will either be 0's or user defined.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::GetDeviceIds GetDeviceIds(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);

    // Get the size of the report descriptor
    // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::GetReportDescSize GetReportDescSize(::zx::unowned_channel _client_end);

    // Get the size of the report descriptor
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::GetReportDescSize GetReportDescSize(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);

    // Get the report descriptor
    // Allocates 16 bytes of request buffer on the stack. Response is heap-allocated.
    static ResultOf::GetReportDesc GetReportDesc(::zx::unowned_channel _client_end);

    // Get the report descriptor
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::GetReportDesc GetReportDesc(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);

    // Get the number of reports in the report descriptor
    // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::GetNumReports GetNumReports(::zx::unowned_channel _client_end);

    // Get the number of reports in the report descriptor
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::GetNumReports GetNumReports(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);

    // Get the report ids that are used in the report descriptor
    // Allocates 304 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::GetReportIds GetReportIds(::zx::unowned_channel _client_end);

    // Get the report ids that are used in the report descriptor
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::GetReportIds GetReportIds(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);

    // Get the size of a single report for the given (type, id) pair.
    // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::GetReportSize GetReportSize(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id);

    // Get the size of a single report for the given (type, id) pair.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::GetReportSize GetReportSize(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id, ::fidl::BytePart _response_buffer);

    // Get the maximum size of a single input report.
    // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::GetMaxInputReportSize GetMaxInputReportSize(::zx::unowned_channel _client_end);

    // Get the maximum size of a single input report.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::GetMaxInputReportSize GetMaxInputReportSize(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);

    // Receive up to MAX_REPORT_DATA bytes of reports that have been sent from a device.
    // This is the interface that is supposed to be used for continuous polling.
    // Multiple reports can be returned from this API at a time, it is up to the client
    // to do the parsing of the reports with the correct sizes and offset.
    // It is guaranteed that only whole reports will be sent.
    // If there are no reports, this will return ZX_ERR_SHOULD_WAIT, and the client can
    // wait on the event from |GetReportsEvent|.
    // Allocates 16 bytes of request buffer on the stack. Response is heap-allocated.
    static ResultOf::GetReports GetReports(::zx::unowned_channel _client_end);

    // Receive up to MAX_REPORT_DATA bytes of reports that have been sent from a device.
    // This is the interface that is supposed to be used for continuous polling.
    // Multiple reports can be returned from this API at a time, it is up to the client
    // to do the parsing of the reports with the correct sizes and offset.
    // It is guaranteed that only whole reports will be sent.
    // If there are no reports, this will return ZX_ERR_SHOULD_WAIT, and the client can
    // wait on the event from |GetReportsEvent|.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::GetReports GetReports(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);

    // Receive an event that will signal on `ZX_USER_SIGNAL_0` when there are reports in the
    // Device's report FIFO. This signal will be de-asserted when there are no
    // reports in the Device's report FIFO. This event can be re-used each time
    // the client wishes to know if there are reports in the FIFO.
    // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::GetReportsEvent GetReportsEvent(::zx::unowned_channel _client_end);

    // Receive an event that will signal on `ZX_USER_SIGNAL_0` when there are reports in the
    // Device's report FIFO. This signal will be de-asserted when there are no
    // reports in the Device's report FIFO. This event can be re-used each time
    // the client wishes to know if there are reports in the FIFO.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::GetReportsEvent GetReportsEvent(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);

    // Get a single report of the given (type, id) pair.  This interface is not intended
    // to be used for continuous polling of the reports.
    // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
    static ResultOf::GetReport GetReport(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id);

    // Get a single report of the given (type, id) pair.  This interface is not intended
    // to be used for continuous polling of the reports.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::GetReport GetReport(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id, ::fidl::BytePart _response_buffer);

    // Set a single report of the given (type, id) pair.
    // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
    static ResultOf::SetReport SetReport(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id, ::fidl::VectorView<uint8_t> report);

    // Set a single report of the given (type, id) pair.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::SetReport SetReport(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id, ::fidl::VectorView<uint8_t> report, ::fidl::BytePart _response_buffer);

    // Set the trace ID that is used for HID report flow events.
    // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
    static ResultOf::SetTraceId SetTraceId(::zx::unowned_channel _client_end, uint32_t id);

    // Set the trace ID that is used for HID report flow events.
    // Caller provides the backing storage for FIDL message via request and response buffers.
    static UnownedResultOf::SetTraceId SetTraceId(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t id);

  };

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

    // Get the HID boot interface protocol this device supports
    static ::fidl::DecodeResult<GetBootProtocolResponse> GetBootProtocol(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);

    // Get the Device's IDs. If this is a real HID device, the IDs will come from the device.
    // If it is a mock HID decice, the IDs will either be 0's or user defined.
    static ::fidl::DecodeResult<GetDeviceIdsResponse> GetDeviceIds(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);

    // Get the size of the report descriptor
    static ::fidl::DecodeResult<GetReportDescSizeResponse> GetReportDescSize(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);

    // Get the report descriptor
    static ::fidl::DecodeResult<GetReportDescResponse> GetReportDesc(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);

    // Get the number of reports in the report descriptor
    static ::fidl::DecodeResult<GetNumReportsResponse> GetNumReports(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);

    // Get the report ids that are used in the report descriptor
    static ::fidl::DecodeResult<GetReportIdsResponse> GetReportIds(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);

    // Get the size of a single report for the given (type, id) pair.
    static ::fidl::DecodeResult<GetReportSizeResponse> GetReportSize(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetReportSizeRequest> params, ::fidl::BytePart response_buffer);

    // Get the maximum size of a single input report.
    static ::fidl::DecodeResult<GetMaxInputReportSizeResponse> GetMaxInputReportSize(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);

    // Receive up to MAX_REPORT_DATA bytes of reports that have been sent from a device.
    // This is the interface that is supposed to be used for continuous polling.
    // Multiple reports can be returned from this API at a time, it is up to the client
    // to do the parsing of the reports with the correct sizes and offset.
    // It is guaranteed that only whole reports will be sent.
    // If there are no reports, this will return ZX_ERR_SHOULD_WAIT, and the client can
    // wait on the event from |GetReportsEvent|.
    static ::fidl::DecodeResult<GetReportsResponse> GetReports(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);

    // Receive an event that will signal on `ZX_USER_SIGNAL_0` when there are reports in the
    // Device's report FIFO. This signal will be de-asserted when there are no
    // reports in the Device's report FIFO. This event can be re-used each time
    // the client wishes to know if there are reports in the FIFO.
    static ::fidl::DecodeResult<GetReportsEventResponse> GetReportsEvent(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);

    // Get a single report of the given (type, id) pair.  This interface is not intended
    // to be used for continuous polling of the reports.
    static ::fidl::DecodeResult<GetReportResponse> GetReport(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetReportRequest> params, ::fidl::BytePart response_buffer);

    // Set a single report of the given (type, id) pair.
    static ::fidl::DecodeResult<SetReportResponse> SetReport(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetReportRequest> params, ::fidl::BytePart response_buffer);

    // Set the trace ID that is used for HID report flow events.
    static ::fidl::internal::StatusAndError SetTraceId(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetTraceIdRequest> params);

  };

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

    class GetBootProtocolCompleterBase : public _Base {
     public:
      void Reply(::llcpp::fuchsia::hardware::input::BootProtocol protocol);
      void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::input::BootProtocol protocol);
      void Reply(::fidl::DecodedMessage<GetBootProtocolResponse> params);

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

    using GetBootProtocolCompleter = ::fidl::Completer<GetBootProtocolCompleterBase>;

    virtual void GetBootProtocol(GetBootProtocolCompleter::Sync _completer) = 0;

    class GetDeviceIdsCompleterBase : public _Base {
     public:
      void Reply(::llcpp::fuchsia::hardware::input::DeviceIds ids);
      void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::input::DeviceIds ids);
      void Reply(::fidl::DecodedMessage<GetDeviceIdsResponse> params);

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

    using GetDeviceIdsCompleter = ::fidl::Completer<GetDeviceIdsCompleterBase>;

    virtual void GetDeviceIds(GetDeviceIdsCompleter::Sync _completer) = 0;

    class GetReportDescSizeCompleterBase : public _Base {
     public:
      void Reply(uint16_t size);
      void Reply(::fidl::BytePart _buffer, uint16_t size);
      void Reply(::fidl::DecodedMessage<GetReportDescSizeResponse> params);

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

    using GetReportDescSizeCompleter = ::fidl::Completer<GetReportDescSizeCompleterBase>;

    virtual void GetReportDescSize(GetReportDescSizeCompleter::Sync _completer) = 0;

    class GetReportDescCompleterBase : public _Base {
     public:
      void Reply(::fidl::VectorView<uint8_t> desc);
      void Reply(::fidl::BytePart _buffer, ::fidl::VectorView<uint8_t> desc);
      void Reply(::fidl::DecodedMessage<GetReportDescResponse> params);

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

    using GetReportDescCompleter = ::fidl::Completer<GetReportDescCompleterBase>;

    virtual void GetReportDesc(GetReportDescCompleter::Sync _completer) = 0;

    class GetNumReportsCompleterBase : public _Base {
     public:
      void Reply(uint16_t count);
      void Reply(::fidl::BytePart _buffer, uint16_t count);
      void Reply(::fidl::DecodedMessage<GetNumReportsResponse> params);

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

    using GetNumReportsCompleter = ::fidl::Completer<GetNumReportsCompleterBase>;

    virtual void GetNumReports(GetNumReportsCompleter::Sync _completer) = 0;

    class GetReportIdsCompleterBase : public _Base {
     public:
      void Reply(::fidl::VectorView<uint8_t> ids);
      void Reply(::fidl::BytePart _buffer, ::fidl::VectorView<uint8_t> ids);
      void Reply(::fidl::DecodedMessage<GetReportIdsResponse> params);

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

    using GetReportIdsCompleter = ::fidl::Completer<GetReportIdsCompleterBase>;

    virtual void GetReportIds(GetReportIdsCompleter::Sync _completer) = 0;

    class GetReportSizeCompleterBase : public _Base {
     public:
      void Reply(int32_t status, uint16_t size);
      void Reply(::fidl::BytePart _buffer, int32_t status, uint16_t size);
      void Reply(::fidl::DecodedMessage<GetReportSizeResponse> params);

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

    using GetReportSizeCompleter = ::fidl::Completer<GetReportSizeCompleterBase>;

    virtual void GetReportSize(::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id, GetReportSizeCompleter::Sync _completer) = 0;

    class GetMaxInputReportSizeCompleterBase : public _Base {
     public:
      void Reply(uint16_t size);
      void Reply(::fidl::BytePart _buffer, uint16_t size);
      void Reply(::fidl::DecodedMessage<GetMaxInputReportSizeResponse> params);

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

    using GetMaxInputReportSizeCompleter = ::fidl::Completer<GetMaxInputReportSizeCompleterBase>;

    virtual void GetMaxInputReportSize(GetMaxInputReportSizeCompleter::Sync _completer) = 0;

    class GetReportsCompleterBase : public _Base {
     public:
      void Reply(int32_t status, ::fidl::VectorView<uint8_t> data);
      void Reply(::fidl::BytePart _buffer, int32_t status, ::fidl::VectorView<uint8_t> data);
      void Reply(::fidl::DecodedMessage<GetReportsResponse> params);

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

    using GetReportsCompleter = ::fidl::Completer<GetReportsCompleterBase>;

    virtual void GetReports(GetReportsCompleter::Sync _completer) = 0;

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

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

    using GetReportsEventCompleter = ::fidl::Completer<GetReportsEventCompleterBase>;

    virtual void GetReportsEvent(GetReportsEventCompleter::Sync _completer) = 0;

    class GetReportCompleterBase : public _Base {
     public:
      void Reply(int32_t status, ::fidl::VectorView<uint8_t> report);
      void Reply(::fidl::BytePart _buffer, int32_t status, ::fidl::VectorView<uint8_t> report);
      void Reply(::fidl::DecodedMessage<GetReportResponse> params);

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

    using GetReportCompleter = ::fidl::Completer<GetReportCompleterBase>;

    virtual void GetReport(::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id, GetReportCompleter::Sync _completer) = 0;

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

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

    using SetReportCompleter = ::fidl::Completer<SetReportCompleterBase>;

    virtual void SetReport(::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id, ::fidl::VectorView<uint8_t> report, SetReportCompleter::Sync _completer) = 0;

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

    virtual void SetTraceId(uint32_t id, SetTraceIdCompleter::Sync _completer) = 0;

  };

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

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

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


  // Helper functions to fill in the transaction header in a |DecodedMessage<TransactionalMessage>|.
  class SetTransactionHeaderFor final {
    SetTransactionHeaderFor() = delete;
   public:
    static void GetBootProtocolRequest(const ::fidl::DecodedMessage<Device::GetBootProtocolRequest>& _msg);
    static void GetBootProtocolResponse(const ::fidl::DecodedMessage<Device::GetBootProtocolResponse>& _msg);
    static void GetDeviceIdsRequest(const ::fidl::DecodedMessage<Device::GetDeviceIdsRequest>& _msg);
    static void GetDeviceIdsResponse(const ::fidl::DecodedMessage<Device::GetDeviceIdsResponse>& _msg);
    static void GetReportDescSizeRequest(const ::fidl::DecodedMessage<Device::GetReportDescSizeRequest>& _msg);
    static void GetReportDescSizeResponse(const ::fidl::DecodedMessage<Device::GetReportDescSizeResponse>& _msg);
    static void GetReportDescRequest(const ::fidl::DecodedMessage<Device::GetReportDescRequest>& _msg);
    static void GetReportDescResponse(const ::fidl::DecodedMessage<Device::GetReportDescResponse>& _msg);
    static void GetNumReportsRequest(const ::fidl::DecodedMessage<Device::GetNumReportsRequest>& _msg);
    static void GetNumReportsResponse(const ::fidl::DecodedMessage<Device::GetNumReportsResponse>& _msg);
    static void GetReportIdsRequest(const ::fidl::DecodedMessage<Device::GetReportIdsRequest>& _msg);
    static void GetReportIdsResponse(const ::fidl::DecodedMessage<Device::GetReportIdsResponse>& _msg);
    static void GetReportSizeRequest(const ::fidl::DecodedMessage<Device::GetReportSizeRequest>& _msg);
    static void GetReportSizeResponse(const ::fidl::DecodedMessage<Device::GetReportSizeResponse>& _msg);
    static void GetMaxInputReportSizeRequest(const ::fidl::DecodedMessage<Device::GetMaxInputReportSizeRequest>& _msg);
    static void GetMaxInputReportSizeResponse(const ::fidl::DecodedMessage<Device::GetMaxInputReportSizeResponse>& _msg);
    static void GetReportsRequest(const ::fidl::DecodedMessage<Device::GetReportsRequest>& _msg);
    static void GetReportsResponse(const ::fidl::DecodedMessage<Device::GetReportsResponse>& _msg);
    static void GetReportsEventRequest(const ::fidl::DecodedMessage<Device::GetReportsEventRequest>& _msg);
    static void GetReportsEventResponse(const ::fidl::DecodedMessage<Device::GetReportsEventResponse>& _msg);
    static void GetReportRequest(const ::fidl::DecodedMessage<Device::GetReportRequest>& _msg);
    static void GetReportResponse(const ::fidl::DecodedMessage<Device::GetReportResponse>& _msg);
    static void SetReportRequest(const ::fidl::DecodedMessage<Device::SetReportRequest>& _msg);
    static void SetReportResponse(const ::fidl::DecodedMessage<Device::SetReportResponse>& _msg);
    static void SetTraceIdRequest(const ::fidl::DecodedMessage<Device::SetTraceIdRequest>& _msg);
  };
};

}  // namespace input
}  // namespace hardware
}  // namespace fuchsia
}  // namespace llcpp

namespace fidl {

template <>
struct IsFidlType<::llcpp::fuchsia::hardware::input::DeviceIds> : public std::true_type {};
static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::input::DeviceIds>);
static_assert(offsetof(::llcpp::fuchsia::hardware::input::DeviceIds, vendor_id) == 0);
static_assert(offsetof(::llcpp::fuchsia::hardware::input::DeviceIds, product_id) == 4);
static_assert(offsetof(::llcpp::fuchsia::hardware::input::DeviceIds, version) == 8);
static_assert(sizeof(::llcpp::fuchsia::hardware::input::DeviceIds) == ::llcpp::fuchsia::hardware::input::DeviceIds::PrimarySize);

template <>
struct IsFidlType<::llcpp::fuchsia::hardware::input::Device::GetBootProtocolResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::hardware::input::Device::GetBootProtocolResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::hardware::input::Device::GetBootProtocolResponse)
    == ::llcpp::fuchsia::hardware::input::Device::GetBootProtocolResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::hardware::input::Device::GetBootProtocolResponse, protocol) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::hardware::input::Device::GetDeviceIdsResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::hardware::input::Device::GetDeviceIdsResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::hardware::input::Device::GetDeviceIdsResponse)
    == ::llcpp::fuchsia::hardware::input::Device::GetDeviceIdsResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::hardware::input::Device::GetDeviceIdsResponse, ids) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::hardware::input::Device::GetReportDescSizeResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::hardware::input::Device::GetReportDescSizeResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::hardware::input::Device::GetReportDescSizeResponse)
    == ::llcpp::fuchsia::hardware::input::Device::GetReportDescSizeResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::hardware::input::Device::GetReportDescSizeResponse, size) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::hardware::input::Device::GetReportDescResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::hardware::input::Device::GetReportDescResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::hardware::input::Device::GetReportDescResponse)
    == ::llcpp::fuchsia::hardware::input::Device::GetReportDescResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::hardware::input::Device::GetReportDescResponse, desc) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::hardware::input::Device::GetNumReportsResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::hardware::input::Device::GetNumReportsResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::hardware::input::Device::GetNumReportsResponse)
    == ::llcpp::fuchsia::hardware::input::Device::GetNumReportsResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::hardware::input::Device::GetNumReportsResponse, count) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::hardware::input::Device::GetReportIdsResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::hardware::input::Device::GetReportIdsResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::hardware::input::Device::GetReportIdsResponse)
    == ::llcpp::fuchsia::hardware::input::Device::GetReportIdsResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::hardware::input::Device::GetReportIdsResponse, ids) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::hardware::input::Device::GetReportSizeRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::hardware::input::Device::GetReportSizeRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::hardware::input::Device::GetReportSizeRequest)
    == ::llcpp::fuchsia::hardware::input::Device::GetReportSizeRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::hardware::input::Device::GetReportSizeRequest, type) == 16);
static_assert(offsetof(::llcpp::fuchsia::hardware::input::Device::GetReportSizeRequest, id) == 17);

template <>
struct IsFidlType<::llcpp::fuchsia::hardware::input::Device::GetReportSizeResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::hardware::input::Device::GetReportSizeResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::hardware::input::Device::GetReportSizeResponse)
    == ::llcpp::fuchsia::hardware::input::Device::GetReportSizeResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::hardware::input::Device::GetReportSizeResponse, status) == 16);
static_assert(offsetof(::llcpp::fuchsia::hardware::input::Device::GetReportSizeResponse, size) == 20);

template <>
struct IsFidlType<::llcpp::fuchsia::hardware::input::Device::GetMaxInputReportSizeResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::hardware::input::Device::GetMaxInputReportSizeResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::hardware::input::Device::GetMaxInputReportSizeResponse)
    == ::llcpp::fuchsia::hardware::input::Device::GetMaxInputReportSizeResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::hardware::input::Device::GetMaxInputReportSizeResponse, size) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::hardware::input::Device::GetReportsResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::hardware::input::Device::GetReportsResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::hardware::input::Device::GetReportsResponse)
    == ::llcpp::fuchsia::hardware::input::Device::GetReportsResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::hardware::input::Device::GetReportsResponse, status) == 16);
static_assert(offsetof(::llcpp::fuchsia::hardware::input::Device::GetReportsResponse, data) == 24);

template <>
struct IsFidlType<::llcpp::fuchsia::hardware::input::Device::GetReportsEventResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::hardware::input::Device::GetReportsEventResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::hardware::input::Device::GetReportsEventResponse)
    == ::llcpp::fuchsia::hardware::input::Device::GetReportsEventResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::hardware::input::Device::GetReportsEventResponse, status) == 16);
static_assert(offsetof(::llcpp::fuchsia::hardware::input::Device::GetReportsEventResponse, event) == 20);

template <>
struct IsFidlType<::llcpp::fuchsia::hardware::input::Device::GetReportRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::hardware::input::Device::GetReportRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::hardware::input::Device::GetReportRequest)
    == ::llcpp::fuchsia::hardware::input::Device::GetReportRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::hardware::input::Device::GetReportRequest, type) == 16);
static_assert(offsetof(::llcpp::fuchsia::hardware::input::Device::GetReportRequest, id) == 17);

template <>
struct IsFidlType<::llcpp::fuchsia::hardware::input::Device::GetReportResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::hardware::input::Device::GetReportResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::hardware::input::Device::GetReportResponse)
    == ::llcpp::fuchsia::hardware::input::Device::GetReportResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::hardware::input::Device::GetReportResponse, status) == 16);
static_assert(offsetof(::llcpp::fuchsia::hardware::input::Device::GetReportResponse, report) == 24);

template <>
struct IsFidlType<::llcpp::fuchsia::hardware::input::Device::SetReportRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::hardware::input::Device::SetReportRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::hardware::input::Device::SetReportRequest)
    == ::llcpp::fuchsia::hardware::input::Device::SetReportRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::hardware::input::Device::SetReportRequest, type) == 16);
static_assert(offsetof(::llcpp::fuchsia::hardware::input::Device::SetReportRequest, id) == 17);
static_assert(offsetof(::llcpp::fuchsia::hardware::input::Device::SetReportRequest, report) == 24);

template <>
struct IsFidlType<::llcpp::fuchsia::hardware::input::Device::SetReportResponse> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::hardware::input::Device::SetReportResponse> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::hardware::input::Device::SetReportResponse)
    == ::llcpp::fuchsia::hardware::input::Device::SetReportResponse::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::hardware::input::Device::SetReportResponse, status) == 16);

template <>
struct IsFidlType<::llcpp::fuchsia::hardware::input::Device::SetTraceIdRequest> : public std::true_type {};
template <>
struct IsFidlMessage<::llcpp::fuchsia::hardware::input::Device::SetTraceIdRequest> : public std::true_type {};
static_assert(sizeof(::llcpp::fuchsia::hardware::input::Device::SetTraceIdRequest)
    == ::llcpp::fuchsia::hardware::input::Device::SetTraceIdRequest::PrimarySize);
static_assert(offsetof(::llcpp::fuchsia::hardware::input::Device::SetTraceIdRequest, id) == 16);

}  // namespace fidl