chromium/out/Default/gen/device/vr/public/mojom/vr_service.mojom.h

// device/vr/public/mojom/vr_service.mojom.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_VR_PUBLIC_MOJOM_VR_SERVICE_MOJOM_H_
#define DEVICE_VR_PUBLIC_MOJOM_VR_SERVICE_MOJOM_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/vr/public/mojom/vr_service.mojom-features.h"  // IWYU pragma: export
#include "device/vr/public/mojom/vr_service.mojom-shared.h"  // IWYU pragma: export
#include "device/vr/public/mojom/vr_service.mojom-forward.h"  // IWYU pragma: export
#include "device/gamepad/public/mojom/gamepad.mojom.h"
#include "device/vr/public/mojom/xr_session.mojom-forward.h"
#include "mojo/public/mojom/base/big_buffer.mojom.h"
#include "mojo/public/mojom/base/time.mojom.h"
#include "gpu/ipc/common/exported_shared_image.mojom.h"
#include "gpu/ipc/common/shared_image_metadata.mojom-forward.h"
#include "gpu/ipc/common/mailbox_holder.mojom.h"
#include "gpu/ipc/common/sync_token.mojom.h"
#include "ui/display/mojom/display.mojom-forward.h"
#include "ui/gfx/geometry/mojom/geometry.mojom.h"
#include "ui/gfx/mojom/gpu_fence_handle.mojom.h"
#include "ui/gfx/mojom/transform.mojom.h"
#include <string>
#include <vector>

#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/vr/public/mojom/vr_service_mojom_traits.h"
#include "base/component_export.h"




namespace device::mojom {

class VRServiceProxy;

template <typename ImplRefTraits>
class VRServiceStub;

class VRServiceRequestValidator;
class VRServiceResponseValidator;


class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) VRService
    : public VRServiceInterfaceBase { … };

class XRSessionMetricsRecorderProxy;

template <typename ImplRefTraits>
class XRSessionMetricsRecorderStub;

class XRSessionMetricsRecorderRequestValidator;


class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) XRSessionMetricsRecorder
    : public XRSessionMetricsRecorderInterfaceBase { … };

class VRServiceClientProxy;

template <typename ImplRefTraits>
class VRServiceClientStub;

class VRServiceClientRequestValidator;


class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) VRServiceClient
    : public VRServiceClientInterfaceBase { … };

class XREnvironmentIntegrationProviderProxy;

template <typename ImplRefTraits>
class XREnvironmentIntegrationProviderStub;

class XREnvironmentIntegrationProviderRequestValidator;
class XREnvironmentIntegrationProviderResponseValidator;


class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) XREnvironmentIntegrationProvider
    : public XREnvironmentIntegrationProviderInterfaceBase { … };

class XRFrameDataProviderProxy;

template <typename ImplRefTraits>
class XRFrameDataProviderStub;

class XRFrameDataProviderRequestValidator;
class XRFrameDataProviderResponseValidator;


class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) XRFrameDataProvider
    : public XRFrameDataProviderInterfaceBase { … };

class XRPresentationProviderProxy;

template <typename ImplRefTraits>
class XRPresentationProviderStub;

class XRPresentationProviderRequestValidator;


class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) XRPresentationProvider
    : public XRPresentationProviderInterfaceBase { … };

class XRPresentationClientProxy;

template <typename ImplRefTraits>
class XRPresentationClientStub;

class XRPresentationClientRequestValidator;


class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) XRPresentationClient
    : public XRPresentationClientInterfaceBase { … };

class XRSessionClientProxy;

template <typename ImplRefTraits>
class XRSessionClientStub;

class XRSessionClientRequestValidator;


class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) XRSessionClient
    : public XRSessionClientInterfaceBase { … };

class WebXrInternalsRendererListenerProxy;

template <typename ImplRefTraits>
class WebXrInternalsRendererListenerStub;

class WebXrInternalsRendererListenerRequestValidator;


class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) WebXrInternalsRendererListener
    : public WebXrInternalsRendererListenerInterfaceBase { … };



class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) VRServiceProxy
    : public VRService { … };



class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) XRSessionMetricsRecorderProxy
    : public XRSessionMetricsRecorder { … };



class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) VRServiceClientProxy
    : public VRServiceClient { … };



class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) XREnvironmentIntegrationProviderProxy
    : public XREnvironmentIntegrationProvider { … };



class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) XRFrameDataProviderProxy
    : public XRFrameDataProvider { … };



class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) XRPresentationProviderProxy
    : public XRPresentationProvider { … };



class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) XRPresentationClientProxy
    : public XRPresentationClient { … };



class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) XRSessionClientProxy
    : public XRSessionClient { … };



class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) WebXrInternalsRendererListenerProxy
    : public WebXrInternalsRendererListener { … };
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) VRServiceStubDispatch { … };

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

  VRServiceStub() = default;
  ~VRServiceStub() override = default;

  void set_sink(ImplPointerType sink) { … }
  ImplPointerType& sink() { … }

  bool Accept(mojo::Message* message) override { … }

  bool AcceptWithResponder(
      mojo::Message* message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) override { … }

 private:
  ImplPointerType sink_;
};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) XRSessionMetricsRecorderStubDispatch { … };

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

  XRSessionMetricsRecorderStub() = default;
  ~XRSessionMetricsRecorderStub() override = default;

  void set_sink(ImplPointerType sink) { … }
  ImplPointerType& sink() { … }

  bool Accept(mojo::Message* message) override { … }

  bool AcceptWithResponder(
      mojo::Message* message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) override { … }

 private:
  ImplPointerType sink_;
};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) VRServiceClientStubDispatch { … };

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

  VRServiceClientStub() = default;
  ~VRServiceClientStub() override = default;

  void set_sink(ImplPointerType sink) { … }
  ImplPointerType& sink() { … }

  bool Accept(mojo::Message* message) override { … }

  bool AcceptWithResponder(
      mojo::Message* message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) override { … }

 private:
  ImplPointerType sink_;
};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) XREnvironmentIntegrationProviderStubDispatch { … };

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

  XREnvironmentIntegrationProviderStub() = default;
  ~XREnvironmentIntegrationProviderStub() override = default;

  void set_sink(ImplPointerType sink) { … }
  ImplPointerType& sink() { … }

  bool Accept(mojo::Message* message) override { … }

  bool AcceptWithResponder(
      mojo::Message* message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) override { … }

 private:
  ImplPointerType sink_;
};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) XRFrameDataProviderStubDispatch { … };

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

  XRFrameDataProviderStub() = default;
  ~XRFrameDataProviderStub() override = default;

  void set_sink(ImplPointerType sink) { … }
  ImplPointerType& sink() { … }

  bool Accept(mojo::Message* message) override { … }

  bool AcceptWithResponder(
      mojo::Message* message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) override { … }

 private:
  ImplPointerType sink_;
};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) XRPresentationProviderStubDispatch { … };

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

  XRPresentationProviderStub() = default;
  ~XRPresentationProviderStub() override = default;

  void set_sink(ImplPointerType sink) { … }
  ImplPointerType& sink() { … }

  bool Accept(mojo::Message* message) override { … }

  bool AcceptWithResponder(
      mojo::Message* message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) override { … }

 private:
  ImplPointerType sink_;
};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) XRPresentationClientStubDispatch { … };

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

  XRPresentationClientStub() = default;
  ~XRPresentationClientStub() override = default;

  void set_sink(ImplPointerType sink) { … }
  ImplPointerType& sink() { … }

  bool Accept(mojo::Message* message) override { … }

  bool AcceptWithResponder(
      mojo::Message* message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) override { … }

 private:
  ImplPointerType sink_;
};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) XRSessionClientStubDispatch { … };

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

  XRSessionClientStub() = default;
  ~XRSessionClientStub() override = default;

  void set_sink(ImplPointerType sink) { … }
  ImplPointerType& sink() { … }

  bool Accept(mojo::Message* message) override { … }

  bool AcceptWithResponder(
      mojo::Message* message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) override { … }

 private:
  ImplPointerType sink_;
};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) WebXrInternalsRendererListenerStubDispatch { … };

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

  WebXrInternalsRendererListenerStub() = default;
  ~WebXrInternalsRendererListenerStub() override = default;

  void set_sink(ImplPointerType sink) { … }
  ImplPointerType& sink() { … }

  bool Accept(mojo::Message* message) override { … }

  bool AcceptWithResponder(
      mojo::Message* message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) override { … }

 private:
  ImplPointerType sink_;
};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) VRServiceRequestValidator : public mojo::MessageReceiver { … };
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) XRSessionMetricsRecorderRequestValidator : public mojo::MessageReceiver { … };
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) VRServiceClientRequestValidator : public mojo::MessageReceiver { … };
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) XREnvironmentIntegrationProviderRequestValidator : public mojo::MessageReceiver { … };
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) XRFrameDataProviderRequestValidator : public mojo::MessageReceiver { … };
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) XRPresentationProviderRequestValidator : public mojo::MessageReceiver { … };
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) XRPresentationClientRequestValidator : public mojo::MessageReceiver { … };
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) XRSessionClientRequestValidator : public mojo::MessageReceiver { … };
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) WebXrInternalsRendererListenerRequestValidator : public mojo::MessageReceiver { … };
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) VRServiceResponseValidator : public mojo::MessageReceiver { … };
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) XREnvironmentIntegrationProviderResponseValidator : public mojo::MessageReceiver { … };
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) XRFrameDataProviderResponseValidator : public mojo::MessageReceiver { … };





class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) XRDepthConfig { … };

// 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, XRDepthConfig::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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












class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) VRFieldOfView { … };

// 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, VRFieldOfView::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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











class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) XRPresentationTransportOptions { … };

// 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, XRPresentationTransportOptions::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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





class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) XRInputSourceSpaceInfo { … };

// 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, XRInputSourceSpaceInfo::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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





class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) XRHandJointSpaceInfo { … };

// 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, XRHandJointSpaceInfo::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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





class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) XRPlanePointData { … };

// 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, XRPlanePointData::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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












class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) RgbTupleF32 { … };

// 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, RgbTupleF32::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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






class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) RgbaTupleF16 { … };

// 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, RgbaTupleF16::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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









class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) XRDepthDataStillValid { … };

// 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, XRDepthDataStillValid::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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










class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) XRFrameDataRequestOptions { … };

// 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, XRFrameDataRequestOptions::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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





class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) XRNativeOriginInformation { … };



class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) XRDepthData { … };



class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) RequestSessionResult { … };






class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) XRSessionDeviceConfig { … };

// 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, XRSessionDeviceConfig::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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





class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) XRSession { … };

// 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, XRSession::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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





class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) XRPresentationConnection { … };

// 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, XRPresentationConnection::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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





class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) XRInputSourceDescription { … };

// 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, XRInputSourceDescription::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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





class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) XRHandJointData { … };

// 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, XRHandJointData::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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





class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) XRHandTrackingData { … };

// 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, XRHandTrackingData::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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





class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) XRInputSourceState { … };

// 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, XRInputSourceState::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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






class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) VRPose { … };

// 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, VRPose::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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





class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) Pose { … };

// 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, Pose::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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





class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) XRRay { … };

// 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, XRRay::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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





class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) XRHitResult { … };

// 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, XRHitResult::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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





class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) XRView { … };

// 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, XRView::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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





class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) VRStageParameters { … };

// 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, VRStageParameters::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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









class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) XRPlaneData { … };

// 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, XRPlaneData::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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





class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) XRPlaneDetectionData { … };

// 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, XRPlaneDetectionData::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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





class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) XRAnchorData { … };

// 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, XRAnchorData::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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





class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) XRAnchorsData { … };

// 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, XRAnchorsData::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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





class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) XRHitTestSubscriptionResultData { … };

// 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, XRHitTestSubscriptionResultData::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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





class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) XRHitTestTransientInputSubscriptionResultData { … };

// 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, XRHitTestTransientInputSubscriptionResultData::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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





class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) XRHitTestSubscriptionResultsData { … };

// 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, XRHitTestSubscriptionResultsData::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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






class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) XRSphericalHarmonics { … };

// 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, XRSphericalHarmonics::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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






class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) XRCubeMap { … };

// 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, XRCubeMap::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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





class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) XRLightProbe { … };

// 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, XRLightProbe::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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





class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) XRReflectionProbe { … };

// 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, XRReflectionProbe::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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





class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) XRLightEstimationData { … };

// 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, XRLightEstimationData::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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






class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) XRDepthDataUpdated { … };

// 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, XRDepthDataUpdated::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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





class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) XRTrackedImageData { … };

// 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, XRTrackedImageData::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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





class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) XRTrackedImagesData { … };

// 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, XRTrackedImagesData::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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





class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) XRFrameData { … };

// 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, XRFrameData::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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





class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) RequestSessionSuccess { … };

// 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, RequestSessionSuccess::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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


template <typename UnionPtrType>
XRNativeOriginInformationPtr XRNativeOriginInformation::Clone() const { … }

template <typename T,
          typename std::enable_if<std::is_same<
              T, XRNativeOriginInformation>::value>::type*>
bool XRNativeOriginInformation::Equals(const T& other) const { … }
template <typename UnionPtrType>
XRDepthDataPtr XRDepthData::Clone() const { … }

template <typename T,
          typename std::enable_if<std::is_same<
              T, XRDepthData>::value>::type*>
bool XRDepthData::Equals(const T& other) const { … }
template <typename UnionPtrType>
RequestSessionResultPtr RequestSessionResult::Clone() const { … }

template <typename T,
          typename std::enable_if<std::is_same<
              T, RequestSessionResult>::value>::type*>
bool RequestSessionResult::Equals(const T& other) const { … }
template <typename StructPtrType>
XRDepthConfigPtr XRDepthConfig::Clone() const { … }

template <typename T, XRDepthConfig::EnableIfSame<T>*>
bool XRDepthConfig::Equals(const T& other_struct) const { … }

template <typename T, XRDepthConfig::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
XRSessionDeviceConfigPtr XRSessionDeviceConfig::Clone() const { … }

template <typename T, XRSessionDeviceConfig::EnableIfSame<T>*>
bool XRSessionDeviceConfig::Equals(const T& other_struct) const { … }

template <typename T, XRSessionDeviceConfig::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
XRSessionPtr XRSession::Clone() const { … }

template <typename T, XRSession::EnableIfSame<T>*>
bool XRSession::Equals(const T& other_struct) const { … }

template <typename T, XRSession::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
XRPresentationConnectionPtr XRPresentationConnection::Clone() const { … }

template <typename T, XRPresentationConnection::EnableIfSame<T>*>
bool XRPresentationConnection::Equals(const T& other_struct) const { … }

template <typename T, XRPresentationConnection::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
XRInputSourceDescriptionPtr XRInputSourceDescription::Clone() const { … }

template <typename T, XRInputSourceDescription::EnableIfSame<T>*>
bool XRInputSourceDescription::Equals(const T& other_struct) const { … }

template <typename T, XRInputSourceDescription::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
XRHandJointDataPtr XRHandJointData::Clone() const { … }

template <typename T, XRHandJointData::EnableIfSame<T>*>
bool XRHandJointData::Equals(const T& other_struct) const { … }

template <typename T, XRHandJointData::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
XRHandTrackingDataPtr XRHandTrackingData::Clone() const { … }

template <typename T, XRHandTrackingData::EnableIfSame<T>*>
bool XRHandTrackingData::Equals(const T& other_struct) const { … }

template <typename T, XRHandTrackingData::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
XRInputSourceStatePtr XRInputSourceState::Clone() const { … }

template <typename T, XRInputSourceState::EnableIfSame<T>*>
bool XRInputSourceState::Equals(const T& other_struct) const { … }

template <typename T, XRInputSourceState::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
VRFieldOfViewPtr VRFieldOfView::Clone() const { … }

template <typename T, VRFieldOfView::EnableIfSame<T>*>
bool VRFieldOfView::Equals(const T& other_struct) const { … }

template <typename T, VRFieldOfView::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
VRPosePtr VRPose::Clone() const { … }

template <typename T, VRPose::EnableIfSame<T>*>
bool VRPose::Equals(const T& other_struct) const { … }

template <typename T, VRPose::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
PosePtr Pose::Clone() const { … }

template <typename T, Pose::EnableIfSame<T>*>
bool Pose::Equals(const T& other_struct) const { … }

template <typename T, Pose::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
XRRayPtr XRRay::Clone() const { … }

template <typename T, XRRay::EnableIfSame<T>*>
bool XRRay::Equals(const T& other_struct) const { … }

template <typename T, XRRay::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
XRHitResultPtr XRHitResult::Clone() const { … }

template <typename T, XRHitResult::EnableIfSame<T>*>
bool XRHitResult::Equals(const T& other_struct) const { … }

template <typename T, XRHitResult::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
XRViewPtr XRView::Clone() const { … }

template <typename T, XRView::EnableIfSame<T>*>
bool XRView::Equals(const T& other_struct) const { … }

template <typename T, XRView::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
VRStageParametersPtr VRStageParameters::Clone() const { … }

template <typename T, VRStageParameters::EnableIfSame<T>*>
bool VRStageParameters::Equals(const T& other_struct) const { … }

template <typename T, VRStageParameters::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
XRPresentationTransportOptionsPtr XRPresentationTransportOptions::Clone() const { … }

template <typename T, XRPresentationTransportOptions::EnableIfSame<T>*>
bool XRPresentationTransportOptions::Equals(const T& other_struct) const { … }

template <typename T, XRPresentationTransportOptions::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
XRInputSourceSpaceInfoPtr XRInputSourceSpaceInfo::Clone() const { … }

template <typename T, XRInputSourceSpaceInfo::EnableIfSame<T>*>
bool XRInputSourceSpaceInfo::Equals(const T& other_struct) const { … }

template <typename T, XRInputSourceSpaceInfo::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
XRHandJointSpaceInfoPtr XRHandJointSpaceInfo::Clone() const { … }

template <typename T, XRHandJointSpaceInfo::EnableIfSame<T>*>
bool XRHandJointSpaceInfo::Equals(const T& other_struct) const { … }

template <typename T, XRHandJointSpaceInfo::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
XRPlanePointDataPtr XRPlanePointData::Clone() const { … }

template <typename T, XRPlanePointData::EnableIfSame<T>*>
bool XRPlanePointData::Equals(const T& other_struct) const { … }

template <typename T, XRPlanePointData::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
XRPlaneDataPtr XRPlaneData::Clone() const { … }

template <typename T, XRPlaneData::EnableIfSame<T>*>
bool XRPlaneData::Equals(const T& other_struct) const { … }

template <typename T, XRPlaneData::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
XRPlaneDetectionDataPtr XRPlaneDetectionData::Clone() const { … }

template <typename T, XRPlaneDetectionData::EnableIfSame<T>*>
bool XRPlaneDetectionData::Equals(const T& other_struct) const { … }

template <typename T, XRPlaneDetectionData::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
XRAnchorDataPtr XRAnchorData::Clone() const { … }

template <typename T, XRAnchorData::EnableIfSame<T>*>
bool XRAnchorData::Equals(const T& other_struct) const { … }

template <typename T, XRAnchorData::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
XRAnchorsDataPtr XRAnchorsData::Clone() const { … }

template <typename T, XRAnchorsData::EnableIfSame<T>*>
bool XRAnchorsData::Equals(const T& other_struct) const { … }

template <typename T, XRAnchorsData::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
XRHitTestSubscriptionResultDataPtr XRHitTestSubscriptionResultData::Clone() const { … }

template <typename T, XRHitTestSubscriptionResultData::EnableIfSame<T>*>
bool XRHitTestSubscriptionResultData::Equals(const T& other_struct) const { … }

template <typename T, XRHitTestSubscriptionResultData::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
XRHitTestTransientInputSubscriptionResultDataPtr XRHitTestTransientInputSubscriptionResultData::Clone() const { … }

template <typename T, XRHitTestTransientInputSubscriptionResultData::EnableIfSame<T>*>
bool XRHitTestTransientInputSubscriptionResultData::Equals(const T& other_struct) const { … }

template <typename T, XRHitTestTransientInputSubscriptionResultData::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
XRHitTestSubscriptionResultsDataPtr XRHitTestSubscriptionResultsData::Clone() const { … }

template <typename T, XRHitTestSubscriptionResultsData::EnableIfSame<T>*>
bool XRHitTestSubscriptionResultsData::Equals(const T& other_struct) const { … }

template <typename T, XRHitTestSubscriptionResultsData::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
RgbTupleF32Ptr RgbTupleF32::Clone() const { … }

template <typename T, RgbTupleF32::EnableIfSame<T>*>
bool RgbTupleF32::Equals(const T& other_struct) const { … }

template <typename T, RgbTupleF32::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
XRSphericalHarmonicsPtr XRSphericalHarmonics::Clone() const { … }

template <typename T, XRSphericalHarmonics::EnableIfSame<T>*>
bool XRSphericalHarmonics::Equals(const T& other_struct) const { … }

template <typename T, XRSphericalHarmonics::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
RgbaTupleF16Ptr RgbaTupleF16::Clone() const { … }

template <typename T, RgbaTupleF16::EnableIfSame<T>*>
bool RgbaTupleF16::Equals(const T& other_struct) const { … }

template <typename T, RgbaTupleF16::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
XRCubeMapPtr XRCubeMap::Clone() const { … }

template <typename T, XRCubeMap::EnableIfSame<T>*>
bool XRCubeMap::Equals(const T& other_struct) const { … }

template <typename T, XRCubeMap::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
XRLightProbePtr XRLightProbe::Clone() const { … }

template <typename T, XRLightProbe::EnableIfSame<T>*>
bool XRLightProbe::Equals(const T& other_struct) const { … }

template <typename T, XRLightProbe::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
XRReflectionProbePtr XRReflectionProbe::Clone() const { … }

template <typename T, XRReflectionProbe::EnableIfSame<T>*>
bool XRReflectionProbe::Equals(const T& other_struct) const { … }

template <typename T, XRReflectionProbe::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
XRLightEstimationDataPtr XRLightEstimationData::Clone() const { … }

template <typename T, XRLightEstimationData::EnableIfSame<T>*>
bool XRLightEstimationData::Equals(const T& other_struct) const { … }

template <typename T, XRLightEstimationData::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
XRDepthDataStillValidPtr XRDepthDataStillValid::Clone() const { … }

template <typename T, XRDepthDataStillValid::EnableIfSame<T>*>
bool XRDepthDataStillValid::Equals(const T& other_struct) const { … }

template <typename T, XRDepthDataStillValid::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
XRDepthDataUpdatedPtr XRDepthDataUpdated::Clone() const { … }

template <typename T, XRDepthDataUpdated::EnableIfSame<T>*>
bool XRDepthDataUpdated::Equals(const T& other_struct) const { … }

template <typename T, XRDepthDataUpdated::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
XRTrackedImageDataPtr XRTrackedImageData::Clone() const { … }

template <typename T, XRTrackedImageData::EnableIfSame<T>*>
bool XRTrackedImageData::Equals(const T& other_struct) const { … }

template <typename T, XRTrackedImageData::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
XRTrackedImagesDataPtr XRTrackedImagesData::Clone() const { … }

template <typename T, XRTrackedImagesData::EnableIfSame<T>*>
bool XRTrackedImagesData::Equals(const T& other_struct) const { … }

template <typename T, XRTrackedImagesData::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
XRFrameDataPtr XRFrameData::Clone() const { … }

template <typename T, XRFrameData::EnableIfSame<T>*>
bool XRFrameData::Equals(const T& other_struct) const { … }

template <typename T, XRFrameData::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
RequestSessionSuccessPtr RequestSessionSuccess::Clone() const { … }

template <typename T, RequestSessionSuccess::EnableIfSame<T>*>
bool RequestSessionSuccess::Equals(const T& other_struct) const { … }

template <typename T, RequestSessionSuccess::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
XRFrameDataRequestOptionsPtr XRFrameDataRequestOptions::Clone() const { … }

template <typename T, XRFrameDataRequestOptions::EnableIfSame<T>*>
bool XRFrameDataRequestOptions::Equals(const T& other_struct) const { … }

template <typename T, XRFrameDataRequestOptions::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }


}  // device::mojom

namespace mojo {


template <>
struct COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) StructTraits<::device::mojom::XRDepthConfig::DataView,
                                         ::device::mojom::XRDepthConfigPtr> { … };


template <>
struct COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) StructTraits<::device::mojom::XRSessionDeviceConfig::DataView,
                                         ::device::mojom::XRSessionDeviceConfigPtr> { … };


template <>
struct COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) StructTraits<::device::mojom::XRSession::DataView,
                                         ::device::mojom::XRSessionPtr> { … };


template <>
struct COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) StructTraits<::device::mojom::XRPresentationConnection::DataView,
                                         ::device::mojom::XRPresentationConnectionPtr> { … };


template <>
struct COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) StructTraits<::device::mojom::XRInputSourceDescription::DataView,
                                         ::device::mojom::XRInputSourceDescriptionPtr> { … };


template <>
struct COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) StructTraits<::device::mojom::XRHandJointData::DataView,
                                         ::device::mojom::XRHandJointDataPtr> { … };


template <>
struct COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) StructTraits<::device::mojom::XRHandTrackingData::DataView,
                                         ::device::mojom::XRHandTrackingDataPtr> { … };


template <>
struct COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) StructTraits<::device::mojom::XRInputSourceState::DataView,
                                         ::device::mojom::XRInputSourceStatePtr> { … };


template <>
struct COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) StructTraits<::device::mojom::VRFieldOfView::DataView,
                                         ::device::mojom::VRFieldOfViewPtr> { … };


template <>
struct COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) StructTraits<::device::mojom::VRPose::DataView,
                                         ::device::mojom::VRPosePtr> { … };


template <>
struct COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) StructTraits<::device::mojom::Pose::DataView,
                                         ::device::mojom::PosePtr> { … };


template <>
struct COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) StructTraits<::device::mojom::XRRay::DataView,
                                         ::device::mojom::XRRayPtr> { … };


template <>
struct COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) StructTraits<::device::mojom::XRHitResult::DataView,
                                         ::device::mojom::XRHitResultPtr> { … };


template <>
struct COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) StructTraits<::device::mojom::XRView::DataView,
                                         ::device::mojom::XRViewPtr> { … };


template <>
struct COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) StructTraits<::device::mojom::VRStageParameters::DataView,
                                         ::device::mojom::VRStageParametersPtr> { … };


template <>
struct COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) StructTraits<::device::mojom::XRPresentationTransportOptions::DataView,
                                         ::device::mojom::XRPresentationTransportOptionsPtr> { … };


template <>
struct COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) StructTraits<::device::mojom::XRInputSourceSpaceInfo::DataView,
                                         ::device::mojom::XRInputSourceSpaceInfoPtr> { … };


template <>
struct COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) StructTraits<::device::mojom::XRHandJointSpaceInfo::DataView,
                                         ::device::mojom::XRHandJointSpaceInfoPtr> { … };


template <>
struct COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) StructTraits<::device::mojom::XRPlanePointData::DataView,
                                         ::device::mojom::XRPlanePointDataPtr> { … };


template <>
struct COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) StructTraits<::device::mojom::XRPlaneData::DataView,
                                         ::device::mojom::XRPlaneDataPtr> { … };


template <>
struct COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) StructTraits<::device::mojom::XRPlaneDetectionData::DataView,
                                         ::device::mojom::XRPlaneDetectionDataPtr> { … };


template <>
struct COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) StructTraits<::device::mojom::XRAnchorData::DataView,
                                         ::device::mojom::XRAnchorDataPtr> { … };


template <>
struct COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) StructTraits<::device::mojom::XRAnchorsData::DataView,
                                         ::device::mojom::XRAnchorsDataPtr> { … };


template <>
struct COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) StructTraits<::device::mojom::XRHitTestSubscriptionResultData::DataView,
                                         ::device::mojom::XRHitTestSubscriptionResultDataPtr> { … };


template <>
struct COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) StructTraits<::device::mojom::XRHitTestTransientInputSubscriptionResultData::DataView,
                                         ::device::mojom::XRHitTestTransientInputSubscriptionResultDataPtr> { … };


template <>
struct COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) StructTraits<::device::mojom::XRHitTestSubscriptionResultsData::DataView,
                                         ::device::mojom::XRHitTestSubscriptionResultsDataPtr> { … };


template <>
struct COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) StructTraits<::device::mojom::RgbTupleF32::DataView,
                                         ::device::mojom::RgbTupleF32Ptr> { … };


template <>
struct COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) StructTraits<::device::mojom::XRSphericalHarmonics::DataView,
                                         ::device::mojom::XRSphericalHarmonicsPtr> { … };


template <>
struct COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) StructTraits<::device::mojom::RgbaTupleF16::DataView,
                                         ::device::mojom::RgbaTupleF16Ptr> { … };


template <>
struct COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) StructTraits<::device::mojom::XRCubeMap::DataView,
                                         ::device::mojom::XRCubeMapPtr> { … };


template <>
struct COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) StructTraits<::device::mojom::XRLightProbe::DataView,
                                         ::device::mojom::XRLightProbePtr> { … };


template <>
struct COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) StructTraits<::device::mojom::XRReflectionProbe::DataView,
                                         ::device::mojom::XRReflectionProbePtr> { … };


template <>
struct COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) StructTraits<::device::mojom::XRLightEstimationData::DataView,
                                         ::device::mojom::XRLightEstimationDataPtr> { … };


template <>
struct COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) StructTraits<::device::mojom::XRDepthDataStillValid::DataView,
                                         ::device::mojom::XRDepthDataStillValidPtr> { … };


template <>
struct COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) StructTraits<::device::mojom::XRDepthDataUpdated::DataView,
                                         ::device::mojom::XRDepthDataUpdatedPtr> { … };


template <>
struct COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) StructTraits<::device::mojom::XRTrackedImageData::DataView,
                                         ::device::mojom::XRTrackedImageDataPtr> { … };


template <>
struct COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) StructTraits<::device::mojom::XRTrackedImagesData::DataView,
                                         ::device::mojom::XRTrackedImagesDataPtr> { … };


template <>
struct COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) StructTraits<::device::mojom::XRFrameData::DataView,
                                         ::device::mojom::XRFrameDataPtr> { … };


template <>
struct COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) StructTraits<::device::mojom::RequestSessionSuccess::DataView,
                                         ::device::mojom::RequestSessionSuccessPtr> { … };


template <>
struct COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) StructTraits<::device::mojom::XRFrameDataRequestOptions::DataView,
                                         ::device::mojom::XRFrameDataRequestOptionsPtr> { … };


template <>
struct COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) UnionTraits<::device::mojom::XRNativeOriginInformation::DataView,
                                        ::device::mojom::XRNativeOriginInformationPtr> { … };


template <>
struct COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) UnionTraits<::device::mojom::XRDepthData::DataView,
                                        ::device::mojom::XRDepthDataPtr> { … };


template <>
struct COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS) UnionTraits<::device::mojom::RequestSessionResult::DataView,
                                        ::device::mojom::RequestSessionResultPtr> { … };

}  // namespace mojo

#endif  // DEVICE_VR_PUBLIC_MOJOM_VR_SERVICE_MOJOM_H_