win-Debug/gen/device/gamepad/public/mojom/gamepad.mojom-blink.h

// device/gamepad/public/mojom/gamepad.mojom-blink.h is auto generated by mojom_bindings_generator.py, do not edit

// Copyright 2013 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef DEVICE_GAMEPAD_PUBLIC_MOJOM_GAMEPAD_MOJOM_BLINK_H_
#define DEVICE_GAMEPAD_PUBLIC_MOJOM_GAMEPAD_MOJOM_BLINK_H_

#include <stdint.h>

#include <limits>
#include <optional>
#include <type_traits>
#include <utility>

#include "base/types/cxx23_to_underlying.h"
#include "mojo/public/cpp/bindings/clone_traits.h"
#include "mojo/public/cpp/bindings/equals_traits.h"
#include "mojo/public/cpp/bindings/lib/serialization.h"
#include "mojo/public/cpp/bindings/struct_ptr.h"
#include "mojo/public/cpp/bindings/struct_traits.h"
#include "mojo/public/cpp/bindings/union_traits.h"

#include "third_party/perfetto/include/perfetto/tracing/traced_value_forward.h"

#include "device/gamepad/public/mojom/gamepad.mojom-features.h"
#include "device/gamepad/public/mojom/gamepad.mojom-shared.h"
#include "device/gamepad/public/mojom/gamepad.mojom-blink-forward.h"
#include "mojo/public/mojom/base/shared_memory.mojom-blink.h"

#include "mojo/public/cpp/bindings/lib/wtf_clone_equals_util.h"
#include "mojo/public/cpp/bindings/lib/wtf_hash_util.h"
#include "third_party/blink/renderer/platform/wtf/hash_functions.h"
#include "third_party/blink/renderer/platform/wtf/text/wtf_string.h"

#include "mojo/public/cpp/bindings/lib/control_message_handler.h"
#include "mojo/public/cpp/bindings/lib/message_size_estimator.h"
#include "mojo/public/cpp/bindings/raw_ptr_impl_ref_traits.h"


#include "device/gamepad/public/cpp/gamepad_mojom_traits.h"
#include "base/component_export.h"

#ifdef KYTHE_IS_RUNNING
#pragma kythe_inline_metadata "Metadata comment"
#endif


namespace device::mojom::blink {

class GamepadObserverProxy;

template <typename ImplRefTraits>
class GamepadObserverStub;

class GamepadObserverRequestValidator;


// @generated_from: device.mojom.GamepadObserver
class COMPONENT_EXPORT(GAMEPAD_MOJOM_BLINK) GamepadObserver
    : public GamepadObserverInterfaceBase {
 public:
  using IPCStableHashFunction = uint32_t(*)();

  static const char Name_[];
  static IPCStableHashFunction MessageToMethodInfo_(mojo::Message& message);
  static const char* MessageToMethodName_(mojo::Message& message);
  static constexpr uint32_t Version_ = 0;
  static constexpr bool PassesAssociatedKinds_ = false;
  static constexpr bool HasUninterruptableMethods_ = false;

  using Base_ = GamepadObserverInterfaceBase;
  using Proxy_ = GamepadObserverProxy;

  template <typename ImplRefTraits>
  using Stub_ = GamepadObserverStub<ImplRefTraits>;

  using RequestValidator_ = GamepadObserverRequestValidator;
  using ResponseValidator_ = mojo::PassThroughFilter;
  enum MethodMinVersions : uint32_t {
    kGamepadConnectedMinVersion = 0,
    kGamepadDisconnectedMinVersion = 0,
    kGamepadChangedMinVersion = 0,
  };

// crbug.com/1340245 - this causes binary size bloat on Fuchsia, and we're OK
// with not having this data in traces there.
#if !BUILDFLAG(IS_FUCHSIA)
  struct GamepadConnected_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct GamepadDisconnected_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct GamepadChanged_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
#endif // !BUILDFLAG(IS_FUCHSIA)
  virtual ~GamepadObserver() = default;

  
// @generated_from: device.mojom.GamepadObserver.GamepadConnected
  virtual void GamepadConnected(uint32_t index, const ::device::Gamepad& gamepad) = 0;

  
// @generated_from: device.mojom.GamepadObserver.GamepadDisconnected
  virtual void GamepadDisconnected(uint32_t index, const ::device::Gamepad& gamepad) = 0;

  
// @generated_from: device.mojom.GamepadObserver.GamepadChanged
  virtual void GamepadChanged(GamepadChangesPtr changes) = 0;
};

class GamepadMonitorProxy;

template <typename ImplRefTraits>
class GamepadMonitorStub;

class GamepadMonitorRequestValidator;
class GamepadMonitorResponseValidator;


// @generated_from: device.mojom.GamepadMonitor
class COMPONENT_EXPORT(GAMEPAD_MOJOM_BLINK) GamepadMonitor
    : public GamepadMonitorInterfaceBase {
 public:
  using IPCStableHashFunction = uint32_t(*)();

  static const char Name_[];
  static IPCStableHashFunction MessageToMethodInfo_(mojo::Message& message);
  static const char* MessageToMethodName_(mojo::Message& message);
  static constexpr uint32_t Version_ = 0;
  static constexpr bool PassesAssociatedKinds_ = false;
  static inline constexpr uint32_t kSyncMethodOrdinals[] = {
    0, 
    1
  };
  static constexpr bool HasUninterruptableMethods_ = false;

  using Base_ = GamepadMonitorInterfaceBase;
  using Proxy_ = GamepadMonitorProxy;

  template <typename ImplRefTraits>
  using Stub_ = GamepadMonitorStub<ImplRefTraits>;

  using RequestValidator_ = GamepadMonitorRequestValidator;
  using ResponseValidator_ = GamepadMonitorResponseValidator;
  enum MethodMinVersions : uint32_t {
    kGamepadStartPollingMinVersion = 0,
    kGamepadStopPollingMinVersion = 0,
    kSetObserverMinVersion = 0,
  };

// crbug.com/1340245 - this causes binary size bloat on Fuchsia, and we're OK
// with not having this data in traces there.
#if !BUILDFLAG(IS_FUCHSIA)
  struct GamepadStartPolling_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct GamepadStopPolling_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct SetObserver_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
#endif // !BUILDFLAG(IS_FUCHSIA)
  virtual ~GamepadMonitor() = default;

  // Sync method. This signature is used by the client side; the service side
  // should implement the signature with callback below.
  
// @generated_from: device.mojom.GamepadMonitor.GamepadStartPolling
  virtual bool GamepadStartPolling(::base::ReadOnlySharedMemoryRegion* out_memory_region);

  using GamepadStartPollingCallback = base::OnceCallback<void(::base::ReadOnlySharedMemoryRegion)>;
  
// @generated_from: device.mojom.GamepadMonitor.GamepadStartPolling
  virtual void GamepadStartPolling(GamepadStartPollingCallback callback) = 0;

  // Sync method. This signature is used by the client side; the service side
  // should implement the signature with callback below.
  
// @generated_from: device.mojom.GamepadMonitor.GamepadStopPolling
  virtual bool GamepadStopPolling();

  using GamepadStopPollingCallback = base::OnceCallback<void()>;
  
// @generated_from: device.mojom.GamepadMonitor.GamepadStopPolling
  virtual void GamepadStopPolling(GamepadStopPollingCallback callback) = 0;

  
// @generated_from: device.mojom.GamepadMonitor.SetObserver
  virtual void SetObserver(::mojo::PendingRemote<GamepadObserver> gamepad_observer) = 0;
};

class GamepadHapticsManagerProxy;

template <typename ImplRefTraits>
class GamepadHapticsManagerStub;

class GamepadHapticsManagerRequestValidator;
class GamepadHapticsManagerResponseValidator;


// @generated_from: device.mojom.GamepadHapticsManager
class COMPONENT_EXPORT(GAMEPAD_MOJOM_BLINK) GamepadHapticsManager
    : public GamepadHapticsManagerInterfaceBase {
 public:
  using IPCStableHashFunction = uint32_t(*)();

  static const char Name_[];
  static IPCStableHashFunction MessageToMethodInfo_(mojo::Message& message);
  static const char* MessageToMethodName_(mojo::Message& message);
  static constexpr uint32_t Version_ = 0;
  static constexpr bool PassesAssociatedKinds_ = false;
  static constexpr bool HasUninterruptableMethods_ = false;

  using Base_ = GamepadHapticsManagerInterfaceBase;
  using Proxy_ = GamepadHapticsManagerProxy;

  template <typename ImplRefTraits>
  using Stub_ = GamepadHapticsManagerStub<ImplRefTraits>;

  using RequestValidator_ = GamepadHapticsManagerRequestValidator;
  using ResponseValidator_ = GamepadHapticsManagerResponseValidator;
  enum MethodMinVersions : uint32_t {
    kPlayVibrationEffectOnceMinVersion = 0,
    kResetVibrationActuatorMinVersion = 0,
  };

// crbug.com/1340245 - this causes binary size bloat on Fuchsia, and we're OK
// with not having this data in traces there.
#if !BUILDFLAG(IS_FUCHSIA)
  struct PlayVibrationEffectOnce_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct ResetVibrationActuator_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
#endif // !BUILDFLAG(IS_FUCHSIA)
  virtual ~GamepadHapticsManager() = default;


  using PlayVibrationEffectOnceCallback = base::OnceCallback<void(GamepadHapticsResult)>;
  
// @generated_from: device.mojom.GamepadHapticsManager.PlayVibrationEffectOnce
  virtual void PlayVibrationEffectOnce(uint32_t pad_index, GamepadHapticEffectType type, GamepadEffectParametersPtr params, PlayVibrationEffectOnceCallback callback) = 0;


  using ResetVibrationActuatorCallback = base::OnceCallback<void(GamepadHapticsResult)>;
  
// @generated_from: device.mojom.GamepadHapticsManager.ResetVibrationActuator
  virtual void ResetVibrationActuator(uint32_t pad_index, ResetVibrationActuatorCallback callback) = 0;
};



// @generated_from: device.mojom.GamepadObserver
class COMPONENT_EXPORT(GAMEPAD_MOJOM_BLINK) GamepadObserverProxy
    : public GamepadObserver {
 public:
  using InterfaceType = GamepadObserver;

  explicit GamepadObserverProxy(mojo::MessageReceiverWithResponder* receiver);
  
// @generated_from: device.mojom.GamepadObserver.GamepadConnected
  void GamepadConnected(uint32_t index, const ::device::Gamepad& gamepad) final;
  
// @generated_from: device.mojom.GamepadObserver.GamepadDisconnected
  void GamepadDisconnected(uint32_t index, const ::device::Gamepad& gamepad) final;
  
// @generated_from: device.mojom.GamepadObserver.GamepadChanged
  void GamepadChanged(GamepadChangesPtr changes) final;

 private:
  mojo::MessageReceiverWithResponder* receiver_;
};



// @generated_from: device.mojom.GamepadMonitor
class COMPONENT_EXPORT(GAMEPAD_MOJOM_BLINK) GamepadMonitorProxy
    : public GamepadMonitor {
 public:
  using InterfaceType = GamepadMonitor;

  explicit GamepadMonitorProxy(mojo::MessageReceiverWithResponder* receiver);
  
// @generated_from: device.mojom.GamepadMonitor.GamepadStartPolling
  bool GamepadStartPolling(::base::ReadOnlySharedMemoryRegion* out_memory_region) final;
  
// @generated_from: device.mojom.GamepadMonitor.GamepadStartPolling
  void GamepadStartPolling(GamepadStartPollingCallback callback) final;
  
// @generated_from: device.mojom.GamepadMonitor.GamepadStopPolling
  bool GamepadStopPolling() final;
  
// @generated_from: device.mojom.GamepadMonitor.GamepadStopPolling
  void GamepadStopPolling(GamepadStopPollingCallback callback) final;
  
// @generated_from: device.mojom.GamepadMonitor.SetObserver
  void SetObserver(::mojo::PendingRemote<GamepadObserver> gamepad_observer) final;

 private:
  mojo::MessageReceiverWithResponder* receiver_;
};



// @generated_from: device.mojom.GamepadHapticsManager
class COMPONENT_EXPORT(GAMEPAD_MOJOM_BLINK) GamepadHapticsManagerProxy
    : public GamepadHapticsManager {
 public:
  using InterfaceType = GamepadHapticsManager;

  explicit GamepadHapticsManagerProxy(mojo::MessageReceiverWithResponder* receiver);
  
// @generated_from: device.mojom.GamepadHapticsManager.PlayVibrationEffectOnce
  void PlayVibrationEffectOnce(uint32_t pad_index, GamepadHapticEffectType type, GamepadEffectParametersPtr params, PlayVibrationEffectOnceCallback callback) final;
  
// @generated_from: device.mojom.GamepadHapticsManager.ResetVibrationActuator
  void ResetVibrationActuator(uint32_t pad_index, ResetVibrationActuatorCallback callback) final;

 private:
  mojo::MessageReceiverWithResponder* receiver_;
};
class COMPONENT_EXPORT(GAMEPAD_MOJOM_BLINK) GamepadObserverStubDispatch {
 public:
  static bool Accept(GamepadObserver* impl, mojo::Message* message);
  static bool AcceptWithResponder(
      GamepadObserver* impl,
      mojo::Message* message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder);
};

template <typename ImplRefTraits =
              mojo::RawPtrImplRefTraits<GamepadObserver>>
class GamepadObserverStub
    : public mojo::MessageReceiverWithResponderStatus {
 public:
  using ImplPointerType = typename ImplRefTraits::PointerType;

  GamepadObserverStub() = default;
  ~GamepadObserverStub() override = default;

  void set_sink(ImplPointerType sink) { sink_ = std::move(sink); }
  ImplPointerType& sink() { return sink_; }

  bool Accept(mojo::Message* message) override {
    if (ImplRefTraits::IsNull(sink_))
      return false;
    return GamepadObserverStubDispatch::Accept(
        ImplRefTraits::GetRawPointer(&sink_), message);
  }

  bool AcceptWithResponder(
      mojo::Message* message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) override {
    if (ImplRefTraits::IsNull(sink_))
      return false;
    return GamepadObserverStubDispatch::AcceptWithResponder(
        ImplRefTraits::GetRawPointer(&sink_), message, std::move(responder));
  }

 private:
  ImplPointerType sink_;
};
class COMPONENT_EXPORT(GAMEPAD_MOJOM_BLINK) GamepadMonitorStubDispatch {
 public:
  static bool Accept(GamepadMonitor* impl, mojo::Message* message);
  static bool AcceptWithResponder(
      GamepadMonitor* impl,
      mojo::Message* message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder);
};

template <typename ImplRefTraits =
              mojo::RawPtrImplRefTraits<GamepadMonitor>>
class GamepadMonitorStub
    : public mojo::MessageReceiverWithResponderStatus {
 public:
  using ImplPointerType = typename ImplRefTraits::PointerType;

  GamepadMonitorStub() = default;
  ~GamepadMonitorStub() override = default;

  void set_sink(ImplPointerType sink) { sink_ = std::move(sink); }
  ImplPointerType& sink() { return sink_; }

  bool Accept(mojo::Message* message) override {
    if (ImplRefTraits::IsNull(sink_))
      return false;
    return GamepadMonitorStubDispatch::Accept(
        ImplRefTraits::GetRawPointer(&sink_), message);
  }

  bool AcceptWithResponder(
      mojo::Message* message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) override {
    if (ImplRefTraits::IsNull(sink_))
      return false;
    return GamepadMonitorStubDispatch::AcceptWithResponder(
        ImplRefTraits::GetRawPointer(&sink_), message, std::move(responder));
  }

 private:
  ImplPointerType sink_;
};
class COMPONENT_EXPORT(GAMEPAD_MOJOM_BLINK) GamepadHapticsManagerStubDispatch {
 public:
  static bool Accept(GamepadHapticsManager* impl, mojo::Message* message);
  static bool AcceptWithResponder(
      GamepadHapticsManager* impl,
      mojo::Message* message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder);
};

template <typename ImplRefTraits =
              mojo::RawPtrImplRefTraits<GamepadHapticsManager>>
class GamepadHapticsManagerStub
    : public mojo::MessageReceiverWithResponderStatus {
 public:
  using ImplPointerType = typename ImplRefTraits::PointerType;

  GamepadHapticsManagerStub() = default;
  ~GamepadHapticsManagerStub() override = default;

  void set_sink(ImplPointerType sink) { sink_ = std::move(sink); }
  ImplPointerType& sink() { return sink_; }

  bool Accept(mojo::Message* message) override {
    if (ImplRefTraits::IsNull(sink_))
      return false;
    return GamepadHapticsManagerStubDispatch::Accept(
        ImplRefTraits::GetRawPointer(&sink_), message);
  }

  bool AcceptWithResponder(
      mojo::Message* message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) override {
    if (ImplRefTraits::IsNull(sink_))
      return false;
    return GamepadHapticsManagerStubDispatch::AcceptWithResponder(
        ImplRefTraits::GetRawPointer(&sink_), message, std::move(responder));
  }

 private:
  ImplPointerType sink_;
};
class COMPONENT_EXPORT(GAMEPAD_MOJOM_BLINK) GamepadObserverRequestValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class COMPONENT_EXPORT(GAMEPAD_MOJOM_BLINK) GamepadMonitorRequestValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class COMPONENT_EXPORT(GAMEPAD_MOJOM_BLINK) GamepadHapticsManagerRequestValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class COMPONENT_EXPORT(GAMEPAD_MOJOM_BLINK) GamepadMonitorResponseValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class COMPONENT_EXPORT(GAMEPAD_MOJOM_BLINK) GamepadHapticsManagerResponseValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};





// @generated_from: device.mojom.GamepadQuaternion
class COMPONENT_EXPORT(GAMEPAD_MOJOM_BLINK) GamepadQuaternion {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<GamepadQuaternion, T>::value>;
  using DataView = GamepadQuaternionDataView;
  using Data_ = internal::GamepadQuaternion_Data;

  template <typename... Args>
  static GamepadQuaternionPtr New(Args&&... args) {
    return GamepadQuaternionPtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static GamepadQuaternionPtr From(const U& u) {
    return mojo::TypeConverter<GamepadQuaternionPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, GamepadQuaternion>::Convert(*this);
  }


  GamepadQuaternion();

  GamepadQuaternion(
      float x,
      float y,
      float z,
      float w);


  ~GamepadQuaternion();

  // Clone() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Clone() or copy
  // constructor/assignment are available for members.
  template <typename StructPtrType = GamepadQuaternionPtr>
  GamepadQuaternionPtr Clone() const;

  // Equals() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Equals() or == operator
  // are available for members.
  template <typename T, GamepadQuaternion::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, GamepadQuaternion::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, GamepadQuaternion::EnableIfSame<T>* = nullptr>
  bool operator!=(const T& rhs) const { return !operator==(rhs); }
  template <typename UserType>
  static WTF::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        GamepadQuaternion::DataView, WTF::Vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        GamepadQuaternion::DataView>(input);
  }

  // The returned Message is serialized only if the message is moved
  // cross-process or cross-language. Otherwise if the message is Deserialized
  // as the same UserType |input| will just be moved to |output| in
  // DeserializeFromMessage.
  template <typename UserType>
  static mojo::Message WrapAsMessage(UserType input) {
    return mojo::Message(std::make_unique<
        internal::GamepadQuaternion_UnserializedMessageContext<
            UserType, GamepadQuaternion::DataView>>(0, 0, std::move(input)),
        MOJO_CREATE_MESSAGE_FLAG_NONE);
  }

  template <typename UserType>
  static bool Deserialize(const void* data,
                          size_t data_num_bytes,
                          UserType* output) {
    mojo::Message message;
    return mojo::internal::DeserializeImpl<GamepadQuaternion::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(const WTF::Vector<uint8_t>& input,
                          UserType* output) {
    return GamepadQuaternion::Deserialize(
        input.size() == 0 ? nullptr : &input.front(), input.size(), output);
  }

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    auto context = input.TakeUnserializedContext<
        internal::GamepadQuaternion_UnserializedMessageContext<
            UserType, GamepadQuaternion::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<GamepadQuaternion::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
// @generated_from: device.mojom.GamepadQuaternion.x
  float x;
  
// @generated_from: device.mojom.GamepadQuaternion.y
  float y;
  
// @generated_from: device.mojom.GamepadQuaternion.z
  float z;
  
// @generated_from: device.mojom.GamepadQuaternion.w
  float w;

  // Serialise this struct into a trace.
  void WriteIntoTrace(perfetto::TracedValue traced_context) const;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
};

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, GamepadQuaternion::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, GamepadQuaternion::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {
  return !(rhs < lhs);
}

template <typename T, GamepadQuaternion::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
  return rhs < lhs;
}

template <typename T, GamepadQuaternion::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
  return !(lhs < rhs);
}





// @generated_from: device.mojom.GamepadVector
class COMPONENT_EXPORT(GAMEPAD_MOJOM_BLINK) GamepadVector {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<GamepadVector, T>::value>;
  using DataView = GamepadVectorDataView;
  using Data_ = internal::GamepadVector_Data;

  template <typename... Args>
  static GamepadVectorPtr New(Args&&... args) {
    return GamepadVectorPtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static GamepadVectorPtr From(const U& u) {
    return mojo::TypeConverter<GamepadVectorPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, GamepadVector>::Convert(*this);
  }


  GamepadVector();

  GamepadVector(
      float x,
      float y,
      float z);


  ~GamepadVector();

  // Clone() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Clone() or copy
  // constructor/assignment are available for members.
  template <typename StructPtrType = GamepadVectorPtr>
  GamepadVectorPtr Clone() const;

  // Equals() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Equals() or == operator
  // are available for members.
  template <typename T, GamepadVector::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, GamepadVector::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, GamepadVector::EnableIfSame<T>* = nullptr>
  bool operator!=(const T& rhs) const { return !operator==(rhs); }
  template <typename UserType>
  static WTF::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        GamepadVector::DataView, WTF::Vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        GamepadVector::DataView>(input);
  }

  // The returned Message is serialized only if the message is moved
  // cross-process or cross-language. Otherwise if the message is Deserialized
  // as the same UserType |input| will just be moved to |output| in
  // DeserializeFromMessage.
  template <typename UserType>
  static mojo::Message WrapAsMessage(UserType input) {
    return mojo::Message(std::make_unique<
        internal::GamepadVector_UnserializedMessageContext<
            UserType, GamepadVector::DataView>>(0, 0, std::move(input)),
        MOJO_CREATE_MESSAGE_FLAG_NONE);
  }

  template <typename UserType>
  static bool Deserialize(const void* data,
                          size_t data_num_bytes,
                          UserType* output) {
    mojo::Message message;
    return mojo::internal::DeserializeImpl<GamepadVector::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(const WTF::Vector<uint8_t>& input,
                          UserType* output) {
    return GamepadVector::Deserialize(
        input.size() == 0 ? nullptr : &input.front(), input.size(), output);
  }

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    auto context = input.TakeUnserializedContext<
        internal::GamepadVector_UnserializedMessageContext<
            UserType, GamepadVector::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<GamepadVector::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
// @generated_from: device.mojom.GamepadVector.x
  float x;
  
// @generated_from: device.mojom.GamepadVector.y
  float y;
  
// @generated_from: device.mojom.GamepadVector.z
  float z;

  // Serialise this struct into a trace.
  void WriteIntoTrace(perfetto::TracedValue traced_context) const;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
};

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, GamepadVector::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, GamepadVector::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {
  return !(rhs < lhs);
}

template <typename T, GamepadVector::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
  return rhs < lhs;
}

template <typename T, GamepadVector::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
  return !(lhs < rhs);
}





// @generated_from: device.mojom.GamepadButton
class COMPONENT_EXPORT(GAMEPAD_MOJOM_BLINK) GamepadButton {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<GamepadButton, T>::value>;
  using DataView = GamepadButtonDataView;
  using Data_ = internal::GamepadButton_Data;

  template <typename... Args>
  static GamepadButtonPtr New(Args&&... args) {
    return GamepadButtonPtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static GamepadButtonPtr From(const U& u) {
    return mojo::TypeConverter<GamepadButtonPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, GamepadButton>::Convert(*this);
  }


  GamepadButton();

  GamepadButton(
      bool pressed,
      bool touched,
      double value);


  ~GamepadButton();

  // Clone() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Clone() or copy
  // constructor/assignment are available for members.
  template <typename StructPtrType = GamepadButtonPtr>
  GamepadButtonPtr Clone() const;

  // Equals() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Equals() or == operator
  // are available for members.
  template <typename T, GamepadButton::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, GamepadButton::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, GamepadButton::EnableIfSame<T>* = nullptr>
  bool operator!=(const T& rhs) const { return !operator==(rhs); }
  template <typename UserType>
  static WTF::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        GamepadButton::DataView, WTF::Vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        GamepadButton::DataView>(input);
  }

  // The returned Message is serialized only if the message is moved
  // cross-process or cross-language. Otherwise if the message is Deserialized
  // as the same UserType |input| will just be moved to |output| in
  // DeserializeFromMessage.
  template <typename UserType>
  static mojo::Message WrapAsMessage(UserType input) {
    return mojo::Message(std::make_unique<
        internal::GamepadButton_UnserializedMessageContext<
            UserType, GamepadButton::DataView>>(0, 0, std::move(input)),
        MOJO_CREATE_MESSAGE_FLAG_NONE);
  }

  template <typename UserType>
  static bool Deserialize(const void* data,
                          size_t data_num_bytes,
                          UserType* output) {
    mojo::Message message;
    return mojo::internal::DeserializeImpl<GamepadButton::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(const WTF::Vector<uint8_t>& input,
                          UserType* output) {
    return GamepadButton::Deserialize(
        input.size() == 0 ? nullptr : &input.front(), input.size(), output);
  }

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    auto context = input.TakeUnserializedContext<
        internal::GamepadButton_UnserializedMessageContext<
            UserType, GamepadButton::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<GamepadButton::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
// @generated_from: device.mojom.GamepadButton.pressed
  bool pressed;
  
// @generated_from: device.mojom.GamepadButton.touched
  bool touched;
  
// @generated_from: device.mojom.GamepadButton.value
  double value;

  // Serialise this struct into a trace.
  void WriteIntoTrace(perfetto::TracedValue traced_context) const;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
};

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, GamepadButton::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, GamepadButton::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {
  return !(rhs < lhs);
}

template <typename T, GamepadButton::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
  return rhs < lhs;
}

template <typename T, GamepadButton::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
  return !(lhs < rhs);
}






// @generated_from: device.mojom.AxisChange
class COMPONENT_EXPORT(GAMEPAD_MOJOM_BLINK) AxisChange {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<AxisChange, T>::value>;
  using DataView = AxisChangeDataView;
  using Data_ = internal::AxisChange_Data;

  template <typename... Args>
  static AxisChangePtr New(Args&&... args) {
    return AxisChangePtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static AxisChangePtr From(const U& u) {
    return mojo::TypeConverter<AxisChangePtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, AxisChange>::Convert(*this);
  }


  AxisChange();

  AxisChange(
      uint32_t axis_index,
      double axis_snapshot);


  ~AxisChange();

  // Clone() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Clone() or copy
  // constructor/assignment are available for members.
  template <typename StructPtrType = AxisChangePtr>
  AxisChangePtr Clone() const;

  // Equals() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Equals() or == operator
  // are available for members.
  template <typename T, AxisChange::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, AxisChange::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, AxisChange::EnableIfSame<T>* = nullptr>
  bool operator!=(const T& rhs) const { return !operator==(rhs); }
  size_t Hash(size_t seed) const;
  template <typename UserType>
  static WTF::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        AxisChange::DataView, WTF::Vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        AxisChange::DataView>(input);
  }

  // The returned Message is serialized only if the message is moved
  // cross-process or cross-language. Otherwise if the message is Deserialized
  // as the same UserType |input| will just be moved to |output| in
  // DeserializeFromMessage.
  template <typename UserType>
  static mojo::Message WrapAsMessage(UserType input) {
    return mojo::Message(std::make_unique<
        internal::AxisChange_UnserializedMessageContext<
            UserType, AxisChange::DataView>>(0, 0, std::move(input)),
        MOJO_CREATE_MESSAGE_FLAG_NONE);
  }

  template <typename UserType>
  static bool Deserialize(const void* data,
                          size_t data_num_bytes,
                          UserType* output) {
    mojo::Message message;
    return mojo::internal::DeserializeImpl<AxisChange::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(const WTF::Vector<uint8_t>& input,
                          UserType* output) {
    return AxisChange::Deserialize(
        input.size() == 0 ? nullptr : &input.front(), input.size(), output);
  }

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    auto context = input.TakeUnserializedContext<
        internal::AxisChange_UnserializedMessageContext<
            UserType, AxisChange::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<AxisChange::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
// @generated_from: device.mojom.AxisChange.axis_index
  uint32_t axis_index;
  
// @generated_from: device.mojom.AxisChange.axis_snapshot
  double axis_snapshot;

  // Serialise this struct into a trace.
  void WriteIntoTrace(perfetto::TracedValue traced_context) const;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
};

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, AxisChange::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, AxisChange::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {
  return !(rhs < lhs);
}

template <typename T, AxisChange::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
  return rhs < lhs;
}

template <typename T, AxisChange::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
  return !(lhs < rhs);
}








// @generated_from: device.mojom.GamepadHapticActuator
class COMPONENT_EXPORT(GAMEPAD_MOJOM_BLINK) GamepadHapticActuator {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<GamepadHapticActuator, T>::value>;
  using DataView = GamepadHapticActuatorDataView;
  using Data_ = internal::GamepadHapticActuator_Data;

  template <typename... Args>
  static GamepadHapticActuatorPtr New(Args&&... args) {
    return GamepadHapticActuatorPtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static GamepadHapticActuatorPtr From(const U& u) {
    return mojo::TypeConverter<GamepadHapticActuatorPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, GamepadHapticActuator>::Convert(*this);
  }


  GamepadHapticActuator();

  explicit GamepadHapticActuator(
      ::device::GamepadHapticActuatorType type);


  ~GamepadHapticActuator();

  // Clone() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Clone() or copy
  // constructor/assignment are available for members.
  template <typename StructPtrType = GamepadHapticActuatorPtr>
  GamepadHapticActuatorPtr Clone() const;

  // Equals() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Equals() or == operator
  // are available for members.
  template <typename T, GamepadHapticActuator::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, GamepadHapticActuator::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, GamepadHapticActuator::EnableIfSame<T>* = nullptr>
  bool operator!=(const T& rhs) const { return !operator==(rhs); }
  template <typename UserType>
  static WTF::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        GamepadHapticActuator::DataView, WTF::Vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        GamepadHapticActuator::DataView>(input);
  }

  // The returned Message is serialized only if the message is moved
  // cross-process or cross-language. Otherwise if the message is Deserialized
  // as the same UserType |input| will just be moved to |output| in
  // DeserializeFromMessage.
  template <typename UserType>
  static mojo::Message WrapAsMessage(UserType input) {
    return mojo::Message(std::make_unique<
        internal::GamepadHapticActuator_UnserializedMessageContext<
            UserType, GamepadHapticActuator::DataView>>(0, 0, std::move(input)),
        MOJO_CREATE_MESSAGE_FLAG_NONE);
  }

  template <typename UserType>
  static bool Deserialize(const void* data,
                          size_t data_num_bytes,
                          UserType* output) {
    mojo::Message message;
    return mojo::internal::DeserializeImpl<GamepadHapticActuator::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(const WTF::Vector<uint8_t>& input,
                          UserType* output) {
    return GamepadHapticActuator::Deserialize(
        input.size() == 0 ? nullptr : &input.front(), input.size(), output);
  }

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    auto context = input.TakeUnserializedContext<
        internal::GamepadHapticActuator_UnserializedMessageContext<
            UserType, GamepadHapticActuator::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<GamepadHapticActuator::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
// @generated_from: device.mojom.GamepadHapticActuator.type
  ::device::GamepadHapticActuatorType type;

  // Serialise this struct into a trace.
  void WriteIntoTrace(perfetto::TracedValue traced_context) const;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
};

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, GamepadHapticActuator::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, GamepadHapticActuator::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {
  return !(rhs < lhs);
}

template <typename T, GamepadHapticActuator::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
  return rhs < lhs;
}

template <typename T, GamepadHapticActuator::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
  return !(lhs < rhs);
}












// @generated_from: device.mojom.ButtonChange
class COMPONENT_EXPORT(GAMEPAD_MOJOM_BLINK) ButtonChange {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<ButtonChange, T>::value>;
  using DataView = ButtonChangeDataView;
  using Data_ = internal::ButtonChange_Data;

  template <typename... Args>
  static ButtonChangePtr New(Args&&... args) {
    return ButtonChangePtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static ButtonChangePtr From(const U& u) {
    return mojo::TypeConverter<ButtonChangePtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, ButtonChange>::Convert(*this);
  }


  ButtonChange();

  ButtonChange(
      uint32_t button_index,
      bool button_down,
      bool button_up,
      bool value_changed,
      const ::device::GamepadButton& button_snapshot);


  ~ButtonChange();

  // Clone() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Clone() or copy
  // constructor/assignment are available for members.
  template <typename StructPtrType = ButtonChangePtr>
  ButtonChangePtr Clone() const;

  // Equals() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Equals() or == operator
  // are available for members.
  template <typename T, ButtonChange::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, ButtonChange::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, ButtonChange::EnableIfSame<T>* = nullptr>
  bool operator!=(const T& rhs) const { return !operator==(rhs); }
  template <typename UserType>
  static WTF::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        ButtonChange::DataView, WTF::Vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        ButtonChange::DataView>(input);
  }

  // The returned Message is serialized only if the message is moved
  // cross-process or cross-language. Otherwise if the message is Deserialized
  // as the same UserType |input| will just be moved to |output| in
  // DeserializeFromMessage.
  template <typename UserType>
  static mojo::Message WrapAsMessage(UserType input) {
    return mojo::Message(std::make_unique<
        internal::ButtonChange_UnserializedMessageContext<
            UserType, ButtonChange::DataView>>(0, 0, std::move(input)),
        MOJO_CREATE_MESSAGE_FLAG_NONE);
  }

  template <typename UserType>
  static bool Deserialize(const void* data,
                          size_t data_num_bytes,
                          UserType* output) {
    mojo::Message message;
    return mojo::internal::DeserializeImpl<ButtonChange::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(const WTF::Vector<uint8_t>& input,
                          UserType* output) {
    return ButtonChange::Deserialize(
        input.size() == 0 ? nullptr : &input.front(), input.size(), output);
  }

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    auto context = input.TakeUnserializedContext<
        internal::ButtonChange_UnserializedMessageContext<
            UserType, ButtonChange::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<ButtonChange::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
// @generated_from: device.mojom.ButtonChange.button_index
  uint32_t button_index;
  
// @generated_from: device.mojom.ButtonChange.button_down
  bool button_down;
  
// @generated_from: device.mojom.ButtonChange.button_up
  bool button_up;
  
// @generated_from: device.mojom.ButtonChange.value_changed
  bool value_changed;
  
// @generated_from: device.mojom.ButtonChange.button_snapshot
  ::device::GamepadButton button_snapshot;

  // Serialise this struct into a trace.
  void WriteIntoTrace(perfetto::TracedValue traced_context) const;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
};

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, ButtonChange::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, ButtonChange::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {
  return !(rhs < lhs);
}

template <typename T, ButtonChange::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
  return rhs < lhs;
}

template <typename T, ButtonChange::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
  return !(lhs < rhs);
}






// @generated_from: device.mojom.GamepadChanges
class COMPONENT_EXPORT(GAMEPAD_MOJOM_BLINK) GamepadChanges {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<GamepadChanges, T>::value>;
  using DataView = GamepadChangesDataView;
  using Data_ = internal::GamepadChanges_Data;

  template <typename... Args>
  static GamepadChangesPtr New(Args&&... args) {
    return GamepadChangesPtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static GamepadChangesPtr From(const U& u) {
    return mojo::TypeConverter<GamepadChangesPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, GamepadChanges>::Convert(*this);
  }


  GamepadChanges();

  GamepadChanges(
      uint32_t gamepad_index,
      WTF::Vector<ButtonChangePtr> button_changes,
      WTF::Vector<AxisChangePtr> axis_changes,
      int64_t timestamp);

GamepadChanges(const GamepadChanges&) = delete;
GamepadChanges& operator=(const GamepadChanges&) = delete;

  ~GamepadChanges();

  // Clone() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Clone() or copy
  // constructor/assignment are available for members.
  template <typename StructPtrType = GamepadChangesPtr>
  GamepadChangesPtr Clone() const;

  // Equals() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Equals() or == operator
  // are available for members.
  template <typename T, GamepadChanges::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, GamepadChanges::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, GamepadChanges::EnableIfSame<T>* = nullptr>
  bool operator!=(const T& rhs) const { return !operator==(rhs); }
  template <typename UserType>
  static WTF::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        GamepadChanges::DataView, WTF::Vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        GamepadChanges::DataView>(input);
  }

  // The returned Message is serialized only if the message is moved
  // cross-process or cross-language. Otherwise if the message is Deserialized
  // as the same UserType |input| will just be moved to |output| in
  // DeserializeFromMessage.
  template <typename UserType>
  static mojo::Message WrapAsMessage(UserType input) {
    return mojo::Message(std::make_unique<
        internal::GamepadChanges_UnserializedMessageContext<
            UserType, GamepadChanges::DataView>>(0, 0, std::move(input)),
        MOJO_CREATE_MESSAGE_FLAG_NONE);
  }

  template <typename UserType>
  static bool Deserialize(const void* data,
                          size_t data_num_bytes,
                          UserType* output) {
    mojo::Message message;
    return mojo::internal::DeserializeImpl<GamepadChanges::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(const WTF::Vector<uint8_t>& input,
                          UserType* output) {
    return GamepadChanges::Deserialize(
        input.size() == 0 ? nullptr : &input.front(), input.size(), output);
  }

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    auto context = input.TakeUnserializedContext<
        internal::GamepadChanges_UnserializedMessageContext<
            UserType, GamepadChanges::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<GamepadChanges::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
// @generated_from: device.mojom.GamepadChanges.gamepad_index
  uint32_t gamepad_index;
  
// @generated_from: device.mojom.GamepadChanges.button_changes
  WTF::Vector<ButtonChangePtr> button_changes;
  
// @generated_from: device.mojom.GamepadChanges.axis_changes
  WTF::Vector<AxisChangePtr> axis_changes;
  
// @generated_from: device.mojom.GamepadChanges.timestamp
  int64_t timestamp;

  // Serialise this struct into a trace.
  void WriteIntoTrace(perfetto::TracedValue traced_context) const;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
};

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, GamepadChanges::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, GamepadChanges::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {
  return !(rhs < lhs);
}

template <typename T, GamepadChanges::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
  return rhs < lhs;
}

template <typename T, GamepadChanges::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
  return !(lhs < rhs);
}





// @generated_from: device.mojom.GamepadTouch
class COMPONENT_EXPORT(GAMEPAD_MOJOM_BLINK) GamepadTouch {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<GamepadTouch, T>::value>;
  using DataView = GamepadTouchDataView;
  using Data_ = internal::GamepadTouch_Data;

  template <typename... Args>
  static GamepadTouchPtr New(Args&&... args) {
    return GamepadTouchPtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static GamepadTouchPtr From(const U& u) {
    return mojo::TypeConverter<GamepadTouchPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, GamepadTouch>::Convert(*this);
  }


  GamepadTouch();

  GamepadTouch(
      uint32_t touch_id,
      uint8_t surface_id,
      double x,
      double y,
      uint32_t surface_height,
      uint32_t surface_width,
      bool has_surface_dimensions);


  ~GamepadTouch();

  // Clone() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Clone() or copy
  // constructor/assignment are available for members.
  template <typename StructPtrType = GamepadTouchPtr>
  GamepadTouchPtr Clone() const;

  // Equals() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Equals() or == operator
  // are available for members.
  template <typename T, GamepadTouch::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, GamepadTouch::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, GamepadTouch::EnableIfSame<T>* = nullptr>
  bool operator!=(const T& rhs) const { return !operator==(rhs); }
  template <typename UserType>
  static WTF::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        GamepadTouch::DataView, WTF::Vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        GamepadTouch::DataView>(input);
  }

  // The returned Message is serialized only if the message is moved
  // cross-process or cross-language. Otherwise if the message is Deserialized
  // as the same UserType |input| will just be moved to |output| in
  // DeserializeFromMessage.
  template <typename UserType>
  static mojo::Message WrapAsMessage(UserType input) {
    return mojo::Message(std::make_unique<
        internal::GamepadTouch_UnserializedMessageContext<
            UserType, GamepadTouch::DataView>>(0, 0, std::move(input)),
        MOJO_CREATE_MESSAGE_FLAG_NONE);
  }

  template <typename UserType>
  static bool Deserialize(const void* data,
                          size_t data_num_bytes,
                          UserType* output) {
    mojo::Message message;
    return mojo::internal::DeserializeImpl<GamepadTouch::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(const WTF::Vector<uint8_t>& input,
                          UserType* output) {
    return GamepadTouch::Deserialize(
        input.size() == 0 ? nullptr : &input.front(), input.size(), output);
  }

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    auto context = input.TakeUnserializedContext<
        internal::GamepadTouch_UnserializedMessageContext<
            UserType, GamepadTouch::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<GamepadTouch::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
// @generated_from: device.mojom.GamepadTouch.touch_id
  uint32_t touch_id;
  
// @generated_from: device.mojom.GamepadTouch.surface_id
  uint8_t surface_id;
  
// @generated_from: device.mojom.GamepadTouch.x
  double x;
  
// @generated_from: device.mojom.GamepadTouch.y
  double y;
  
// @generated_from: device.mojom.GamepadTouch.surface_height
  uint32_t surface_height;
  
// @generated_from: device.mojom.GamepadTouch.surface_width
  uint32_t surface_width;
  
// @generated_from: device.mojom.GamepadTouch.has_surface_dimensions
  bool has_surface_dimensions;

  // Serialise this struct into a trace.
  void WriteIntoTrace(perfetto::TracedValue traced_context) const;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
};

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, GamepadTouch::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, GamepadTouch::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {
  return !(rhs < lhs);
}

template <typename T, GamepadTouch::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
  return rhs < lhs;
}

template <typename T, GamepadTouch::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
  return !(lhs < rhs);
}





// @generated_from: device.mojom.GamepadPose
class COMPONENT_EXPORT(GAMEPAD_MOJOM_BLINK) GamepadPose {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<GamepadPose, T>::value>;
  using DataView = GamepadPoseDataView;
  using Data_ = internal::GamepadPose_Data;

  template <typename... Args>
  static GamepadPosePtr New(Args&&... args) {
    return GamepadPosePtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static GamepadPosePtr From(const U& u) {
    return mojo::TypeConverter<GamepadPosePtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, GamepadPose>::Convert(*this);
  }


  GamepadPose();

  GamepadPose(
      const ::device::GamepadQuaternion& orientation,
      const ::device::GamepadVector& position,
      const ::device::GamepadVector& angular_velocity,
      const ::device::GamepadVector& linear_velocity,
      const ::device::GamepadVector& angular_acceleration,
      const ::device::GamepadVector& linear_acceleration);


  ~GamepadPose();

  // Clone() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Clone() or copy
  // constructor/assignment are available for members.
  template <typename StructPtrType = GamepadPosePtr>
  GamepadPosePtr Clone() const;

  // Equals() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Equals() or == operator
  // are available for members.
  template <typename T, GamepadPose::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, GamepadPose::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, GamepadPose::EnableIfSame<T>* = nullptr>
  bool operator!=(const T& rhs) const { return !operator==(rhs); }
  template <typename UserType>
  static WTF::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        GamepadPose::DataView, WTF::Vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        GamepadPose::DataView>(input);
  }

  // The returned Message is serialized only if the message is moved
  // cross-process or cross-language. Otherwise if the message is Deserialized
  // as the same UserType |input| will just be moved to |output| in
  // DeserializeFromMessage.
  template <typename UserType>
  static mojo::Message WrapAsMessage(UserType input) {
    return mojo::Message(std::make_unique<
        internal::GamepadPose_UnserializedMessageContext<
            UserType, GamepadPose::DataView>>(0, 0, std::move(input)),
        MOJO_CREATE_MESSAGE_FLAG_NONE);
  }

  template <typename UserType>
  static bool Deserialize(const void* data,
                          size_t data_num_bytes,
                          UserType* output) {
    mojo::Message message;
    return mojo::internal::DeserializeImpl<GamepadPose::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(const WTF::Vector<uint8_t>& input,
                          UserType* output) {
    return GamepadPose::Deserialize(
        input.size() == 0 ? nullptr : &input.front(), input.size(), output);
  }

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    auto context = input.TakeUnserializedContext<
        internal::GamepadPose_UnserializedMessageContext<
            UserType, GamepadPose::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<GamepadPose::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
// @generated_from: device.mojom.GamepadPose.orientation
  ::device::GamepadQuaternion orientation;
  
// @generated_from: device.mojom.GamepadPose.position
  ::device::GamepadVector position;
  
// @generated_from: device.mojom.GamepadPose.angular_velocity
  ::device::GamepadVector angular_velocity;
  
// @generated_from: device.mojom.GamepadPose.linear_velocity
  ::device::GamepadVector linear_velocity;
  
// @generated_from: device.mojom.GamepadPose.angular_acceleration
  ::device::GamepadVector angular_acceleration;
  
// @generated_from: device.mojom.GamepadPose.linear_acceleration
  ::device::GamepadVector linear_acceleration;

  // Serialise this struct into a trace.
  void WriteIntoTrace(perfetto::TracedValue traced_context) const;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
};

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, GamepadPose::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, GamepadPose::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {
  return !(rhs < lhs);
}

template <typename T, GamepadPose::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
  return rhs < lhs;
}

template <typename T, GamepadPose::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
  return !(lhs < rhs);
}






// @generated_from: device.mojom.Gamepad
class COMPONENT_EXPORT(GAMEPAD_MOJOM_BLINK) Gamepad {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<Gamepad, T>::value>;
  using DataView = GamepadDataView;
  using Data_ = internal::Gamepad_Data;

  template <typename... Args>
  static GamepadPtr New(Args&&... args) {
    return GamepadPtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static GamepadPtr From(const U& u) {
    return mojo::TypeConverter<GamepadPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, Gamepad>::Convert(*this);
  }


  Gamepad();

  Gamepad(
      bool connected,
      WTF::Vector<uint16_t> id,
      int64_t timestamp,
      WTF::Vector<double> axes,
      WTF::Vector<::device::GamepadButton> buttons,
      const ::device::GamepadHapticActuator& vibration_actuator,
      ::device::GamepadMapping mapping,
      const ::device::GamepadPose& pose,
      ::device::GamepadHand hand,
      WTF::Vector<::device::GamepadTouch> touch_events,
      uint32_t display_id);


  ~Gamepad();

  // Clone() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Clone() or copy
  // constructor/assignment are available for members.
  template <typename StructPtrType = GamepadPtr>
  GamepadPtr Clone() const;

  // Equals() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Equals() or == operator
  // are available for members.
  template <typename T, Gamepad::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, Gamepad::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, Gamepad::EnableIfSame<T>* = nullptr>
  bool operator!=(const T& rhs) const { return !operator==(rhs); }
  template <typename UserType>
  static WTF::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        Gamepad::DataView, WTF::Vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        Gamepad::DataView>(input);
  }

  // The returned Message is serialized only if the message is moved
  // cross-process or cross-language. Otherwise if the message is Deserialized
  // as the same UserType |input| will just be moved to |output| in
  // DeserializeFromMessage.
  template <typename UserType>
  static mojo::Message WrapAsMessage(UserType input) {
    return mojo::Message(std::make_unique<
        internal::Gamepad_UnserializedMessageContext<
            UserType, Gamepad::DataView>>(0, 0, std::move(input)),
        MOJO_CREATE_MESSAGE_FLAG_NONE);
  }

  template <typename UserType>
  static bool Deserialize(const void* data,
                          size_t data_num_bytes,
                          UserType* output) {
    mojo::Message message;
    return mojo::internal::DeserializeImpl<Gamepad::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(const WTF::Vector<uint8_t>& input,
                          UserType* output) {
    return Gamepad::Deserialize(
        input.size() == 0 ? nullptr : &input.front(), input.size(), output);
  }

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    auto context = input.TakeUnserializedContext<
        internal::Gamepad_UnserializedMessageContext<
            UserType, Gamepad::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<Gamepad::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
// @generated_from: device.mojom.Gamepad.connected
  bool connected;
  
// @generated_from: device.mojom.Gamepad.id
  WTF::Vector<uint16_t> id;
  
// @generated_from: device.mojom.Gamepad.timestamp
  int64_t timestamp;
  
// @generated_from: device.mojom.Gamepad.axes
  WTF::Vector<double> axes;
  
// @generated_from: device.mojom.Gamepad.buttons
  WTF::Vector<::device::GamepadButton> buttons;
  
// @generated_from: device.mojom.Gamepad.vibration_actuator
  ::device::GamepadHapticActuator vibration_actuator;
  
// @generated_from: device.mojom.Gamepad.mapping
  ::device::GamepadMapping mapping;
  
// @generated_from: device.mojom.Gamepad.pose
  ::device::GamepadPose pose;
  
// @generated_from: device.mojom.Gamepad.hand
  ::device::GamepadHand hand;
  
// @generated_from: device.mojom.Gamepad.touch_events
  WTF::Vector<::device::GamepadTouch> touch_events;
  
// @generated_from: device.mojom.Gamepad.display_id
  uint32_t display_id;

  // Serialise this struct into a trace.
  void WriteIntoTrace(perfetto::TracedValue traced_context) const;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
};

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, Gamepad::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, Gamepad::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {
  return !(rhs < lhs);
}

template <typename T, Gamepad::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
  return rhs < lhs;
}

template <typename T, Gamepad::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
  return !(lhs < rhs);
}





// @generated_from: device.mojom.GamepadEffectParameters
class COMPONENT_EXPORT(GAMEPAD_MOJOM_BLINK) GamepadEffectParameters {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<GamepadEffectParameters, T>::value>;
  using DataView = GamepadEffectParametersDataView;
  using Data_ = internal::GamepadEffectParameters_Data;

  template <typename... Args>
  static GamepadEffectParametersPtr New(Args&&... args) {
    return GamepadEffectParametersPtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static GamepadEffectParametersPtr From(const U& u) {
    return mojo::TypeConverter<GamepadEffectParametersPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, GamepadEffectParameters>::Convert(*this);
  }


  GamepadEffectParameters();

  GamepadEffectParameters(
      double duration,
      double start_delay,
      double strong_magnitude,
      double weak_magnitude,
      double left_trigger,
      double right_trigger);


  ~GamepadEffectParameters();

  // Clone() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Clone() or copy
  // constructor/assignment are available for members.
  template <typename StructPtrType = GamepadEffectParametersPtr>
  GamepadEffectParametersPtr Clone() const;

  // Equals() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Equals() or == operator
  // are available for members.
  template <typename T, GamepadEffectParameters::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, GamepadEffectParameters::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, GamepadEffectParameters::EnableIfSame<T>* = nullptr>
  bool operator!=(const T& rhs) const { return !operator==(rhs); }
  size_t Hash(size_t seed) const;
  template <typename UserType>
  static WTF::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        GamepadEffectParameters::DataView, WTF::Vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        GamepadEffectParameters::DataView>(input);
  }

  // The returned Message is serialized only if the message is moved
  // cross-process or cross-language. Otherwise if the message is Deserialized
  // as the same UserType |input| will just be moved to |output| in
  // DeserializeFromMessage.
  template <typename UserType>
  static mojo::Message WrapAsMessage(UserType input) {
    return mojo::Message(std::make_unique<
        internal::GamepadEffectParameters_UnserializedMessageContext<
            UserType, GamepadEffectParameters::DataView>>(0, 0, std::move(input)),
        MOJO_CREATE_MESSAGE_FLAG_NONE);
  }

  template <typename UserType>
  static bool Deserialize(const void* data,
                          size_t data_num_bytes,
                          UserType* output) {
    mojo::Message message;
    return mojo::internal::DeserializeImpl<GamepadEffectParameters::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(const WTF::Vector<uint8_t>& input,
                          UserType* output) {
    return GamepadEffectParameters::Deserialize(
        input.size() == 0 ? nullptr : &input.front(), input.size(), output);
  }

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    auto context = input.TakeUnserializedContext<
        internal::GamepadEffectParameters_UnserializedMessageContext<
            UserType, GamepadEffectParameters::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<GamepadEffectParameters::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
// @generated_from: device.mojom.GamepadEffectParameters.duration
  double duration;
  
// @generated_from: device.mojom.GamepadEffectParameters.start_delay
  double start_delay;
  
// @generated_from: device.mojom.GamepadEffectParameters.strong_magnitude
  double strong_magnitude;
  
// @generated_from: device.mojom.GamepadEffectParameters.weak_magnitude
  double weak_magnitude;
  
// @generated_from: device.mojom.GamepadEffectParameters.left_trigger
  double left_trigger;
  
// @generated_from: device.mojom.GamepadEffectParameters.right_trigger
  double right_trigger;

  // Serialise this struct into a trace.
  void WriteIntoTrace(perfetto::TracedValue traced_context) const;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
};

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, GamepadEffectParameters::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, GamepadEffectParameters::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {
  return !(rhs < lhs);
}

template <typename T, GamepadEffectParameters::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
  return rhs < lhs;
}

template <typename T, GamepadEffectParameters::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
  return !(lhs < rhs);
}

template <typename StructPtrType>
GamepadQuaternionPtr GamepadQuaternion::Clone() const {
  return New(
      mojo::Clone(x),
      mojo::Clone(y),
      mojo::Clone(z),
      mojo::Clone(w)
  );
}

template <typename T, GamepadQuaternion::EnableIfSame<T>*>
bool GamepadQuaternion::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->x, other_struct.x))
    return false;
  if (!mojo::Equals(this->y, other_struct.y))
    return false;
  if (!mojo::Equals(this->z, other_struct.z))
    return false;
  if (!mojo::Equals(this->w, other_struct.w))
    return false;
  return true;
}

template <typename T, GamepadQuaternion::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.x < rhs.x)
    return true;
  if (rhs.x < lhs.x)
    return false;
  if (lhs.y < rhs.y)
    return true;
  if (rhs.y < lhs.y)
    return false;
  if (lhs.z < rhs.z)
    return true;
  if (rhs.z < lhs.z)
    return false;
  if (lhs.w < rhs.w)
    return true;
  if (rhs.w < lhs.w)
    return false;
  return false;
}
template <typename StructPtrType>
GamepadVectorPtr GamepadVector::Clone() const {
  return New(
      mojo::Clone(x),
      mojo::Clone(y),
      mojo::Clone(z)
  );
}

template <typename T, GamepadVector::EnableIfSame<T>*>
bool GamepadVector::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->x, other_struct.x))
    return false;
  if (!mojo::Equals(this->y, other_struct.y))
    return false;
  if (!mojo::Equals(this->z, other_struct.z))
    return false;
  return true;
}

template <typename T, GamepadVector::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.x < rhs.x)
    return true;
  if (rhs.x < lhs.x)
    return false;
  if (lhs.y < rhs.y)
    return true;
  if (rhs.y < lhs.y)
    return false;
  if (lhs.z < rhs.z)
    return true;
  if (rhs.z < lhs.z)
    return false;
  return false;
}
template <typename StructPtrType>
GamepadButtonPtr GamepadButton::Clone() const {
  return New(
      mojo::Clone(pressed),
      mojo::Clone(touched),
      mojo::Clone(value)
  );
}

template <typename T, GamepadButton::EnableIfSame<T>*>
bool GamepadButton::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->pressed, other_struct.pressed))
    return false;
  if (!mojo::Equals(this->touched, other_struct.touched))
    return false;
  if (!mojo::Equals(this->value, other_struct.value))
    return false;
  return true;
}

template <typename T, GamepadButton::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.pressed < rhs.pressed)
    return true;
  if (rhs.pressed < lhs.pressed)
    return false;
  if (lhs.touched < rhs.touched)
    return true;
  if (rhs.touched < lhs.touched)
    return false;
  if (lhs.value < rhs.value)
    return true;
  if (rhs.value < lhs.value)
    return false;
  return false;
}
template <typename StructPtrType>
ButtonChangePtr ButtonChange::Clone() const {
  return New(
      mojo::Clone(button_index),
      mojo::Clone(button_down),
      mojo::Clone(button_up),
      mojo::Clone(value_changed),
      mojo::Clone(button_snapshot)
  );
}

template <typename T, ButtonChange::EnableIfSame<T>*>
bool ButtonChange::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->button_index, other_struct.button_index))
    return false;
  if (!mojo::Equals(this->button_down, other_struct.button_down))
    return false;
  if (!mojo::Equals(this->button_up, other_struct.button_up))
    return false;
  if (!mojo::Equals(this->value_changed, other_struct.value_changed))
    return false;
  if (!mojo::Equals(this->button_snapshot, other_struct.button_snapshot))
    return false;
  return true;
}

template <typename T, ButtonChange::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.button_index < rhs.button_index)
    return true;
  if (rhs.button_index < lhs.button_index)
    return false;
  if (lhs.button_down < rhs.button_down)
    return true;
  if (rhs.button_down < lhs.button_down)
    return false;
  if (lhs.button_up < rhs.button_up)
    return true;
  if (rhs.button_up < lhs.button_up)
    return false;
  if (lhs.value_changed < rhs.value_changed)
    return true;
  if (rhs.value_changed < lhs.value_changed)
    return false;
  if (lhs.button_snapshot < rhs.button_snapshot)
    return true;
  if (rhs.button_snapshot < lhs.button_snapshot)
    return false;
  return false;
}
template <typename StructPtrType>
AxisChangePtr AxisChange::Clone() const {
  return New(
      mojo::Clone(axis_index),
      mojo::Clone(axis_snapshot)
  );
}

template <typename T, AxisChange::EnableIfSame<T>*>
bool AxisChange::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->axis_index, other_struct.axis_index))
    return false;
  if (!mojo::Equals(this->axis_snapshot, other_struct.axis_snapshot))
    return false;
  return true;
}

template <typename T, AxisChange::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.axis_index < rhs.axis_index)
    return true;
  if (rhs.axis_index < lhs.axis_index)
    return false;
  if (lhs.axis_snapshot < rhs.axis_snapshot)
    return true;
  if (rhs.axis_snapshot < lhs.axis_snapshot)
    return false;
  return false;
}
template <typename StructPtrType>
GamepadChangesPtr GamepadChanges::Clone() const {
  return New(
      mojo::Clone(gamepad_index),
      mojo::Clone(button_changes),
      mojo::Clone(axis_changes),
      mojo::Clone(timestamp)
  );
}

template <typename T, GamepadChanges::EnableIfSame<T>*>
bool GamepadChanges::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->gamepad_index, other_struct.gamepad_index))
    return false;
  if (!mojo::Equals(this->button_changes, other_struct.button_changes))
    return false;
  if (!mojo::Equals(this->axis_changes, other_struct.axis_changes))
    return false;
  if (!mojo::Equals(this->timestamp, other_struct.timestamp))
    return false;
  return true;
}

template <typename T, GamepadChanges::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.gamepad_index < rhs.gamepad_index)
    return true;
  if (rhs.gamepad_index < lhs.gamepad_index)
    return false;
  if (lhs.button_changes < rhs.button_changes)
    return true;
  if (rhs.button_changes < lhs.button_changes)
    return false;
  if (lhs.axis_changes < rhs.axis_changes)
    return true;
  if (rhs.axis_changes < lhs.axis_changes)
    return false;
  if (lhs.timestamp < rhs.timestamp)
    return true;
  if (rhs.timestamp < lhs.timestamp)
    return false;
  return false;
}
template <typename StructPtrType>
GamepadTouchPtr GamepadTouch::Clone() const {
  return New(
      mojo::Clone(touch_id),
      mojo::Clone(surface_id),
      mojo::Clone(x),
      mojo::Clone(y),
      mojo::Clone(surface_height),
      mojo::Clone(surface_width),
      mojo::Clone(has_surface_dimensions)
  );
}

template <typename T, GamepadTouch::EnableIfSame<T>*>
bool GamepadTouch::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->touch_id, other_struct.touch_id))
    return false;
  if (!mojo::Equals(this->surface_id, other_struct.surface_id))
    return false;
  if (!mojo::Equals(this->x, other_struct.x))
    return false;
  if (!mojo::Equals(this->y, other_struct.y))
    return false;
  if (!mojo::Equals(this->surface_height, other_struct.surface_height))
    return false;
  if (!mojo::Equals(this->surface_width, other_struct.surface_width))
    return false;
  if (!mojo::Equals(this->has_surface_dimensions, other_struct.has_surface_dimensions))
    return false;
  return true;
}

template <typename T, GamepadTouch::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.touch_id < rhs.touch_id)
    return true;
  if (rhs.touch_id < lhs.touch_id)
    return false;
  if (lhs.surface_id < rhs.surface_id)
    return true;
  if (rhs.surface_id < lhs.surface_id)
    return false;
  if (lhs.x < rhs.x)
    return true;
  if (rhs.x < lhs.x)
    return false;
  if (lhs.y < rhs.y)
    return true;
  if (rhs.y < lhs.y)
    return false;
  if (lhs.surface_height < rhs.surface_height)
    return true;
  if (rhs.surface_height < lhs.surface_height)
    return false;
  if (lhs.surface_width < rhs.surface_width)
    return true;
  if (rhs.surface_width < lhs.surface_width)
    return false;
  if (lhs.has_surface_dimensions < rhs.has_surface_dimensions)
    return true;
  if (rhs.has_surface_dimensions < lhs.has_surface_dimensions)
    return false;
  return false;
}
template <typename StructPtrType>
GamepadPosePtr GamepadPose::Clone() const {
  return New(
      mojo::Clone(orientation),
      mojo::Clone(position),
      mojo::Clone(angular_velocity),
      mojo::Clone(linear_velocity),
      mojo::Clone(angular_acceleration),
      mojo::Clone(linear_acceleration)
  );
}

template <typename T, GamepadPose::EnableIfSame<T>*>
bool GamepadPose::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->orientation, other_struct.orientation))
    return false;
  if (!mojo::Equals(this->position, other_struct.position))
    return false;
  if (!mojo::Equals(this->angular_velocity, other_struct.angular_velocity))
    return false;
  if (!mojo::Equals(this->linear_velocity, other_struct.linear_velocity))
    return false;
  if (!mojo::Equals(this->angular_acceleration, other_struct.angular_acceleration))
    return false;
  if (!mojo::Equals(this->linear_acceleration, other_struct.linear_acceleration))
    return false;
  return true;
}

template <typename T, GamepadPose::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.orientation < rhs.orientation)
    return true;
  if (rhs.orientation < lhs.orientation)
    return false;
  if (lhs.position < rhs.position)
    return true;
  if (rhs.position < lhs.position)
    return false;
  if (lhs.angular_velocity < rhs.angular_velocity)
    return true;
  if (rhs.angular_velocity < lhs.angular_velocity)
    return false;
  if (lhs.linear_velocity < rhs.linear_velocity)
    return true;
  if (rhs.linear_velocity < lhs.linear_velocity)
    return false;
  if (lhs.angular_acceleration < rhs.angular_acceleration)
    return true;
  if (rhs.angular_acceleration < lhs.angular_acceleration)
    return false;
  if (lhs.linear_acceleration < rhs.linear_acceleration)
    return true;
  if (rhs.linear_acceleration < lhs.linear_acceleration)
    return false;
  return false;
}
template <typename StructPtrType>
GamepadHapticActuatorPtr GamepadHapticActuator::Clone() const {
  return New(
      mojo::Clone(type)
  );
}

template <typename T, GamepadHapticActuator::EnableIfSame<T>*>
bool GamepadHapticActuator::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->type, other_struct.type))
    return false;
  return true;
}

template <typename T, GamepadHapticActuator::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.type < rhs.type)
    return true;
  if (rhs.type < lhs.type)
    return false;
  return false;
}
template <typename StructPtrType>
GamepadPtr Gamepad::Clone() const {
  return New(
      mojo::Clone(connected),
      mojo::Clone(id),
      mojo::Clone(timestamp),
      mojo::Clone(axes),
      mojo::Clone(buttons),
      mojo::Clone(vibration_actuator),
      mojo::Clone(mapping),
      mojo::Clone(pose),
      mojo::Clone(hand),
      mojo::Clone(touch_events),
      mojo::Clone(display_id)
  );
}

template <typename T, Gamepad::EnableIfSame<T>*>
bool Gamepad::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->connected, other_struct.connected))
    return false;
  if (!mojo::Equals(this->id, other_struct.id))
    return false;
  if (!mojo::Equals(this->timestamp, other_struct.timestamp))
    return false;
  if (!mojo::Equals(this->axes, other_struct.axes))
    return false;
  if (!mojo::Equals(this->buttons, other_struct.buttons))
    return false;
  if (!mojo::Equals(this->vibration_actuator, other_struct.vibration_actuator))
    return false;
  if (!mojo::Equals(this->mapping, other_struct.mapping))
    return false;
  if (!mojo::Equals(this->pose, other_struct.pose))
    return false;
  if (!mojo::Equals(this->hand, other_struct.hand))
    return false;
  if (!mojo::Equals(this->touch_events, other_struct.touch_events))
    return false;
  if (!mojo::Equals(this->display_id, other_struct.display_id))
    return false;
  return true;
}

template <typename T, Gamepad::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.connected < rhs.connected)
    return true;
  if (rhs.connected < lhs.connected)
    return false;
  if (lhs.id < rhs.id)
    return true;
  if (rhs.id < lhs.id)
    return false;
  if (lhs.timestamp < rhs.timestamp)
    return true;
  if (rhs.timestamp < lhs.timestamp)
    return false;
  if (lhs.axes < rhs.axes)
    return true;
  if (rhs.axes < lhs.axes)
    return false;
  if (lhs.buttons < rhs.buttons)
    return true;
  if (rhs.buttons < lhs.buttons)
    return false;
  if (lhs.vibration_actuator < rhs.vibration_actuator)
    return true;
  if (rhs.vibration_actuator < lhs.vibration_actuator)
    return false;
  if (lhs.mapping < rhs.mapping)
    return true;
  if (rhs.mapping < lhs.mapping)
    return false;
  if (lhs.pose < rhs.pose)
    return true;
  if (rhs.pose < lhs.pose)
    return false;
  if (lhs.hand < rhs.hand)
    return true;
  if (rhs.hand < lhs.hand)
    return false;
  if (lhs.touch_events < rhs.touch_events)
    return true;
  if (rhs.touch_events < lhs.touch_events)
    return false;
  if (lhs.display_id < rhs.display_id)
    return true;
  if (rhs.display_id < lhs.display_id)
    return false;
  return false;
}
template <typename StructPtrType>
GamepadEffectParametersPtr GamepadEffectParameters::Clone() const {
  return New(
      mojo::Clone(duration),
      mojo::Clone(start_delay),
      mojo::Clone(strong_magnitude),
      mojo::Clone(weak_magnitude),
      mojo::Clone(left_trigger),
      mojo::Clone(right_trigger)
  );
}

template <typename T, GamepadEffectParameters::EnableIfSame<T>*>
bool GamepadEffectParameters::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->duration, other_struct.duration))
    return false;
  if (!mojo::Equals(this->start_delay, other_struct.start_delay))
    return false;
  if (!mojo::Equals(this->strong_magnitude, other_struct.strong_magnitude))
    return false;
  if (!mojo::Equals(this->weak_magnitude, other_struct.weak_magnitude))
    return false;
  if (!mojo::Equals(this->left_trigger, other_struct.left_trigger))
    return false;
  if (!mojo::Equals(this->right_trigger, other_struct.right_trigger))
    return false;
  return true;
}

template <typename T, GamepadEffectParameters::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.duration < rhs.duration)
    return true;
  if (rhs.duration < lhs.duration)
    return false;
  if (lhs.start_delay < rhs.start_delay)
    return true;
  if (rhs.start_delay < lhs.start_delay)
    return false;
  if (lhs.strong_magnitude < rhs.strong_magnitude)
    return true;
  if (rhs.strong_magnitude < lhs.strong_magnitude)
    return false;
  if (lhs.weak_magnitude < rhs.weak_magnitude)
    return true;
  if (rhs.weak_magnitude < lhs.weak_magnitude)
    return false;
  if (lhs.left_trigger < rhs.left_trigger)
    return true;
  if (rhs.left_trigger < lhs.left_trigger)
    return false;
  if (lhs.right_trigger < rhs.right_trigger)
    return true;
  if (rhs.right_trigger < lhs.right_trigger)
    return false;
  return false;
}


}  // device::mojom::blink

namespace mojo {


template <>
struct COMPONENT_EXPORT(GAMEPAD_MOJOM_BLINK) StructTraits<::device::mojom::blink::GamepadQuaternion::DataView,
                                         ::device::mojom::blink::GamepadQuaternionPtr> {
  static bool IsNull(const ::device::mojom::blink::GamepadQuaternionPtr& input) { return !input; }
  static void SetToNull(::device::mojom::blink::GamepadQuaternionPtr* output) { output->reset(); }

  static decltype(::device::mojom::blink::GamepadQuaternion::x) x(
      const ::device::mojom::blink::GamepadQuaternionPtr& input) {
    return input->x;
  }

  static decltype(::device::mojom::blink::GamepadQuaternion::y) y(
      const ::device::mojom::blink::GamepadQuaternionPtr& input) {
    return input->y;
  }

  static decltype(::device::mojom::blink::GamepadQuaternion::z) z(
      const ::device::mojom::blink::GamepadQuaternionPtr& input) {
    return input->z;
  }

  static decltype(::device::mojom::blink::GamepadQuaternion::w) w(
      const ::device::mojom::blink::GamepadQuaternionPtr& input) {
    return input->w;
  }

  static bool Read(::device::mojom::blink::GamepadQuaternion::DataView input, ::device::mojom::blink::GamepadQuaternionPtr* output);
};


template <>
struct COMPONENT_EXPORT(GAMEPAD_MOJOM_BLINK) StructTraits<::device::mojom::blink::GamepadVector::DataView,
                                         ::device::mojom::blink::GamepadVectorPtr> {
  static bool IsNull(const ::device::mojom::blink::GamepadVectorPtr& input) { return !input; }
  static void SetToNull(::device::mojom::blink::GamepadVectorPtr* output) { output->reset(); }

  static decltype(::device::mojom::blink::GamepadVector::x) x(
      const ::device::mojom::blink::GamepadVectorPtr& input) {
    return input->x;
  }

  static decltype(::device::mojom::blink::GamepadVector::y) y(
      const ::device::mojom::blink::GamepadVectorPtr& input) {
    return input->y;
  }

  static decltype(::device::mojom::blink::GamepadVector::z) z(
      const ::device::mojom::blink::GamepadVectorPtr& input) {
    return input->z;
  }

  static bool Read(::device::mojom::blink::GamepadVector::DataView input, ::device::mojom::blink::GamepadVectorPtr* output);
};


template <>
struct COMPONENT_EXPORT(GAMEPAD_MOJOM_BLINK) StructTraits<::device::mojom::blink::GamepadButton::DataView,
                                         ::device::mojom::blink::GamepadButtonPtr> {
  static bool IsNull(const ::device::mojom::blink::GamepadButtonPtr& input) { return !input; }
  static void SetToNull(::device::mojom::blink::GamepadButtonPtr* output) { output->reset(); }

  static decltype(::device::mojom::blink::GamepadButton::pressed) pressed(
      const ::device::mojom::blink::GamepadButtonPtr& input) {
    return input->pressed;
  }

  static decltype(::device::mojom::blink::GamepadButton::touched) touched(
      const ::device::mojom::blink::GamepadButtonPtr& input) {
    return input->touched;
  }

  static decltype(::device::mojom::blink::GamepadButton::value) value(
      const ::device::mojom::blink::GamepadButtonPtr& input) {
    return input->value;
  }

  static bool Read(::device::mojom::blink::GamepadButton::DataView input, ::device::mojom::blink::GamepadButtonPtr* output);
};


template <>
struct COMPONENT_EXPORT(GAMEPAD_MOJOM_BLINK) StructTraits<::device::mojom::blink::ButtonChange::DataView,
                                         ::device::mojom::blink::ButtonChangePtr> {
  static bool IsNull(const ::device::mojom::blink::ButtonChangePtr& input) { return !input; }
  static void SetToNull(::device::mojom::blink::ButtonChangePtr* output) { output->reset(); }

  static decltype(::device::mojom::blink::ButtonChange::button_index) button_index(
      const ::device::mojom::blink::ButtonChangePtr& input) {
    return input->button_index;
  }

  static decltype(::device::mojom::blink::ButtonChange::button_down) button_down(
      const ::device::mojom::blink::ButtonChangePtr& input) {
    return input->button_down;
  }

  static decltype(::device::mojom::blink::ButtonChange::button_up) button_up(
      const ::device::mojom::blink::ButtonChangePtr& input) {
    return input->button_up;
  }

  static decltype(::device::mojom::blink::ButtonChange::value_changed) value_changed(
      const ::device::mojom::blink::ButtonChangePtr& input) {
    return input->value_changed;
  }

  static const decltype(::device::mojom::blink::ButtonChange::button_snapshot)& button_snapshot(
      const ::device::mojom::blink::ButtonChangePtr& input) {
    return input->button_snapshot;
  }

  static bool Read(::device::mojom::blink::ButtonChange::DataView input, ::device::mojom::blink::ButtonChangePtr* output);
};


template <>
struct COMPONENT_EXPORT(GAMEPAD_MOJOM_BLINK) StructTraits<::device::mojom::blink::AxisChange::DataView,
                                         ::device::mojom::blink::AxisChangePtr> {
  static bool IsNull(const ::device::mojom::blink::AxisChangePtr& input) { return !input; }
  static void SetToNull(::device::mojom::blink::AxisChangePtr* output) { output->reset(); }

  static decltype(::device::mojom::blink::AxisChange::axis_index) axis_index(
      const ::device::mojom::blink::AxisChangePtr& input) {
    return input->axis_index;
  }

  static decltype(::device::mojom::blink::AxisChange::axis_snapshot) axis_snapshot(
      const ::device::mojom::blink::AxisChangePtr& input) {
    return input->axis_snapshot;
  }

  static bool Read(::device::mojom::blink::AxisChange::DataView input, ::device::mojom::blink::AxisChangePtr* output);
};


template <>
struct COMPONENT_EXPORT(GAMEPAD_MOJOM_BLINK) StructTraits<::device::mojom::blink::GamepadChanges::DataView,
                                         ::device::mojom::blink::GamepadChangesPtr> {
  static bool IsNull(const ::device::mojom::blink::GamepadChangesPtr& input) { return !input; }
  static void SetToNull(::device::mojom::blink::GamepadChangesPtr* output) { output->reset(); }

  static decltype(::device::mojom::blink::GamepadChanges::gamepad_index) gamepad_index(
      const ::device::mojom::blink::GamepadChangesPtr& input) {
    return input->gamepad_index;
  }

  static const decltype(::device::mojom::blink::GamepadChanges::button_changes)& button_changes(
      const ::device::mojom::blink::GamepadChangesPtr& input) {
    return input->button_changes;
  }

  static const decltype(::device::mojom::blink::GamepadChanges::axis_changes)& axis_changes(
      const ::device::mojom::blink::GamepadChangesPtr& input) {
    return input->axis_changes;
  }

  static decltype(::device::mojom::blink::GamepadChanges::timestamp) timestamp(
      const ::device::mojom::blink::GamepadChangesPtr& input) {
    return input->timestamp;
  }

  static bool Read(::device::mojom::blink::GamepadChanges::DataView input, ::device::mojom::blink::GamepadChangesPtr* output);
};


template <>
struct COMPONENT_EXPORT(GAMEPAD_MOJOM_BLINK) StructTraits<::device::mojom::blink::GamepadTouch::DataView,
                                         ::device::mojom::blink::GamepadTouchPtr> {
  static bool IsNull(const ::device::mojom::blink::GamepadTouchPtr& input) { return !input; }
  static void SetToNull(::device::mojom::blink::GamepadTouchPtr* output) { output->reset(); }

  static decltype(::device::mojom::blink::GamepadTouch::touch_id) touch_id(
      const ::device::mojom::blink::GamepadTouchPtr& input) {
    return input->touch_id;
  }

  static decltype(::device::mojom::blink::GamepadTouch::surface_id) surface_id(
      const ::device::mojom::blink::GamepadTouchPtr& input) {
    return input->surface_id;
  }

  static decltype(::device::mojom::blink::GamepadTouch::x) x(
      const ::device::mojom::blink::GamepadTouchPtr& input) {
    return input->x;
  }

  static decltype(::device::mojom::blink::GamepadTouch::y) y(
      const ::device::mojom::blink::GamepadTouchPtr& input) {
    return input->y;
  }

  static decltype(::device::mojom::blink::GamepadTouch::surface_height) surface_height(
      const ::device::mojom::blink::GamepadTouchPtr& input) {
    return input->surface_height;
  }

  static decltype(::device::mojom::blink::GamepadTouch::surface_width) surface_width(
      const ::device::mojom::blink::GamepadTouchPtr& input) {
    return input->surface_width;
  }

  static decltype(::device::mojom::blink::GamepadTouch::has_surface_dimensions) has_surface_dimensions(
      const ::device::mojom::blink::GamepadTouchPtr& input) {
    return input->has_surface_dimensions;
  }

  static bool Read(::device::mojom::blink::GamepadTouch::DataView input, ::device::mojom::blink::GamepadTouchPtr* output);
};


template <>
struct COMPONENT_EXPORT(GAMEPAD_MOJOM_BLINK) StructTraits<::device::mojom::blink::GamepadPose::DataView,
                                         ::device::mojom::blink::GamepadPosePtr> {
  static bool IsNull(const ::device::mojom::blink::GamepadPosePtr& input) { return !input; }
  static void SetToNull(::device::mojom::blink::GamepadPosePtr* output) { output->reset(); }

  static const decltype(::device::mojom::blink::GamepadPose::orientation)& orientation(
      const ::device::mojom::blink::GamepadPosePtr& input) {
    return input->orientation;
  }

  static const decltype(::device::mojom::blink::GamepadPose::position)& position(
      const ::device::mojom::blink::GamepadPosePtr& input) {
    return input->position;
  }

  static const decltype(::device::mojom::blink::GamepadPose::angular_velocity)& angular_velocity(
      const ::device::mojom::blink::GamepadPosePtr& input) {
    return input->angular_velocity;
  }

  static const decltype(::device::mojom::blink::GamepadPose::linear_velocity)& linear_velocity(
      const ::device::mojom::blink::GamepadPosePtr& input) {
    return input->linear_velocity;
  }

  static const decltype(::device::mojom::blink::GamepadPose::angular_acceleration)& angular_acceleration(
      const ::device::mojom::blink::GamepadPosePtr& input) {
    return input->angular_acceleration;
  }

  static const decltype(::device::mojom::blink::GamepadPose::linear_acceleration)& linear_acceleration(
      const ::device::mojom::blink::GamepadPosePtr& input) {
    return input->linear_acceleration;
  }

  static bool Read(::device::mojom::blink::GamepadPose::DataView input, ::device::mojom::blink::GamepadPosePtr* output);
};


template <>
struct COMPONENT_EXPORT(GAMEPAD_MOJOM_BLINK) StructTraits<::device::mojom::blink::GamepadHapticActuator::DataView,
                                         ::device::mojom::blink::GamepadHapticActuatorPtr> {
  static bool IsNull(const ::device::mojom::blink::GamepadHapticActuatorPtr& input) { return !input; }
  static void SetToNull(::device::mojom::blink::GamepadHapticActuatorPtr* output) { output->reset(); }

  static decltype(::device::mojom::blink::GamepadHapticActuator::type) type(
      const ::device::mojom::blink::GamepadHapticActuatorPtr& input) {
    return input->type;
  }

  static bool Read(::device::mojom::blink::GamepadHapticActuator::DataView input, ::device::mojom::blink::GamepadHapticActuatorPtr* output);
};


template <>
struct COMPONENT_EXPORT(GAMEPAD_MOJOM_BLINK) StructTraits<::device::mojom::blink::Gamepad::DataView,
                                         ::device::mojom::blink::GamepadPtr> {
  static bool IsNull(const ::device::mojom::blink::GamepadPtr& input) { return !input; }
  static void SetToNull(::device::mojom::blink::GamepadPtr* output) { output->reset(); }

  static decltype(::device::mojom::blink::Gamepad::connected) connected(
      const ::device::mojom::blink::GamepadPtr& input) {
    return input->connected;
  }

  static const decltype(::device::mojom::blink::Gamepad::id)& id(
      const ::device::mojom::blink::GamepadPtr& input) {
    return input->id;
  }

  static decltype(::device::mojom::blink::Gamepad::timestamp) timestamp(
      const ::device::mojom::blink::GamepadPtr& input) {
    return input->timestamp;
  }

  static const decltype(::device::mojom::blink::Gamepad::axes)& axes(
      const ::device::mojom::blink::GamepadPtr& input) {
    return input->axes;
  }

  static const decltype(::device::mojom::blink::Gamepad::buttons)& buttons(
      const ::device::mojom::blink::GamepadPtr& input) {
    return input->buttons;
  }

  static const decltype(::device::mojom::blink::Gamepad::vibration_actuator)& vibration_actuator(
      const ::device::mojom::blink::GamepadPtr& input) {
    return input->vibration_actuator;
  }

  static decltype(::device::mojom::blink::Gamepad::mapping) mapping(
      const ::device::mojom::blink::GamepadPtr& input) {
    return input->mapping;
  }

  static const decltype(::device::mojom::blink::Gamepad::pose)& pose(
      const ::device::mojom::blink::GamepadPtr& input) {
    return input->pose;
  }

  static decltype(::device::mojom::blink::Gamepad::hand) hand(
      const ::device::mojom::blink::GamepadPtr& input) {
    return input->hand;
  }

  static const decltype(::device::mojom::blink::Gamepad::touch_events)& touch_events(
      const ::device::mojom::blink::GamepadPtr& input) {
    return input->touch_events;
  }

  static decltype(::device::mojom::blink::Gamepad::display_id) display_id(
      const ::device::mojom::blink::GamepadPtr& input) {
    return input->display_id;
  }

  static bool Read(::device::mojom::blink::Gamepad::DataView input, ::device::mojom::blink::GamepadPtr* output);
};


template <>
struct COMPONENT_EXPORT(GAMEPAD_MOJOM_BLINK) StructTraits<::device::mojom::blink::GamepadEffectParameters::DataView,
                                         ::device::mojom::blink::GamepadEffectParametersPtr> {
  static bool IsNull(const ::device::mojom::blink::GamepadEffectParametersPtr& input) { return !input; }
  static void SetToNull(::device::mojom::blink::GamepadEffectParametersPtr* output) { output->reset(); }

  static decltype(::device::mojom::blink::GamepadEffectParameters::duration) duration(
      const ::device::mojom::blink::GamepadEffectParametersPtr& input) {
    return input->duration;
  }

  static decltype(::device::mojom::blink::GamepadEffectParameters::start_delay) start_delay(
      const ::device::mojom::blink::GamepadEffectParametersPtr& input) {
    return input->start_delay;
  }

  static decltype(::device::mojom::blink::GamepadEffectParameters::strong_magnitude) strong_magnitude(
      const ::device::mojom::blink::GamepadEffectParametersPtr& input) {
    return input->strong_magnitude;
  }

  static decltype(::device::mojom::blink::GamepadEffectParameters::weak_magnitude) weak_magnitude(
      const ::device::mojom::blink::GamepadEffectParametersPtr& input) {
    return input->weak_magnitude;
  }

  static decltype(::device::mojom::blink::GamepadEffectParameters::left_trigger) left_trigger(
      const ::device::mojom::blink::GamepadEffectParametersPtr& input) {
    return input->left_trigger;
  }

  static decltype(::device::mojom::blink::GamepadEffectParameters::right_trigger) right_trigger(
      const ::device::mojom::blink::GamepadEffectParametersPtr& input) {
    return input->right_trigger;
  }

  static bool Read(::device::mojom::blink::GamepadEffectParameters::DataView input, ::device::mojom::blink::GamepadEffectParametersPtr* output);
};

}  // namespace mojo

#endif  // DEVICE_GAMEPAD_PUBLIC_MOJOM_GAMEPAD_MOJOM_BLINK_H_
/* Metadata comment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*/