out/sdk/cache/chromeos-chrome/chrome-src/src/out_arm64-generic/Release/gen/chromeos/ash/services/cros_healthd/public/mojom/cros_healthd_events.mojom-shared-internal.h

// chromeos/ash/services/cros_healthd/public/mojom/cros_healthd_events.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 CHROMEOS_ASH_SERVICES_CROS_HEALTHD_PUBLIC_MOJOM_CROS_HEALTHD_EVENTS_MOJOM_SHARED_INTERNAL_H_
#define CHROMEOS_ASH_SERVICES_CROS_HEALTHD_PUBLIC_MOJOM_CROS_HEALTHD_EVENTS_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/buffer.h"
#include "ash/system/diagnostics/mojom/input.mojom-shared-internal.h"
#include "chromeos/ash/services/cros_healthd/public/mojom/cros_healthd_probe.mojom-shared-internal.h"
#include "chromeos/ash/services/cros_healthd/public/mojom/nullable_primitives.mojom-shared-internal.h"
#include "mojo/public/mojom/base/time.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"



namespace mojo {
namespace internal {
class ValidationContext;
}
}


namespace ash::cros_healthd::mojom {
namespace internal {
class UsbEventInfo_Data;
class ThunderboltEventInfo_Data;
class LidEventInfo_Data;
class BluetoothEventInfo_Data;
class PowerEventInfo_Data;
class AudioEventInfo_Data;
class AudioJackEventInfo_Data;
class SdCardEventInfo_Data;
class TouchpadButtonEvent_Data;
class TouchPointInfo_Data;
class TouchpadTouchEvent_Data;
class TouchpadConnectedEvent_Data;
class ExternalDisplayEventInfo_Data;
class TouchscreenTouchEvent_Data;
class TouchscreenConnectedEvent_Data;
class StylusGarageEventInfo_Data;
class StylusTouchPointInfo_Data;
class StylusTouchEvent_Data;
class StylusConnectedEvent_Data;
class CrashUploadInfo_Data;
class CrashEventInfo_Data;
class TouchpadEventInfo_Data;
class TouchscreenEventInfo_Data;
class StylusEventInfo_Data;
class EventInfo_Data;

struct InputTouchButton_Data {
 public:
  static bool constexpr kIsExtensible = true;

  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 EventCategoryEnum_Data {
 public:
  static bool constexpr kIsExtensible = true;

  static bool IsKnownValue(int32_t value) {
    switch (value) {
      case 0:
      case 1:
      case 2:
      case 3:
      case 4:
      case 5:
      case 6:
      case 7:
      case 8:
      case 9:
      case 10:
      case 11:
      case 12:
      case 13:
      case 14:
      case 15:
      case 16:
        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 UsbEventInfo_State_Data {
 public:
  static bool constexpr kIsExtensible = true;

  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 ThunderboltEventInfo_State_Data {
 public:
  static bool constexpr kIsExtensible = true;

  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 LidEventInfo_State_Data {
 public:
  static bool constexpr kIsExtensible = true;

  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 BluetoothEventInfo_State_Data {
 public:
  static bool constexpr kIsExtensible = true;

  static bool IsKnownValue(int32_t value) {
    switch (value) {
      case 0:
      case 1:
      case 2:
      case 3:
      case 4:
      case 5:
      case 6:
        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 PowerEventInfo_State_Data {
 public:
  static bool constexpr kIsExtensible = true;

  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 AudioEventInfo_State_Data {
 public:
  static bool constexpr kIsExtensible = true;

  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 AudioJackEventInfo_State_Data {
 public:
  static bool constexpr kIsExtensible = true;

  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 AudioJackEventInfo_DeviceType_Data {
 public:
  static bool constexpr kIsExtensible = true;

  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 SdCardEventInfo_State_Data {
 public:
  static bool constexpr kIsExtensible = true;

  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 ExternalDisplayEventInfo_State_Data {
 public:
  static bool constexpr kIsExtensible = true;

  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 StylusGarageEventInfo_State_Data {
 public:
  static bool constexpr kIsExtensible = true;

  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 CrashEventInfo_CrashType_Data {
 public:
  static bool constexpr kIsExtensible = true;

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

#pragma pack(push, 1)


class  TouchpadEventInfo_Data {
 public:
  // Used to identify Mojom Union Data Classes.
  typedef void MojomUnionDataType;

  TouchpadEventInfo_Data() = default;
  // Do nothing in the destructor since it won't be called when it is a
  // non-inlined union.
  ~TouchpadEventInfo_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<TouchpadEventInfo_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 TouchpadEventInfo_Tag : uint32_t {

    
    kDefaultType,
    
    kButtonEvent,
    
    kTouchEvent,
    
    kConnectedEvent,
  };

  // 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) {}
    uint8_t f_default_type;
    mojo::internal::Pointer<internal::TouchpadButtonEvent_Data> f_button_event;
    mojo::internal::Pointer<internal::TouchpadTouchEvent_Data> f_touch_event;
    mojo::internal::Pointer<internal::TouchpadConnectedEvent_Data> f_connected_event;
    uint64_t unknown;
  };

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


class  TouchscreenEventInfo_Data {
 public:
  // Used to identify Mojom Union Data Classes.
  typedef void MojomUnionDataType;

  TouchscreenEventInfo_Data() = default;
  // Do nothing in the destructor since it won't be called when it is a
  // non-inlined union.
  ~TouchscreenEventInfo_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<TouchscreenEventInfo_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 TouchscreenEventInfo_Tag : uint32_t {

    
    kDefaultType,
    
    kTouchEvent,
    
    kConnectedEvent,
  };

  // 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) {}
    uint8_t f_default_type;
    mojo::internal::Pointer<internal::TouchscreenTouchEvent_Data> f_touch_event;
    mojo::internal::Pointer<internal::TouchscreenConnectedEvent_Data> f_connected_event;
    uint64_t unknown;
  };

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


class  StylusEventInfo_Data {
 public:
  // Used to identify Mojom Union Data Classes.
  typedef void MojomUnionDataType;

  StylusEventInfo_Data() = default;
  // Do nothing in the destructor since it won't be called when it is a
  // non-inlined union.
  ~StylusEventInfo_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<StylusEventInfo_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 StylusEventInfo_Tag : uint32_t {

    
    kDefaultType,
    
    kTouchEvent,
    
    kConnectedEvent,
  };

  // 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) {}
    uint8_t f_default_type;
    mojo::internal::Pointer<internal::StylusTouchEvent_Data> f_touch_event;
    mojo::internal::Pointer<internal::StylusConnectedEvent_Data> f_connected_event;
    uint64_t unknown;
  };

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


class  EventInfo_Data {
 public:
  // Used to identify Mojom Union Data Classes.
  typedef void MojomUnionDataType;

  EventInfo_Data() = default;
  // Do nothing in the destructor since it won't be called when it is a
  // non-inlined union.
  ~EventInfo_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<EventInfo_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 EventInfo_Tag : uint32_t {

    
    kDefaultType,
    
    kUsbEventInfo,
    
    kThunderboltEventInfo,
    
    kLidEventInfo,
    
    kBluetoothEventInfo,
    
    kPowerEventInfo,
    
    kAudioEventInfo,
    
    kAudioJackEventInfo,
    
    kSdCardEventInfo,
    
    kKeyboardDiagnosticEventInfo,
    
    kTouchpadEventInfo,
    
    kExternalDisplayEventInfo,
    
    kTouchscreenEventInfo,
    
    kStylusGarageEventInfo,
    
    kStylusEventInfo,
    
    kCrashEventInfo,
  };

  // 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) {}
    uint8_t f_default_type;
    mojo::internal::Pointer<internal::UsbEventInfo_Data> f_usb_event_info;
    mojo::internal::Pointer<internal::ThunderboltEventInfo_Data> f_thunderbolt_event_info;
    mojo::internal::Pointer<internal::LidEventInfo_Data> f_lid_event_info;
    mojo::internal::Pointer<internal::BluetoothEventInfo_Data> f_bluetooth_event_info;
    mojo::internal::Pointer<internal::PowerEventInfo_Data> f_power_event_info;
    mojo::internal::Pointer<internal::AudioEventInfo_Data> f_audio_event_info;
    mojo::internal::Pointer<internal::AudioJackEventInfo_Data> f_audio_jack_event_info;
    mojo::internal::Pointer<internal::SdCardEventInfo_Data> f_sd_card_event_info;
    mojo::internal::Pointer<::ash::diagnostics::mojom::internal::KeyboardDiagnosticEventInfo_Data> f_keyboard_diagnostic_event_info;
    mojo::internal::Pointer<internal::TouchpadEventInfo_Data> f_touchpad_event_info;
    mojo::internal::Pointer<internal::ExternalDisplayEventInfo_Data> f_external_display_event_info;
    mojo::internal::Pointer<internal::TouchscreenEventInfo_Data> f_touchscreen_event_info;
    mojo::internal::Pointer<internal::StylusGarageEventInfo_Data> f_stylus_garage_event_info;
    mojo::internal::Pointer<internal::StylusEventInfo_Data> f_stylus_event_info;
    mojo::internal::Pointer<internal::CrashEventInfo_Data> f_crash_event_info;
    uint64_t unknown;
  };

  uint32_t size;
  EventInfo_Tag tag;
  Union_ data;
};
static_assert(sizeof(EventInfo_Data) == mojo::internal::kUnionDataSize,
              "Bad sizeof(EventInfo_Data)");
class  UsbEventInfo_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::String_Data> vendor;
  mojo::internal::Pointer<mojo::internal::String_Data> name;
  uint16_t vid;
  uint16_t pid;
  int32_t state;
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<mojo::internal::String_Data>>> categories;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  int32_t state;
  uint8_t padfinal_[4];

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  int32_t state;
  uint8_t padfinal_[4];

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  int32_t state;
  uint8_t padfinal_[4];

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  int32_t state;
  uint8_t padfinal_[4];

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  int32_t state;
  uint8_t padfinal_[4];

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  int32_t state;
  int32_t device_type;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  int32_t state;
  uint8_t padfinal_[4];

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  int32_t button;
  uint8_t pressed : 1;
  uint8_t padfinal_[3];

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  uint32_t tracking_id;
  uint32_t x;
  uint32_t y;
  uint8_t pad2_[4];
  mojo::internal::Pointer<::ash::cros_healthd::mojom::internal::NullableUint32_Data> pressure;
  mojo::internal::Pointer<::ash::cros_healthd::mojom::internal::NullableUint32_Data> touch_major;
  mojo::internal::Pointer<::ash::cros_healthd::mojom::internal::NullableUint32_Data> touch_minor;

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

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

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

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

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

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    TouchPointInfo_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  TouchpadTouchEvent_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::TouchPointInfo_Data>>> touch_points;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  uint32_t max_x;
  uint32_t max_y;
  uint32_t max_pressure;
  uint8_t pad2_[4];
  mojo::internal::Pointer<mojo::internal::Array_Data<int32_t>> buttons;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  int32_t state;
  uint8_t pad0_[4];
  mojo::internal::Pointer<::ash::cros_healthd::mojom::internal::ExternalDisplayInfo_Data> display_info;

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

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

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

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

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

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    ExternalDisplayEventInfo_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  TouchscreenTouchEvent_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::TouchPointInfo_Data>>> touch_points;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  uint32_t max_x;
  uint32_t max_y;
  uint32_t max_pressure;
  uint8_t padfinal_[4];

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  int32_t state;
  uint8_t padfinal_[4];

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  uint32_t x;
  uint32_t y;
  mojo::internal::Pointer<::ash::cros_healthd::mojom::internal::NullableUint32_Data> pressure;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<internal::StylusTouchPointInfo_Data> touch_point;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  uint32_t max_x;
  uint32_t max_y;
  uint32_t max_pressure;
  uint8_t padfinal_[4];

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::String_Data> crash_report_id;
  mojo::internal::Pointer<::mojo_base::mojom::internal::Time_Data> creation_time;
  uint64_t offset;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  int32_t crash_type;
  uint8_t pad0_[4];
  mojo::internal::Pointer<mojo::internal::String_Data> local_id;
  mojo::internal::Pointer<::mojo_base::mojom::internal::Time_Data> capture_time;
  mojo::internal::Pointer<internal::CrashUploadInfo_Data> upload_info;

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

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

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

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

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

  UserType user_data_;
};

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

#pragma pack(pop)

}  // namespace internal

}  // ash::cros_healthd::mojom

#endif  // CHROMEOS_ASH_SERVICES_CROS_HEALTHD_PUBLIC_MOJOM_CROS_HEALTHD_EVENTS_MOJOM_SHARED_INTERNAL_H_