// device/vr/public/mojom/vr_service.mojom-shared-internal.h is auto generated by mojom_bindings_generator.py, do not edit

// Copyright 2016 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_SHARED_INTERNAL_H_
#define DEVICE_VR_PUBLIC_MOJOM_VR_SERVICE_MOJOM_SHARED_INTERNAL_H_
#include "mojo/public/cpp/bindings/lib/array_internal.h"
#include "mojo/public/cpp/bindings/lib/bindings_internal.h"
#include "mojo/public/cpp/bindings/lib/map_data_internal.h"
#include "mojo/public/cpp/bindings/lib/validation_errors.h"
#include "mojo/public/cpp/bindings/lib/message_fragment.h"
#include "mojo/public/c/system/macros.h"
#include "device/gamepad/public/mojom/gamepad.mojom-shared-internal.h"
#include "device/vr/public/mojom/xr_hand_tracking_data.mojom-shared-internal.h"
#include "device/vr/public/mojom/xr_session.mojom-shared-internal.h"
#include "mojo/public/mojom/base/big_buffer.mojom-shared-internal.h"
#include "mojo/public/mojom/base/time.mojom-shared-internal.h"
#include "gpu/ipc/common/exported_shared_image.mojom-shared-internal.h"
#include "gpu/ipc/common/shared_image_metadata.mojom-shared-internal.h"
#include "gpu/ipc/common/sync_token.mojom-shared-internal.h"
#include "ui/display/mojom/display.mojom-shared-internal.h"
#include "ui/gfx/geometry/mojom/geometry.mojom-shared-internal.h"
#include "ui/gfx/mojom/gpu_fence_handle.mojom-shared-internal.h"
#include "ui/gfx/mojom/transform.mojom-shared-internal.h"
#include "mojo/public/cpp/bindings/lib/native_enum_data.h"
#include "mojo/public/interfaces/bindings/native_struct.mojom-shared-internal.h"
#include "base/component_export.h"



namespace mojo {
namespace internal {
class ValidationContext;
}
}


namespace device::mojom {
namespace internal {
class XRDepthConfig_Data;
class XRSessionDeviceConfig_Data;
class XRSession_Data;
class XRPresentationConnection_Data;
class XRInputSourceDescription_Data;
class XRInputSourceState_Data;
class VRFieldOfView_Data;
class VRPose_Data;
class Pose_Data;
class AnchorId_Data;
class HitTestSubscriptionId_Data;
class PlaneId_Data;
class MeshId_Data;
class XrVisibilityMaskId_Data;
class XRRay_Data;
class XRHitResult_Data;
class XRViewGeometry_Data;
class XRVisibilityMask_Data;
class XRView_Data;
class VRStageParameters_Data;
class XRPresentationTransportOptions_Data;
class XRInputSourceSpaceInfo_Data;
class XRHandJointSpaceInfo_Data;
class XRPlanePointData_Data;
class XRPlaneData_Data;
class XRPlaneDetectionData_Data;
class XRMeshData_Data;
class XRMeshDetectionData_Data;
class XRAnchorData_Data;
class XRAnchorsData_Data;
class XRHitTestSubscriptionResultData_Data;
class XRHitTestTransientInputSubscriptionResultData_Data;
class XRHitTestSubscriptionResultsData_Data;
class RgbTupleF32_Data;
class XRSphericalHarmonics_Data;
class XRCubeMap_Data;
class XRLightProbe_Data;
class XRReflectionProbe_Data;
class XRLightEstimationData_Data;
class XRDepthDataStillValid_Data;
class XRDepthDataUpdated_Data;
class XRTrackedImageData_Data;
class XRTrackedImagesData_Data;
class LayerId_Data;
class XRProjectionLayerData_Data;
class XRQuadLayerData_Data;
class XRCylinderLayerData_Data;
class XREquirectLayerData_Data;
class XRCubeLayerData_Data;
class XRLayerReadOnlyData_Data;
class XRLayerMutableData_Data;
class XRCompositionLayerData_Data;
class XRLayerFrameData_Data;
class XRRenderInfo_Data;
class XRFrameData_Data;
class RequestSessionSuccess_Data;
class XRFrameDataRequestOptions_Data;
class XRLayerUpdate_Data;
class XRNativeOriginInformation_Data;
class XRDepthData_Data;
class XRLayerSpecificData_Data;
class RequestSessionResult_Data;

struct XRHandedness_Data {
 public:
  static bool constexpr kIsExtensible = false;

  static bool IsKnownValue(int32_t value) {
    switch (value) {
      case 0:
      case 1:
      case 2:
        return true;
    }
    return false;
  }

  static bool Validate(int32_t value,
                       mojo::internal::ValidationContext* validation_context) {
    if (kIsExtensible || IsKnownValue(value))
      return true;

    ReportValidationError(validation_context,
                          mojo::internal::VALIDATION_ERROR_UNKNOWN_ENUM_VALUE);
    return false;
  }
};

struct XRTargetRayMode_Data {
 public:
  static bool constexpr kIsExtensible = false;

  static bool IsKnownValue(int32_t value) {
    switch (value) {
      case 1:
      case 2:
      case 3:
        return true;
    }
    return false;
  }

  static bool Validate(int32_t value,
                       mojo::internal::ValidationContext* validation_context) {
    if (kIsExtensible || IsKnownValue(value))
      return true;

    ReportValidationError(validation_context,
                          mojo::internal::VALIDATION_ERROR_UNKNOWN_ENUM_VALUE);
    return false;
  }
};

struct XRSessionFeatureRequestStatus_Data {
 public:
  static bool constexpr kIsExtensible = false;

  static bool IsKnownValue(int32_t value) {
    switch (value) {
      case 0:
      case 1:
      case 2:
      case 3:
        return true;
    }
    return false;
  }

  static bool Validate(int32_t value,
                       mojo::internal::ValidationContext* validation_context) {
    if (kIsExtensible || IsKnownValue(value))
      return true;

    ReportValidationError(validation_context,
                          mojo::internal::VALIDATION_ERROR_UNKNOWN_ENUM_VALUE);
    return false;
  }
};

struct XREnvironmentBlendMode_Data {
 public:
  static bool constexpr kIsExtensible = false;

  static bool IsKnownValue(int32_t value) {
    switch (value) {
      case 1:
      case 2:
      case 3:
        return true;
    }
    return false;
  }

  static bool Validate(int32_t value,
                       mojo::internal::ValidationContext* validation_context) {
    if (kIsExtensible || IsKnownValue(value))
      return true;

    ReportValidationError(validation_context,
                          mojo::internal::VALIDATION_ERROR_UNKNOWN_ENUM_VALUE);
    return false;
  }
};

struct XRInteractionMode_Data {
 public:
  static bool constexpr kIsExtensible = false;

  static bool IsKnownValue(int32_t value) {
    switch (value) {
      case 1:
      case 2:
        return true;
    }
    return false;
  }

  static bool Validate(int32_t value,
                       mojo::internal::ValidationContext* validation_context) {
    if (kIsExtensible || IsKnownValue(value))
      return true;

    ReportValidationError(validation_context,
                          mojo::internal::VALIDATION_ERROR_UNKNOWN_ENUM_VALUE);
    return false;
  }
};

struct XREye_Data {
 public:
  static bool constexpr kIsExtensible = false;

  static bool IsKnownValue(int32_t value) {
    switch (value) {
      case 0:
      case 1:
      case 2:
        return true;
    }
    return false;
  }

  static bool Validate(int32_t value,
                       mojo::internal::ValidationContext* validation_context) {
    if (kIsExtensible || IsKnownValue(value))
      return true;

    ReportValidationError(validation_context,
                          mojo::internal::VALIDATION_ERROR_UNKNOWN_ENUM_VALUE);
    return false;
  }
};

struct XRPresentationTransportMethod_Data {
 public:
  static bool constexpr kIsExtensible = false;

  static bool IsKnownValue(int32_t value) {
    switch (value) {
      case 0:
      case 1:
      case 2:
      case 3:
        return true;
    }
    return false;
  }

  static bool Validate(int32_t value,
                       mojo::internal::ValidationContext* validation_context) {
    if (kIsExtensible || IsKnownValue(value))
      return true;

    ReportValidationError(validation_context,
                          mojo::internal::VALIDATION_ERROR_UNKNOWN_ENUM_VALUE);
    return false;
  }
};

struct XRReferenceSpaceType_Data {
 public:
  static bool constexpr kIsExtensible = false;

  static bool IsKnownValue(int32_t value) {
    switch (value) {
      case 0:
      case 1:
      case 2:
      case 3:
      case 4:
        return true;
    }
    return false;
  }

  static bool Validate(int32_t value,
                       mojo::internal::ValidationContext* validation_context) {
    if (kIsExtensible || IsKnownValue(value))
      return true;

    ReportValidationError(validation_context,
                          mojo::internal::VALIDATION_ERROR_UNKNOWN_ENUM_VALUE);
    return false;
  }
};

struct XRInputSourceSpaceType_Data {
 public:
  static bool constexpr kIsExtensible = false;

  static bool IsKnownValue(int32_t value) {
    switch (value) {
      case 0:
      case 1:
        return true;
    }
    return false;
  }

  static bool Validate(int32_t value,
                       mojo::internal::ValidationContext* validation_context) {
    if (kIsExtensible || IsKnownValue(value))
      return true;

    ReportValidationError(validation_context,
                          mojo::internal::VALIDATION_ERROR_UNKNOWN_ENUM_VALUE);
    return false;
  }
};

struct XRPlaneOrientation_Data {
 public:
  static bool constexpr kIsExtensible = false;

  static bool IsKnownValue(int32_t value) {
    switch (value) {
      case 0:
      case 1:
      case 2:
        return true;
    }
    return false;
  }

  static bool Validate(int32_t value,
                       mojo::internal::ValidationContext* validation_context) {
    if (kIsExtensible || IsKnownValue(value))
      return true;

    ReportValidationError(validation_context,
                          mojo::internal::VALIDATION_ERROR_UNKNOWN_ENUM_VALUE);
    return false;
  }
};

struct XRSemanticLabel_Data {
 public:
  static bool constexpr kIsExtensible = false;

  static bool IsKnownValue(int32_t value) {
    switch (value) {
      case 0:
      case 1:
      case 2:
      case 3:
      case 4:
        return true;
    }
    return false;
  }

  static bool Validate(int32_t value,
                       mojo::internal::ValidationContext* validation_context) {
    if (kIsExtensible || IsKnownValue(value))
      return true;

    ReportValidationError(validation_context,
                          mojo::internal::VALIDATION_ERROR_UNKNOWN_ENUM_VALUE);
    return false;
  }
};

struct XRLayerLayout_Data {
 public:
  static bool constexpr kIsExtensible = false;

  static bool IsKnownValue(int32_t value) {
    switch (value) {
      case 0:
      case 1:
      case 2:
      case 3:
        return true;
    }
    return false;
  }

  static bool Validate(int32_t value,
                       mojo::internal::ValidationContext* validation_context) {
    if (kIsExtensible || IsKnownValue(value))
      return true;

    ReportValidationError(validation_context,
                          mojo::internal::VALIDATION_ERROR_UNKNOWN_ENUM_VALUE);
    return false;
  }
};

struct CreateCompositionLayerResult_Data {
 public:
  static bool constexpr kIsExtensible = false;

  static bool IsKnownValue(int32_t value) {
    switch (value) {
      case 0:
      case 1:
        return true;
    }
    return false;
  }

  static bool Validate(int32_t value,
                       mojo::internal::ValidationContext* validation_context) {
    if (kIsExtensible || IsKnownValue(value))
      return true;

    ReportValidationError(validation_context,
                          mojo::internal::VALIDATION_ERROR_UNKNOWN_ENUM_VALUE);
    return false;
  }
};

struct XrCompatibleResult_Data {
 public:
  static bool constexpr kIsExtensible = false;

  static bool IsKnownValue(int32_t value) {
    switch (value) {
      case 0:
      case 1:
      case 2:
      case 3:
      case 4:
        return true;
    }
    return false;
  }

  static bool Validate(int32_t value,
                       mojo::internal::ValidationContext* validation_context) {
    if (kIsExtensible || IsKnownValue(value))
      return true;

    ReportValidationError(validation_context,
                          mojo::internal::VALIDATION_ERROR_UNKNOWN_ENUM_VALUE);
    return false;
  }
};

struct EntityTypeForHitTest_Data {
 public:
  static bool constexpr kIsExtensible = false;

  static bool IsKnownValue(int32_t value) {
    switch (value) {
      case 1:
      case 2:
        return true;
    }
    return false;
  }

  static bool Validate(int32_t value,
                       mojo::internal::ValidationContext* validation_context) {
    if (kIsExtensible || IsKnownValue(value))
      return true;

    ReportValidationError(validation_context,
                          mojo::internal::VALIDATION_ERROR_UNKNOWN_ENUM_VALUE);
    return false;
  }
};

struct XRVisibilityState_Data {
 public:
  static bool constexpr kIsExtensible = false;

  static bool IsKnownValue(int32_t value) {
    switch (value) {
      case 1:
      case 2:
      case 3:
        return true;
    }
    return false;
  }

  static bool Validate(int32_t value,
                       mojo::internal::ValidationContext* validation_context) {
    if (kIsExtensible || IsKnownValue(value))
      return true;

    ReportValidationError(validation_context,
                          mojo::internal::VALIDATION_ERROR_UNKNOWN_ENUM_VALUE);
    return false;
  }
};

#pragma pack(push, 1)


class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS_SHARED) XRNativeOriginInformation_Data {
 public:
  // Used to identify Mojom Union Data Classes.
  typedef void MojomUnionDataType;

  XRNativeOriginInformation_Data() = default;
  // Do nothing in the destructor since it won't be called when it is a
  // non-inlined union.
  ~XRNativeOriginInformation_Data() = default;

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

  bool is_null() const { return size == 0; }

  void set_null() {
    size = 0U;
    tag = static_cast<XRNativeOriginInformation_Tag>(0);
    data.unknown = 0U;
  }

  // TODO(crbug.com/40731316): SHOUTY_CASE values are being deprecated per C++ code style
  // guidelines (https://google.github.io/styleguide/cppguide.html#Enumerator_Names),
  // please use kCamelCase values instead.  Cleanup NULL_VALUE, BOOL_VALUE, INT_VALUE, etc.
  // generation once codebase is transitioned to kNullValue, kBoolValue, kIntValue, etc.
  enum class XRNativeOriginInformation_Tag : uint32_t {

    
    kInputSourceSpaceInfo,
    
    kPlaneId,
    
    kMeshId,
    
    kAnchorId,
    
    kReferenceSpaceType,
    
    kHandJointSpaceInfo,
    
    kImageIndex,
  };

  // A note on layout:
  // "Each non-static data member is allocated as if it were the sole member of
  // a struct." - Section 9.5.2 ISO/IEC 14882:2011 (The C++ Spec)
  union MOJO_ALIGNAS(8) Union_ {
    Union_() : unknown(0) {}
    mojo::internal::Pointer<internal::XRInputSourceSpaceInfo_Data> f_input_source_space_info;
    mojo::internal::Pointer<internal::PlaneId_Data> f_plane_id;
    mojo::internal::Pointer<internal::MeshId_Data> f_mesh_id;
    mojo::internal::Pointer<internal::AnchorId_Data> f_anchor_id;
    int32_t f_reference_space_type;
    mojo::internal::Pointer<internal::XRHandJointSpaceInfo_Data> f_hand_joint_space_info;
    uint32_t f_image_index;
    uint64_t unknown;
  };

  uint32_t size;
  XRNativeOriginInformation_Tag tag;
  Union_ data;
};
static_assert(sizeof(XRNativeOriginInformation_Data) == mojo::internal::kUnionDataSize,
              "Bad sizeof(XRNativeOriginInformation_Data)");


class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS_SHARED) XRDepthData_Data {
 public:
  // Used to identify Mojom Union Data Classes.
  typedef void MojomUnionDataType;

  XRDepthData_Data() = default;
  // Do nothing in the destructor since it won't be called when it is a
  // non-inlined union.
  ~XRDepthData_Data() = default;

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

  bool is_null() const { return size == 0; }

  void set_null() {
    size = 0U;
    tag = static_cast<XRDepthData_Tag>(0);
    data.unknown = 0U;
  }

  // TODO(crbug.com/40731316): SHOUTY_CASE values are being deprecated per C++ code style
  // guidelines (https://google.github.io/styleguide/cppguide.html#Enumerator_Names),
  // please use kCamelCase values instead.  Cleanup NULL_VALUE, BOOL_VALUE, INT_VALUE, etc.
  // generation once codebase is transitioned to kNullValue, kBoolValue, kIntValue, etc.
  enum class XRDepthData_Tag : uint32_t {

    
    kDataStillValid,
    
    kUpdatedDepthData,
  };

  // A note on layout:
  // "Each non-static data member is allocated as if it were the sole member of
  // a struct." - Section 9.5.2 ISO/IEC 14882:2011 (The C++ Spec)
  union MOJO_ALIGNAS(8) Union_ {
    Union_() : unknown(0) {}
    mojo::internal::Pointer<internal::XRDepthDataStillValid_Data> f_data_still_valid;
    mojo::internal::Pointer<internal::XRDepthDataUpdated_Data> f_updated_depth_data;
    uint64_t unknown;
  };

  uint32_t size;
  XRDepthData_Tag tag;
  Union_ data;
};
static_assert(sizeof(XRDepthData_Data) == mojo::internal::kUnionDataSize,
              "Bad sizeof(XRDepthData_Data)");


class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS_SHARED) XRLayerSpecificData_Data {
 public:
  // Used to identify Mojom Union Data Classes.
  typedef void MojomUnionDataType;

  XRLayerSpecificData_Data() = default;
  // Do nothing in the destructor since it won't be called when it is a
  // non-inlined union.
  ~XRLayerSpecificData_Data() = default;

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

  bool is_null() const { return size == 0; }

  void set_null() {
    size = 0U;
    tag = static_cast<XRLayerSpecificData_Tag>(0);
    data.unknown = 0U;
  }

  // TODO(crbug.com/40731316): SHOUTY_CASE values are being deprecated per C++ code style
  // guidelines (https://google.github.io/styleguide/cppguide.html#Enumerator_Names),
  // please use kCamelCase values instead.  Cleanup NULL_VALUE, BOOL_VALUE, INT_VALUE, etc.
  // generation once codebase is transitioned to kNullValue, kBoolValue, kIntValue, etc.
  enum class XRLayerSpecificData_Tag : uint32_t {

    
    kProjection,
    
    kQuad,
    
    kCylinder,
    
    kEquirect,
    
    kCube,
  };

  // A note on layout:
  // "Each non-static data member is allocated as if it were the sole member of
  // a struct." - Section 9.5.2 ISO/IEC 14882:2011 (The C++ Spec)
  union MOJO_ALIGNAS(8) Union_ {
    Union_() : unknown(0) {}
    mojo::internal::Pointer<internal::XRProjectionLayerData_Data> f_projection;
    mojo::internal::Pointer<internal::XRQuadLayerData_Data> f_quad;
    mojo::internal::Pointer<internal::XRCylinderLayerData_Data> f_cylinder;
    mojo::internal::Pointer<internal::XREquirectLayerData_Data> f_equirect;
    mojo::internal::Pointer<internal::XRCubeLayerData_Data> f_cube;
    uint64_t unknown;
  };

  uint32_t size;
  XRLayerSpecificData_Tag tag;
  Union_ data;
};
static_assert(sizeof(XRLayerSpecificData_Data) == mojo::internal::kUnionDataSize,
              "Bad sizeof(XRLayerSpecificData_Data)");


class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS_SHARED) RequestSessionResult_Data {
 public:
  // Used to identify Mojom Union Data Classes.
  typedef void MojomUnionDataType;

  RequestSessionResult_Data() = default;
  // Do nothing in the destructor since it won't be called when it is a
  // non-inlined union.
  ~RequestSessionResult_Data() = default;

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

  bool is_null() const { return size == 0; }

  void set_null() {
    size = 0U;
    tag = static_cast<RequestSessionResult_Tag>(0);
    data.unknown = 0U;
  }

  // TODO(crbug.com/40731316): SHOUTY_CASE values are being deprecated per C++ code style
  // guidelines (https://google.github.io/styleguide/cppguide.html#Enumerator_Names),
  // please use kCamelCase values instead.  Cleanup NULL_VALUE, BOOL_VALUE, INT_VALUE, etc.
  // generation once codebase is transitioned to kNullValue, kBoolValue, kIntValue, etc.
  enum class RequestSessionResult_Tag : uint32_t {

    
    kSuccess,
    
    kFailureReason,
  };

  // A note on layout:
  // "Each non-static data member is allocated as if it were the sole member of
  // a struct." - Section 9.5.2 ISO/IEC 14882:2011 (The C++ Spec)
  union MOJO_ALIGNAS(8) Union_ {
    Union_() : unknown(0) {}
    mojo::internal::Pointer<internal::RequestSessionSuccess_Data> f_success;
    int32_t f_failure_reason;
    uint64_t unknown;
  };

  uint32_t size;
  RequestSessionResult_Tag tag;
  Union_ data;
};
static_assert(sizeof(RequestSessionResult_Data) == mojo::internal::kUnionDataSize,
              "Bad sizeof(RequestSessionResult_Data)");
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS_SHARED) XRDepthConfig_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  int32_t depth_usage;
  int32_t depth_data_format;
  uint8_t depth_type_$flag : 1;
  uint8_t pad2_[3];
  int32_t depth_type_$value;

 private:
  friend class mojo::internal::MessageFragment<XRDepthConfig_Data>;

  XRDepthConfig_Data();
  ~XRDepthConfig_Data() = delete;
};
static_assert(sizeof(XRDepthConfig_Data) == 24,
              "Bad sizeof(XRDepthConfig_Data)");
// Used by XRDepthConfig::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct XRDepthConfig_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  XRDepthConfig_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~XRDepthConfig_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<XRDepthConfig_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    XRDepthConfig_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS_SHARED) XRSessionDeviceConfig_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  float default_framebuffer_scale;
  uint8_t supports_viewport_scaling : 1;
  uint8_t enable_anti_aliasing : 1;
  uint8_t pad2_[1];
  uint16_t max_render_layers;
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<internal::XRView_Data>>> views;
  mojo::internal::Pointer<internal::XRDepthConfig_Data> depth_configuration;

 private:
  friend class mojo::internal::MessageFragment<XRSessionDeviceConfig_Data>;

  XRSessionDeviceConfig_Data();
  ~XRSessionDeviceConfig_Data() = delete;
};
static_assert(sizeof(XRSessionDeviceConfig_Data) == 32,
              "Bad sizeof(XRSessionDeviceConfig_Data)");
// Used by XRSessionDeviceConfig::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct XRSessionDeviceConfig_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  XRSessionDeviceConfig_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~XRSessionDeviceConfig_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<XRSessionDeviceConfig_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    XRSessionDeviceConfig_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS_SHARED) XRSession_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Interface_Data data_provider;
  mojo::internal::Interface_Data layer_manager;
  mojo::internal::Handle_Data client_receiver;
  int32_t enviroment_blend_mode;
  mojo::internal::Pointer<internal::XRPresentationConnection_Data> submit_frame_sink;
  mojo::internal::Pointer<mojo::internal::Array_Data<int32_t>> enabled_features;
  mojo::internal::Pointer<internal::XRSessionDeviceConfig_Data> device_config;
  int32_t interaction_mode;
  uint8_t wants_fullscreen : 1;
  uint8_t padfinal_[3];

 private:
  friend class mojo::internal::MessageFragment<XRSession_Data>;

  XRSession_Data();
  ~XRSession_Data() = delete;
};
static_assert(sizeof(XRSession_Data) == 64,
              "Bad sizeof(XRSession_Data)");
// Used by XRSession::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct XRSession_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  XRSession_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~XRSession_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<XRSession_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    XRSession_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS_SHARED) XRPresentationConnection_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Interface_Data provider;
  mojo::internal::Handle_Data client_receiver;
  uint8_t pad1_[4];
  mojo::internal::Pointer<internal::XRPresentationTransportOptions_Data> transport_options;

 private:
  friend class mojo::internal::MessageFragment<XRPresentationConnection_Data>;

  XRPresentationConnection_Data();
  ~XRPresentationConnection_Data() = delete;
};
static_assert(sizeof(XRPresentationConnection_Data) == 32,
              "Bad sizeof(XRPresentationConnection_Data)");
// Used by XRPresentationConnection::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct XRPresentationConnection_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  XRPresentationConnection_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~XRPresentationConnection_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<XRPresentationConnection_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    XRPresentationConnection_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS_SHARED) XRInputSourceDescription_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  int32_t target_ray_mode;
  int32_t handedness;
  mojo::internal::Pointer<::gfx::mojom::internal::Transform_Data> input_from_pointer;
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<mojo::internal::String_Data>>> profiles;

 private:
  friend class mojo::internal::MessageFragment<XRInputSourceDescription_Data>;

  XRInputSourceDescription_Data();
  ~XRInputSourceDescription_Data() = delete;
};
static_assert(sizeof(XRInputSourceDescription_Data) == 32,
              "Bad sizeof(XRInputSourceDescription_Data)");
// Used by XRInputSourceDescription::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct XRInputSourceDescription_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  XRInputSourceDescription_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~XRInputSourceDescription_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<XRInputSourceDescription_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    XRInputSourceDescription_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS_SHARED) XRInputSourceState_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  uint32_t source_id;
  uint8_t emulated_position : 1;
  uint8_t is_auxiliary : 1;
  uint8_t primary_input_pressed : 1;
  uint8_t primary_input_clicked : 1;
  uint8_t primary_squeeze_pressed : 1;
  uint8_t primary_squeeze_clicked : 1;
  uint8_t pad6_[3];
  mojo::internal::Pointer<internal::XRInputSourceDescription_Data> description;
  mojo::internal::Pointer<::gfx::mojom::internal::Transform_Data> mojo_from_input;
  mojo::internal::Pointer<::device::mojom::internal::Gamepad_Data> gamepad;
  mojo::internal::Pointer<::gfx::mojom::internal::PointF_Data> overlay_pointer_position;
  mojo::internal::Pointer<::device::mojom::internal::XRHandTrackingData_Data> hand_tracking_data;

 private:
  friend class mojo::internal::MessageFragment<XRInputSourceState_Data>;

  XRInputSourceState_Data();
  ~XRInputSourceState_Data() = delete;
};
static_assert(sizeof(XRInputSourceState_Data) == 56,
              "Bad sizeof(XRInputSourceState_Data)");
// Used by XRInputSourceState::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct XRInputSourceState_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  XRInputSourceState_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~XRInputSourceState_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<XRInputSourceState_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    XRInputSourceState_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS_SHARED) VRFieldOfView_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  float up_degrees;
  float down_degrees;
  float left_degrees;
  float right_degrees;

 private:
  friend class mojo::internal::MessageFragment<VRFieldOfView_Data>;

  VRFieldOfView_Data();
  ~VRFieldOfView_Data() = delete;
};
static_assert(sizeof(VRFieldOfView_Data) == 24,
              "Bad sizeof(VRFieldOfView_Data)");
// Used by VRFieldOfView::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct VRFieldOfView_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  VRFieldOfView_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~VRFieldOfView_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<VRFieldOfView_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    VRFieldOfView_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS_SHARED) VRPose_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<::gfx::mojom::internal::Quaternion_Data> orientation;
  mojo::internal::Pointer<::gfx::mojom::internal::Point3F_Data> position;
  uint8_t emulated_position : 1;
  uint8_t padfinal_[7];

 private:
  friend class mojo::internal::MessageFragment<VRPose_Data>;

  VRPose_Data();
  ~VRPose_Data() = delete;
};
static_assert(sizeof(VRPose_Data) == 32,
              "Bad sizeof(VRPose_Data)");
// Used by VRPose::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct VRPose_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  VRPose_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~VRPose_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<VRPose_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    VRPose_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS_SHARED) Pose_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<::gfx::mojom::internal::Quaternion_Data> orientation;
  mojo::internal::Pointer<::gfx::mojom::internal::Point3F_Data> position;

 private:
  friend class mojo::internal::MessageFragment<Pose_Data>;

  Pose_Data();
  ~Pose_Data() = delete;
};
static_assert(sizeof(Pose_Data) == 24,
              "Bad sizeof(Pose_Data)");
// Used by Pose::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct Pose_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  Pose_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~Pose_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<Pose_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    Pose_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS_SHARED) AnchorId_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  uint64_t id_value;

 private:
  friend class mojo::internal::MessageFragment<AnchorId_Data>;

  AnchorId_Data();
  ~AnchorId_Data() = delete;
};
static_assert(sizeof(AnchorId_Data) == 16,
              "Bad sizeof(AnchorId_Data)");
// Used by AnchorId::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct AnchorId_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  AnchorId_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~AnchorId_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<AnchorId_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    AnchorId_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS_SHARED) HitTestSubscriptionId_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  uint64_t id_value;

 private:
  friend class mojo::internal::MessageFragment<HitTestSubscriptionId_Data>;

  HitTestSubscriptionId_Data();
  ~HitTestSubscriptionId_Data() = delete;
};
static_assert(sizeof(HitTestSubscriptionId_Data) == 16,
              "Bad sizeof(HitTestSubscriptionId_Data)");
// Used by HitTestSubscriptionId::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct HitTestSubscriptionId_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  HitTestSubscriptionId_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~HitTestSubscriptionId_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<HitTestSubscriptionId_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    HitTestSubscriptionId_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS_SHARED) PlaneId_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  uint64_t id_value;

 private:
  friend class mojo::internal::MessageFragment<PlaneId_Data>;

  PlaneId_Data();
  ~PlaneId_Data() = delete;
};
static_assert(sizeof(PlaneId_Data) == 16,
              "Bad sizeof(PlaneId_Data)");
// Used by PlaneId::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct PlaneId_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  PlaneId_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~PlaneId_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<PlaneId_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    PlaneId_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS_SHARED) MeshId_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  uint64_t id_value;

 private:
  friend class mojo::internal::MessageFragment<MeshId_Data>;

  MeshId_Data();
  ~MeshId_Data() = delete;
};
static_assert(sizeof(MeshId_Data) == 16,
              "Bad sizeof(MeshId_Data)");
// Used by MeshId::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct MeshId_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  MeshId_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~MeshId_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<MeshId_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    MeshId_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS_SHARED) XrVisibilityMaskId_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  uint64_t id_value;

 private:
  friend class mojo::internal::MessageFragment<XrVisibilityMaskId_Data>;

  XrVisibilityMaskId_Data();
  ~XrVisibilityMaskId_Data() = delete;
};
static_assert(sizeof(XrVisibilityMaskId_Data) == 16,
              "Bad sizeof(XrVisibilityMaskId_Data)");
// Used by XrVisibilityMaskId::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct XrVisibilityMaskId_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  XrVisibilityMaskId_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~XrVisibilityMaskId_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<XrVisibilityMaskId_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    XrVisibilityMaskId_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS_SHARED) XRRay_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<::gfx::mojom::internal::Point3F_Data> origin;
  mojo::internal::Pointer<::gfx::mojom::internal::Vector3dF_Data> direction;

 private:
  friend class mojo::internal::MessageFragment<XRRay_Data>;

  XRRay_Data();
  ~XRRay_Data() = delete;
};
static_assert(sizeof(XRRay_Data) == 24,
              "Bad sizeof(XRRay_Data)");
// Used by XRRay::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct XRRay_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  XRRay_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~XRRay_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<XRRay_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    XRRay_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS_SHARED) XRHitResult_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<internal::Pose_Data> mojo_from_result;
  mojo::internal::Pointer<internal::PlaneId_Data> plane_id;

 private:
  friend class mojo::internal::MessageFragment<XRHitResult_Data>;

  XRHitResult_Data();
  ~XRHitResult_Data() = delete;
};
static_assert(sizeof(XRHitResult_Data) == 24,
              "Bad sizeof(XRHitResult_Data)");
// Used by XRHitResult::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct XRHitResult_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  XRHitResult_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~XRHitResult_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<XRHitResult_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    XRHitResult_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS_SHARED) XRViewGeometry_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<internal::VRFieldOfView_Data> field_of_view;
  mojo::internal::Pointer<::gfx::mojom::internal::Transform_Data> mojo_from_view;

 private:
  friend class mojo::internal::MessageFragment<XRViewGeometry_Data>;

  XRViewGeometry_Data();
  ~XRViewGeometry_Data() = delete;
};
static_assert(sizeof(XRViewGeometry_Data) == 24,
              "Bad sizeof(XRViewGeometry_Data)");
// Used by XRViewGeometry::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct XRViewGeometry_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  XRViewGeometry_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~XRViewGeometry_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<XRViewGeometry_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    XRViewGeometry_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS_SHARED) XRVisibilityMask_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<::gfx::mojom::internal::PointF_Data>>> vertices;
  mojo::internal::Pointer<mojo::internal::Array_Data<uint32_t>> unvalidated_indices;

 private:
  friend class mojo::internal::MessageFragment<XRVisibilityMask_Data>;

  XRVisibilityMask_Data();
  ~XRVisibilityMask_Data() = delete;
};
static_assert(sizeof(XRVisibilityMask_Data) == 24,
              "Bad sizeof(XRVisibilityMask_Data)");
// Used by XRVisibilityMask::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct XRVisibilityMask_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  XRVisibilityMask_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~XRVisibilityMask_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<XRVisibilityMask_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    XRVisibilityMask_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS_SHARED) XRView_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  int32_t eye;
  uint8_t is_first_person_observer : 1;
  uint8_t pad1_[3];
  mojo::internal::Pointer<internal::XRViewGeometry_Data> geometry;
  mojo::internal::Pointer<::gfx::mojom::internal::Rect_Data> viewport;
  internal::XRDepthData_Data depth_data;
  mojo::internal::Pointer<internal::XRVisibilityMask_Data> visibility_mask;
  mojo::internal::Pointer<internal::XrVisibilityMaskId_Data> visibility_mask_id;

 private:
  friend class mojo::internal::MessageFragment<XRView_Data>;

  XRView_Data();
  ~XRView_Data() = delete;
};
static_assert(sizeof(XRView_Data) == 64,
              "Bad sizeof(XRView_Data)");
// Used by XRView::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct XRView_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  XRView_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~XRView_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<XRView_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    XRView_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS_SHARED) VRStageParameters_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<::gfx::mojom::internal::Transform_Data> mojo_from_stage;
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<::gfx::mojom::internal::Point3F_Data>>> bounds;

 private:
  friend class mojo::internal::MessageFragment<VRStageParameters_Data>;

  VRStageParameters_Data();
  ~VRStageParameters_Data() = delete;
};
static_assert(sizeof(VRStageParameters_Data) == 24,
              "Bad sizeof(VRStageParameters_Data)");
// Used by VRStageParameters::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct VRStageParameters_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  VRStageParameters_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~VRStageParameters_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<VRStageParameters_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    VRStageParameters_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS_SHARED) XRPresentationTransportOptions_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  int32_t transport_method;
  uint8_t wait_for_transfer_notification : 1;
  uint8_t wait_for_render_notification : 1;
  uint8_t wait_for_gpu_fence : 1;
  uint8_t padfinal_[3];

 private:
  friend class mojo::internal::MessageFragment<XRPresentationTransportOptions_Data>;

  XRPresentationTransportOptions_Data();
  ~XRPresentationTransportOptions_Data() = delete;
};
static_assert(sizeof(XRPresentationTransportOptions_Data) == 16,
              "Bad sizeof(XRPresentationTransportOptions_Data)");
// Used by XRPresentationTransportOptions::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct XRPresentationTransportOptions_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  XRPresentationTransportOptions_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~XRPresentationTransportOptions_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<XRPresentationTransportOptions_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    XRPresentationTransportOptions_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS_SHARED) XRInputSourceSpaceInfo_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  uint32_t input_source_id;
  int32_t input_source_space_type;

 private:
  friend class mojo::internal::MessageFragment<XRInputSourceSpaceInfo_Data>;

  XRInputSourceSpaceInfo_Data();
  ~XRInputSourceSpaceInfo_Data() = delete;
};
static_assert(sizeof(XRInputSourceSpaceInfo_Data) == 16,
              "Bad sizeof(XRInputSourceSpaceInfo_Data)");
// Used by XRInputSourceSpaceInfo::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct XRInputSourceSpaceInfo_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  XRInputSourceSpaceInfo_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~XRInputSourceSpaceInfo_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<XRInputSourceSpaceInfo_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    XRInputSourceSpaceInfo_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS_SHARED) XRHandJointSpaceInfo_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  int32_t handedness;
  int32_t joint;

 private:
  friend class mojo::internal::MessageFragment<XRHandJointSpaceInfo_Data>;

  XRHandJointSpaceInfo_Data();
  ~XRHandJointSpaceInfo_Data() = delete;
};
static_assert(sizeof(XRHandJointSpaceInfo_Data) == 16,
              "Bad sizeof(XRHandJointSpaceInfo_Data)");
// Used by XRHandJointSpaceInfo::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct XRHandJointSpaceInfo_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  XRHandJointSpaceInfo_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~XRHandJointSpaceInfo_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<XRHandJointSpaceInfo_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    XRHandJointSpaceInfo_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS_SHARED) XRPlanePointData_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  float x;
  float z;

 private:
  friend class mojo::internal::MessageFragment<XRPlanePointData_Data>;

  XRPlanePointData_Data();
  ~XRPlanePointData_Data() = delete;
};
static_assert(sizeof(XRPlanePointData_Data) == 16,
              "Bad sizeof(XRPlanePointData_Data)");
// Used by XRPlanePointData::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct XRPlanePointData_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  XRPlanePointData_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~XRPlanePointData_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<XRPlanePointData_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    XRPlanePointData_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS_SHARED) XRPlaneData_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<internal::PlaneId_Data> id;
  int32_t orientation;
  uint8_t semantic_label_$flag : 1;
  uint8_t pad2_[3];
  mojo::internal::Pointer<internal::Pose_Data> mojo_from_plane;
  int32_t semantic_label_$value;
  uint8_t pad4_[4];
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<internal::XRPlanePointData_Data>>> polygon;

 private:
  friend class mojo::internal::MessageFragment<XRPlaneData_Data>;

  XRPlaneData_Data();
  ~XRPlaneData_Data() = delete;
};
static_assert(sizeof(XRPlaneData_Data) == 48,
              "Bad sizeof(XRPlaneData_Data)");
// Used by XRPlaneData::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct XRPlaneData_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  XRPlaneData_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~XRPlaneData_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<XRPlaneData_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    XRPlaneData_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS_SHARED) XRPlaneDetectionData_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<internal::PlaneId_Data>>> all_planes_ids;
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<internal::XRPlaneData_Data>>> updated_planes_data;

 private:
  friend class mojo::internal::MessageFragment<XRPlaneDetectionData_Data>;

  XRPlaneDetectionData_Data();
  ~XRPlaneDetectionData_Data() = delete;
};
static_assert(sizeof(XRPlaneDetectionData_Data) == 24,
              "Bad sizeof(XRPlaneDetectionData_Data)");
// Used by XRPlaneDetectionData::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct XRPlaneDetectionData_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  XRPlaneDetectionData_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~XRPlaneDetectionData_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<XRPlaneDetectionData_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    XRPlaneDetectionData_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS_SHARED) XRMeshData_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<internal::MeshId_Data> id;
  mojo::internal::Pointer<internal::Pose_Data> mojo_from_mesh;
  mojo::internal::Pointer<mojo::internal::Array_Data<float>> vertices;
  mojo::internal::Pointer<mojo::internal::Array_Data<uint32_t>> indices;
  uint8_t semantic_label_$flag : 1;
  uint8_t pad4_[3];
  int32_t semantic_label_$value;

 private:
  friend class mojo::internal::MessageFragment<XRMeshData_Data>;

  XRMeshData_Data();
  ~XRMeshData_Data() = delete;
};
static_assert(sizeof(XRMeshData_Data) == 48,
              "Bad sizeof(XRMeshData_Data)");
// Used by XRMeshData::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct XRMeshData_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  XRMeshData_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~XRMeshData_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<XRMeshData_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    XRMeshData_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS_SHARED) XRMeshDetectionData_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<internal::MeshId_Data>>> all_meshes_ids;
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<internal::XRMeshData_Data>>> updated_meshes_data;

 private:
  friend class mojo::internal::MessageFragment<XRMeshDetectionData_Data>;

  XRMeshDetectionData_Data();
  ~XRMeshDetectionData_Data() = delete;
};
static_assert(sizeof(XRMeshDetectionData_Data) == 24,
              "Bad sizeof(XRMeshDetectionData_Data)");
// Used by XRMeshDetectionData::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct XRMeshDetectionData_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  XRMeshDetectionData_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~XRMeshDetectionData_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<XRMeshDetectionData_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    XRMeshDetectionData_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS_SHARED) XRAnchorData_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<internal::AnchorId_Data> id;
  mojo::internal::Pointer<internal::Pose_Data> mojo_from_anchor;

 private:
  friend class mojo::internal::MessageFragment<XRAnchorData_Data>;

  XRAnchorData_Data();
  ~XRAnchorData_Data() = delete;
};
static_assert(sizeof(XRAnchorData_Data) == 24,
              "Bad sizeof(XRAnchorData_Data)");
// Used by XRAnchorData::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct XRAnchorData_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  XRAnchorData_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~XRAnchorData_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<XRAnchorData_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    XRAnchorData_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS_SHARED) XRAnchorsData_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<internal::AnchorId_Data>>> all_anchors_ids;
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<internal::XRAnchorData_Data>>> updated_anchors_data;

 private:
  friend class mojo::internal::MessageFragment<XRAnchorsData_Data>;

  XRAnchorsData_Data();
  ~XRAnchorsData_Data() = delete;
};
static_assert(sizeof(XRAnchorsData_Data) == 24,
              "Bad sizeof(XRAnchorsData_Data)");
// Used by XRAnchorsData::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct XRAnchorsData_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  XRAnchorsData_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~XRAnchorsData_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<XRAnchorsData_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    XRAnchorsData_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS_SHARED) XRHitTestSubscriptionResultData_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<internal::HitTestSubscriptionId_Data> subscription_id;
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<internal::XRHitResult_Data>>> hit_test_results;

 private:
  friend class mojo::internal::MessageFragment<XRHitTestSubscriptionResultData_Data>;

  XRHitTestSubscriptionResultData_Data();
  ~XRHitTestSubscriptionResultData_Data() = delete;
};
static_assert(sizeof(XRHitTestSubscriptionResultData_Data) == 24,
              "Bad sizeof(XRHitTestSubscriptionResultData_Data)");
// Used by XRHitTestSubscriptionResultData::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct XRHitTestSubscriptionResultData_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  XRHitTestSubscriptionResultData_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~XRHitTestSubscriptionResultData_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<XRHitTestSubscriptionResultData_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    XRHitTestSubscriptionResultData_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS_SHARED) XRHitTestTransientInputSubscriptionResultData_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<internal::HitTestSubscriptionId_Data> subscription_id;
  mojo::internal::Pointer<mojo::internal::Map_Data<uint32_t, mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<internal::XRHitResult_Data>>>>> input_source_id_to_hit_test_results;

 private:
  friend class mojo::internal::MessageFragment<XRHitTestTransientInputSubscriptionResultData_Data>;

  XRHitTestTransientInputSubscriptionResultData_Data();
  ~XRHitTestTransientInputSubscriptionResultData_Data() = delete;
};
static_assert(sizeof(XRHitTestTransientInputSubscriptionResultData_Data) == 24,
              "Bad sizeof(XRHitTestTransientInputSubscriptionResultData_Data)");
// Used by XRHitTestTransientInputSubscriptionResultData::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct XRHitTestTransientInputSubscriptionResultData_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  XRHitTestTransientInputSubscriptionResultData_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~XRHitTestTransientInputSubscriptionResultData_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<XRHitTestTransientInputSubscriptionResultData_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    XRHitTestTransientInputSubscriptionResultData_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS_SHARED) XRHitTestSubscriptionResultsData_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<internal::XRHitTestSubscriptionResultData_Data>>> results;
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<internal::XRHitTestTransientInputSubscriptionResultData_Data>>> transient_input_results;

 private:
  friend class mojo::internal::MessageFragment<XRHitTestSubscriptionResultsData_Data>;

  XRHitTestSubscriptionResultsData_Data();
  ~XRHitTestSubscriptionResultsData_Data() = delete;
};
static_assert(sizeof(XRHitTestSubscriptionResultsData_Data) == 24,
              "Bad sizeof(XRHitTestSubscriptionResultsData_Data)");
// Used by XRHitTestSubscriptionResultsData::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct XRHitTestSubscriptionResultsData_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  XRHitTestSubscriptionResultsData_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~XRHitTestSubscriptionResultsData_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<XRHitTestSubscriptionResultsData_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    XRHitTestSubscriptionResultsData_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS_SHARED) RgbTupleF32_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  float red;
  float green;
  float blue;
  uint8_t padfinal_[4];

 private:
  friend class mojo::internal::MessageFragment<RgbTupleF32_Data>;

  RgbTupleF32_Data();
  ~RgbTupleF32_Data() = delete;
};
static_assert(sizeof(RgbTupleF32_Data) == 24,
              "Bad sizeof(RgbTupleF32_Data)");
// Used by RgbTupleF32::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct RgbTupleF32_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  RgbTupleF32_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~RgbTupleF32_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<RgbTupleF32_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    RgbTupleF32_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS_SHARED) XRSphericalHarmonics_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<internal::RgbTupleF32_Data>>> coefficients;

 private:
  friend class mojo::internal::MessageFragment<XRSphericalHarmonics_Data>;

  XRSphericalHarmonics_Data();
  ~XRSphericalHarmonics_Data() = delete;
};
static_assert(sizeof(XRSphericalHarmonics_Data) == 16,
              "Bad sizeof(XRSphericalHarmonics_Data)");
// Used by XRSphericalHarmonics::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct XRSphericalHarmonics_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  XRSphericalHarmonics_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~XRSphericalHarmonics_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<XRSphericalHarmonics_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    XRSphericalHarmonics_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS_SHARED) XRCubeMap_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  uint32_t width_and_height;
  uint8_t pad0_[4];
  mojo::internal::Pointer<mojo::internal::Array_Data<uint16_t>> positive_x;
  mojo::internal::Pointer<mojo::internal::Array_Data<uint16_t>> negative_x;
  mojo::internal::Pointer<mojo::internal::Array_Data<uint16_t>> positive_y;
  mojo::internal::Pointer<mojo::internal::Array_Data<uint16_t>> negative_y;
  mojo::internal::Pointer<mojo::internal::Array_Data<uint16_t>> positive_z;
  mojo::internal::Pointer<mojo::internal::Array_Data<uint16_t>> negative_z;

 private:
  friend class mojo::internal::MessageFragment<XRCubeMap_Data>;

  XRCubeMap_Data();
  ~XRCubeMap_Data() = delete;
};
static_assert(sizeof(XRCubeMap_Data) == 64,
              "Bad sizeof(XRCubeMap_Data)");
// Used by XRCubeMap::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct XRCubeMap_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  XRCubeMap_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~XRCubeMap_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<XRCubeMap_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    XRCubeMap_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS_SHARED) XRLightProbe_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<internal::XRSphericalHarmonics_Data> spherical_harmonics;
  mojo::internal::Pointer<::gfx::mojom::internal::Vector3dF_Data> main_light_direction;
  mojo::internal::Pointer<internal::RgbTupleF32_Data> main_light_intensity;

 private:
  friend class mojo::internal::MessageFragment<XRLightProbe_Data>;

  XRLightProbe_Data();
  ~XRLightProbe_Data() = delete;
};
static_assert(sizeof(XRLightProbe_Data) == 32,
              "Bad sizeof(XRLightProbe_Data)");
// Used by XRLightProbe::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct XRLightProbe_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  XRLightProbe_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~XRLightProbe_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<XRLightProbe_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    XRLightProbe_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS_SHARED) XRReflectionProbe_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<internal::XRCubeMap_Data> cube_map;

 private:
  friend class mojo::internal::MessageFragment<XRReflectionProbe_Data>;

  XRReflectionProbe_Data();
  ~XRReflectionProbe_Data() = delete;
};
static_assert(sizeof(XRReflectionProbe_Data) == 16,
              "Bad sizeof(XRReflectionProbe_Data)");
// Used by XRReflectionProbe::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct XRReflectionProbe_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  XRReflectionProbe_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~XRReflectionProbe_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<XRReflectionProbe_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    XRReflectionProbe_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS_SHARED) XRLightEstimationData_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<internal::XRLightProbe_Data> light_probe;
  mojo::internal::Pointer<internal::XRReflectionProbe_Data> reflection_probe;

 private:
  friend class mojo::internal::MessageFragment<XRLightEstimationData_Data>;

  XRLightEstimationData_Data();
  ~XRLightEstimationData_Data() = delete;
};
static_assert(sizeof(XRLightEstimationData_Data) == 24,
              "Bad sizeof(XRLightEstimationData_Data)");
// Used by XRLightEstimationData::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct XRLightEstimationData_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  XRLightEstimationData_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~XRLightEstimationData_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<XRLightEstimationData_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    XRLightEstimationData_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS_SHARED) XRDepthDataStillValid_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;

 private:
  friend class mojo::internal::MessageFragment<XRDepthDataStillValid_Data>;

  XRDepthDataStillValid_Data();
  ~XRDepthDataStillValid_Data() = delete;
};
static_assert(sizeof(XRDepthDataStillValid_Data) == 8,
              "Bad sizeof(XRDepthDataStillValid_Data)");
// Used by XRDepthDataStillValid::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct XRDepthDataStillValid_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  XRDepthDataStillValid_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~XRDepthDataStillValid_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<XRDepthDataStillValid_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    XRDepthDataStillValid_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS_SHARED) XRDepthDataUpdated_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  ::mojo_base::mojom::internal::BigBuffer_Data pixel_data;
  mojo::internal::Pointer<::gfx::mojom::internal::Transform_Data> norm_texture_from_norm_view;
  mojo::internal::Pointer<::gfx::mojom::internal::Size_Data> size;
  float raw_value_to_meters;
  uint8_t pad3_[4];
  mojo::internal::Pointer<internal::XRViewGeometry_Data> view_geometry;

 private:
  friend class mojo::internal::MessageFragment<XRDepthDataUpdated_Data>;

  XRDepthDataUpdated_Data();
  ~XRDepthDataUpdated_Data() = delete;
};
static_assert(sizeof(XRDepthDataUpdated_Data) == 56,
              "Bad sizeof(XRDepthDataUpdated_Data)");
// Used by XRDepthDataUpdated::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct XRDepthDataUpdated_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  XRDepthDataUpdated_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~XRDepthDataUpdated_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<XRDepthDataUpdated_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    XRDepthDataUpdated_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS_SHARED) XRTrackedImageData_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  uint32_t index;
  uint8_t actively_tracked : 1;
  uint8_t pad1_[3];
  mojo::internal::Pointer<internal::Pose_Data> mojo_from_image;
  float width_in_meters;
  uint8_t padfinal_[4];

 private:
  friend class mojo::internal::MessageFragment<XRTrackedImageData_Data>;

  XRTrackedImageData_Data();
  ~XRTrackedImageData_Data() = delete;
};
static_assert(sizeof(XRTrackedImageData_Data) == 32,
              "Bad sizeof(XRTrackedImageData_Data)");
// Used by XRTrackedImageData::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct XRTrackedImageData_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  XRTrackedImageData_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~XRTrackedImageData_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<XRTrackedImageData_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    XRTrackedImageData_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS_SHARED) XRTrackedImagesData_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<internal::XRTrackedImageData_Data>>> images_data;
  mojo::internal::Pointer<mojo::internal::Array_Data<bool>> image_trackable_scores;

 private:
  friend class mojo::internal::MessageFragment<XRTrackedImagesData_Data>;

  XRTrackedImagesData_Data();
  ~XRTrackedImagesData_Data() = delete;
};
static_assert(sizeof(XRTrackedImagesData_Data) == 24,
              "Bad sizeof(XRTrackedImagesData_Data)");
// Used by XRTrackedImagesData::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct XRTrackedImagesData_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  XRTrackedImagesData_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~XRTrackedImagesData_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<XRTrackedImagesData_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    XRTrackedImagesData_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS_SHARED) LayerId_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  uint64_t id_value;

 private:
  friend class mojo::internal::MessageFragment<LayerId_Data>;

  LayerId_Data();
  ~LayerId_Data() = delete;
};
static_assert(sizeof(LayerId_Data) == 16,
              "Bad sizeof(LayerId_Data)");
// Used by LayerId::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct LayerId_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  LayerId_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~LayerId_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<LayerId_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    LayerId_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS_SHARED) XRProjectionLayerData_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;

 private:
  friend class mojo::internal::MessageFragment<XRProjectionLayerData_Data>;

  XRProjectionLayerData_Data();
  ~XRProjectionLayerData_Data() = delete;
};
static_assert(sizeof(XRProjectionLayerData_Data) == 8,
              "Bad sizeof(XRProjectionLayerData_Data)");
// Used by XRProjectionLayerData::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct XRProjectionLayerData_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  XRProjectionLayerData_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~XRProjectionLayerData_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<XRProjectionLayerData_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    XRProjectionLayerData_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS_SHARED) XRQuadLayerData_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<::gfx::mojom::internal::Transform_Data> native_origin_from_layer;
  float width;
  float height;

 private:
  friend class mojo::internal::MessageFragment<XRQuadLayerData_Data>;

  XRQuadLayerData_Data();
  ~XRQuadLayerData_Data() = delete;
};
static_assert(sizeof(XRQuadLayerData_Data) == 24,
              "Bad sizeof(XRQuadLayerData_Data)");
// Used by XRQuadLayerData::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct XRQuadLayerData_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  XRQuadLayerData_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~XRQuadLayerData_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<XRQuadLayerData_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    XRQuadLayerData_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS_SHARED) XRCylinderLayerData_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<::gfx::mojom::internal::Transform_Data> native_origin_from_layer;
  float radius;
  float central_angle;
  float aspect_ratio;
  uint8_t padfinal_[4];

 private:
  friend class mojo::internal::MessageFragment<XRCylinderLayerData_Data>;

  XRCylinderLayerData_Data();
  ~XRCylinderLayerData_Data() = delete;
};
static_assert(sizeof(XRCylinderLayerData_Data) == 32,
              "Bad sizeof(XRCylinderLayerData_Data)");
// Used by XRCylinderLayerData::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct XRCylinderLayerData_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  XRCylinderLayerData_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~XRCylinderLayerData_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<XRCylinderLayerData_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    XRCylinderLayerData_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS_SHARED) XREquirectLayerData_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<::gfx::mojom::internal::Transform_Data> native_origin_from_layer;
  float radius;
  float central_horizontal_angle;
  float upper_vertical_angle;
  float lower_vertical_angle;

 private:
  friend class mojo::internal::MessageFragment<XREquirectLayerData_Data>;

  XREquirectLayerData_Data();
  ~XREquirectLayerData_Data() = delete;
};
static_assert(sizeof(XREquirectLayerData_Data) == 32,
              "Bad sizeof(XREquirectLayerData_Data)");
// Used by XREquirectLayerData::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct XREquirectLayerData_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  XREquirectLayerData_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~XREquirectLayerData_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<XREquirectLayerData_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    XREquirectLayerData_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS_SHARED) XRCubeLayerData_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<::gfx::mojom::internal::Quaternion_Data> orientation;

 private:
  friend class mojo::internal::MessageFragment<XRCubeLayerData_Data>;

  XRCubeLayerData_Data();
  ~XRCubeLayerData_Data() = delete;
};
static_assert(sizeof(XRCubeLayerData_Data) == 16,
              "Bad sizeof(XRCubeLayerData_Data)");
// Used by XRCubeLayerData::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct XRCubeLayerData_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  XRCubeLayerData_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~XRCubeLayerData_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<XRCubeLayerData_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    XRCubeLayerData_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS_SHARED) XRLayerReadOnlyData_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<internal::LayerId_Data> layer_id;
  int32_t layout;
  uint32_t texture_width;
  uint32_t texture_height;
  uint8_t is_static : 1;
  uint8_t flip_y : 1;
  uint8_t needs_raster_access : 1;
  uint8_t padfinal_[3];

 private:
  friend class mojo::internal::MessageFragment<XRLayerReadOnlyData_Data>;

  XRLayerReadOnlyData_Data();
  ~XRLayerReadOnlyData_Data() = delete;
};
static_assert(sizeof(XRLayerReadOnlyData_Data) == 32,
              "Bad sizeof(XRLayerReadOnlyData_Data)");
// Used by XRLayerReadOnlyData::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct XRLayerReadOnlyData_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  XRLayerReadOnlyData_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~XRLayerReadOnlyData_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<XRLayerReadOnlyData_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    XRLayerReadOnlyData_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS_SHARED) XRLayerMutableData_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  uint8_t blend_texture_source_alpha : 1;
  uint8_t force_mono_presentation : 1;
  uint8_t pad1_[3];
  float opacity;
  internal::XRNativeOriginInformation_Data native_origin_information;
  internal::XRLayerSpecificData_Data layer_data;

 private:
  friend class mojo::internal::MessageFragment<XRLayerMutableData_Data>;

  XRLayerMutableData_Data();
  ~XRLayerMutableData_Data() = delete;
};
static_assert(sizeof(XRLayerMutableData_Data) == 48,
              "Bad sizeof(XRLayerMutableData_Data)");
// Used by XRLayerMutableData::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct XRLayerMutableData_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  XRLayerMutableData_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~XRLayerMutableData_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<XRLayerMutableData_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    XRLayerMutableData_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS_SHARED) XRCompositionLayerData_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<internal::XRLayerReadOnlyData_Data> read_only_data;
  mojo::internal::Pointer<internal::XRLayerMutableData_Data> mutable_data;

 private:
  friend class mojo::internal::MessageFragment<XRCompositionLayerData_Data>;

  XRCompositionLayerData_Data();
  ~XRCompositionLayerData_Data() = delete;
};
static_assert(sizeof(XRCompositionLayerData_Data) == 24,
              "Bad sizeof(XRCompositionLayerData_Data)");
// Used by XRCompositionLayerData::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct XRCompositionLayerData_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  XRCompositionLayerData_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~XRCompositionLayerData_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<XRCompositionLayerData_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    XRCompositionLayerData_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS_SHARED) XRLayerFrameData_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<internal::LayerId_Data> layer_id;
  mojo::internal::Pointer<::gpu::mojom::internal::ExportedSharedImage_Data> buffer_shared_image;
  mojo::internal::Pointer<::gpu::mojom::internal::SyncToken_Data> buffer_sync_token;

 private:
  friend class mojo::internal::MessageFragment<XRLayerFrameData_Data>;

  XRLayerFrameData_Data();
  ~XRLayerFrameData_Data() = delete;
};
static_assert(sizeof(XRLayerFrameData_Data) == 32,
              "Bad sizeof(XRLayerFrameData_Data)");
// Used by XRLayerFrameData::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct XRLayerFrameData_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  XRLayerFrameData_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~XRLayerFrameData_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<XRLayerFrameData_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    XRLayerFrameData_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS_SHARED) XRRenderInfo_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  int16_t frame_id;
  uint8_t pad0_[6];
  mojo::internal::Pointer<internal::VRPose_Data> mojo_from_viewer;
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<internal::XRView_Data>>> views;

 private:
  friend class mojo::internal::MessageFragment<XRRenderInfo_Data>;

  XRRenderInfo_Data();
  ~XRRenderInfo_Data() = delete;
};
static_assert(sizeof(XRRenderInfo_Data) == 32,
              "Bad sizeof(XRRenderInfo_Data)");
// Used by XRRenderInfo::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct XRRenderInfo_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  XRRenderInfo_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~XRRenderInfo_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<XRRenderInfo_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    XRRenderInfo_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS_SHARED) XRFrameData_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<internal::XRRenderInfo_Data> render_info;
  mojo::internal::Pointer<::mojo_base::mojom::internal::TimeDelta_Data> time_delta;
  mojo::internal::Pointer<::gpu::mojom::internal::ExportedSharedImage_Data> buffer_shared_image;
  mojo::internal::Pointer<::gpu::mojom::internal::SyncToken_Data> buffer_sync_token;
  mojo::internal::Pointer<::gpu::mojom::internal::ExportedSharedImage_Data> camera_image_buffer_shared_image;
  mojo::internal::Pointer<::gpu::mojom::internal::SyncToken_Data> camera_image_buffer_sync_token;
  mojo::internal::Pointer<::gfx::mojom::internal::Size_Data> camera_image_size;
  uint8_t mojo_space_reset : 1;
  uint8_t pad7_[3];
  uint32_t stage_parameters_id;
  mojo::internal::Pointer<::gfx::mojom::internal::Transform_Data> mojo_from_floor;
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<internal::XRInputSourceState_Data>>> input_state;
  mojo::internal::Pointer<internal::VRStageParameters_Data> stage_parameters;
  mojo::internal::Pointer<internal::XRPlaneDetectionData_Data> detected_planes_data;
  mojo::internal::Pointer<internal::XRMeshDetectionData_Data> detected_meshes_data;
  mojo::internal::Pointer<internal::XRAnchorsData_Data> anchors_data;
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<internal::XRLayerFrameData_Data>>> composition_layers_data;
  mojo::internal::Pointer<internal::XRLightEstimationData_Data> light_estimation_data;
  mojo::internal::Pointer<internal::XRHitTestSubscriptionResultsData_Data> hit_test_subscription_results;
  float rendering_time_ratio;
  uint8_t pad18_[4];
  mojo::internal::Pointer<internal::XRTrackedImagesData_Data> tracked_images;

 private:
  friend class mojo::internal::MessageFragment<XRFrameData_Data>;

  XRFrameData_Data();
  ~XRFrameData_Data() = delete;
};
static_assert(sizeof(XRFrameData_Data) == 160,
              "Bad sizeof(XRFrameData_Data)");
// Used by XRFrameData::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct XRFrameData_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  XRFrameData_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~XRFrameData_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<XRFrameData_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    XRFrameData_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS_SHARED) RequestSessionSuccess_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<internal::XRSession_Data> session;
  uint64_t trace_id;
  mojo::internal::Interface_Data metrics_recorder;
  mojo::internal::Interface_Data xr_internals_listener;

 private:
  friend class mojo::internal::MessageFragment<RequestSessionSuccess_Data>;

  RequestSessionSuccess_Data();
  ~RequestSessionSuccess_Data() = delete;
};
static_assert(sizeof(RequestSessionSuccess_Data) == 40,
              "Bad sizeof(RequestSessionSuccess_Data)");
// Used by RequestSessionSuccess::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct RequestSessionSuccess_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  RequestSessionSuccess_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~RequestSessionSuccess_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<RequestSessionSuccess_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    RequestSessionSuccess_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS_SHARED) XRFrameDataRequestOptions_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  uint8_t include_lighting_estimation_data : 1;
  uint8_t depth_active : 1;
  uint8_t pad1_[3];
  uint32_t stage_parameters_id;

 private:
  friend class mojo::internal::MessageFragment<XRFrameDataRequestOptions_Data>;

  XRFrameDataRequestOptions_Data();
  ~XRFrameDataRequestOptions_Data() = delete;
};
static_assert(sizeof(XRFrameDataRequestOptions_Data) == 16,
              "Bad sizeof(XRFrameDataRequestOptions_Data)");
// Used by XRFrameDataRequestOptions::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct XRFrameDataRequestOptions_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  XRFrameDataRequestOptions_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~XRFrameDataRequestOptions_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<XRFrameDataRequestOptions_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    XRFrameDataRequestOptions_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class COMPONENT_EXPORT(DEVICE_VR_SERVICE_MOJO_BINDINGS_SHARED) XRLayerUpdate_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<internal::LayerId_Data> layer_id;
  mojo::internal::Pointer<::gpu::mojom::internal::SharedImageExportResult_Data> shared_image_export_result;

 private:
  friend class mojo::internal::MessageFragment<XRLayerUpdate_Data>;

  XRLayerUpdate_Data();
  ~XRLayerUpdate_Data() = delete;
};
static_assert(sizeof(XRLayerUpdate_Data) == 24,
              "Bad sizeof(XRLayerUpdate_Data)");
// Used by XRLayerUpdate::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct XRLayerUpdate_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  XRLayerUpdate_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~XRLayerUpdate_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<XRLayerUpdate_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    XRLayerUpdate_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};

#pragma pack(pop)

}  // namespace internal

}  // device::mojom

#endif  // DEVICE_VR_PUBLIC_MOJOM_VR_SERVICE_MOJOM_SHARED_INTERNAL_H_