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

// chromeos/ash/services/cros_healthd/public/mojom/cros_healthd_routines.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_ROUTINES_MOJOM_SHARED_INTERNAL_H_
#define CHROMEOS_ASH_SERVICES_CROS_HEALTHD_PUBLIC_MOJOM_CROS_HEALTHD_ROUTINES_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 "mojo/public/mojom/base/time.mojom-shared-internal.h"
#include "mojo/public/mojom/base/uuid.mojom-shared-internal.h"
#include "chromeos/ash/services/cros_healthd/public/mojom/cros_healthd_exception.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 MemoryRoutineArgument_Data;
class AudioDriverRoutineArgument_Data;
class CpuStressRoutineArgument_Data;
class UfsLifetimeRoutineArgument_Data;
class DiskReadRoutineArgument_Data;
class CpuCacheRoutineArgument_Data;
class PrimeSearchRoutineArgument_Data;
class VolumeButtonRoutineArgument_Data;
class LedLitUpRoutineArgument_Data;
class FloatingPointRoutineArgument_Data;
class BluetoothPowerRoutineArgument_Data;
class BluetoothDiscoveryRoutineArgument_Data;
class FanRoutineArgument_Data;
class BluetoothScanningRoutineArgument_Data;
class BluetoothPairingRoutineArgument_Data;
class CameraAvailabilityRoutineArgument_Data;
class UrandomRoutineArgument_Data;
class NetworkBandwidthRoutineArgument_Data;
class RoutineState_Data;
class RoutineStateInitialized_Data;
class RoutineStateRunning_Data;
class NetworkBandwidthRoutineRunningInfo_Data;
class RoutineStateWaiting_Data;
class CheckLedLitUpStateInquiry_Data;
class CheckLedLitUpStateReply_Data;
class RoutineStateFinished_Data;
class MemoryRoutineDetail_Data;
class AudioDriverRoutineDetail_Data;
class UfsLifetimeRoutineDetail_Data;
class MemtesterResult_Data;
class BluetoothPoweredDetail_Data;
class BluetoothPowerRoutineDetail_Data;
class BluetoothDiscoveringDetail_Data;
class BluetoothDiscoveryRoutineDetail_Data;
class BluetoothScannedPeripheralInfo_Data;
class BluetoothScanningRoutineDetail_Data;
class BluetoothPairingPeripheralInfo_Data;
class BluetoothPairingRoutineDetail_Data;
class CameraAvailabilityRoutineDetail_Data;
class FanRoutineDetail_Data;
class NetworkBandwidthRoutineDetail_Data;
class RoutineArgument_Data;
class RoutineStateUnion_Data;
class RoutineRunningInfo_Data;
class RoutineInteraction_Data;
class RoutineInquiry_Data;
class RoutineInquiryReply_Data;
class RoutineDetail_Data;

struct MemtesterTestItemEnum_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:
      case 17:
      case 18:
      case 19:
        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 CameraSubtestResult_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 DiskReadTypeEnum_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 LedName_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:
        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 LedColor_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 HardwarePresenceStatus_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 VolumeButtonRoutineArgument_ButtonType_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 NetworkBandwidthRoutineRunningInfo_Type_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 RoutineStateWaiting_Reason_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 CheckLedLitUpStateReply_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 BluetoothPairingPeripheralInfo_PairError_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:
        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 BluetoothPairingPeripheralInfo_ConnectError_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 BluetoothPairingPeripheralInfo_AddressType_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  RoutineArgument_Data {
 public:
  // Used to identify Mojom Union Data Classes.
  typedef void MojomUnionDataType;

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

    
    kUnrecognizedArgument,
    
    kMemory,
    
    kVolumeButton,
    
    kFan,
    
    kAudioDriver,
    
    kCpuStress,
    
    kUfsLifetime,
    
    kDiskRead,
    
    kCpuCache,
    
    kPrimeSearch,
    
    kLedLitUp,
    
    kFloatingPoint,
    
    kBluetoothPower,
    
    kBluetoothDiscovery,
    
    kBluetoothScanning,
    
    kBluetoothPairing,
    
    kCameraAvailability,
    
    kUrandom,
    
    kNetworkBandwidth,
  };

  // 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_unrecognizedArgument : 1;
    mojo::internal::Pointer<internal::MemoryRoutineArgument_Data> f_memory;
    mojo::internal::Pointer<internal::VolumeButtonRoutineArgument_Data> f_volume_button;
    mojo::internal::Pointer<internal::FanRoutineArgument_Data> f_fan;
    mojo::internal::Pointer<internal::AudioDriverRoutineArgument_Data> f_audio_driver;
    mojo::internal::Pointer<internal::CpuStressRoutineArgument_Data> f_cpu_stress;
    mojo::internal::Pointer<internal::UfsLifetimeRoutineArgument_Data> f_ufs_lifetime;
    mojo::internal::Pointer<internal::DiskReadRoutineArgument_Data> f_disk_read;
    mojo::internal::Pointer<internal::CpuCacheRoutineArgument_Data> f_cpu_cache;
    mojo::internal::Pointer<internal::PrimeSearchRoutineArgument_Data> f_prime_search;
    mojo::internal::Pointer<internal::LedLitUpRoutineArgument_Data> f_led_lit_up;
    mojo::internal::Pointer<internal::FloatingPointRoutineArgument_Data> f_floating_point;
    mojo::internal::Pointer<internal::BluetoothPowerRoutineArgument_Data> f_bluetooth_power;
    mojo::internal::Pointer<internal::BluetoothDiscoveryRoutineArgument_Data> f_bluetooth_discovery;
    mojo::internal::Pointer<internal::BluetoothScanningRoutineArgument_Data> f_bluetooth_scanning;
    mojo::internal::Pointer<internal::BluetoothPairingRoutineArgument_Data> f_bluetooth_pairing;
    mojo::internal::Pointer<internal::CameraAvailabilityRoutineArgument_Data> f_camera_availability;
    mojo::internal::Pointer<internal::UrandomRoutineArgument_Data> f_urandom;
    mojo::internal::Pointer<internal::NetworkBandwidthRoutineArgument_Data> f_network_bandwidth;
    uint64_t unknown;
  };

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


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

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

    
    kUnrecognizedArgument,
    
    kInitialized,
    
    kRunning,
    
    kWaiting,
    
    kFinished,
  };

  // 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_unrecognizedArgument : 1;
    mojo::internal::Pointer<internal::RoutineStateInitialized_Data> f_initialized;
    mojo::internal::Pointer<internal::RoutineStateRunning_Data> f_running;
    mojo::internal::Pointer<internal::RoutineStateWaiting_Data> f_waiting;
    mojo::internal::Pointer<internal::RoutineStateFinished_Data> f_finished;
    uint64_t unknown;
  };

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


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

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

    
    kUnrecognizedArgument,
    
    kNetworkBandwidth,
  };

  // 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_unrecognizedArgument : 1;
    mojo::internal::Pointer<internal::NetworkBandwidthRoutineRunningInfo_Data> f_network_bandwidth;
    uint64_t unknown;
  };

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


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

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

    
    kUnrecognizedInteraction,
    
    kInquiry,
  };

  // 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_unrecognizedInteraction : 1;
    mojo::internal::Pointer<internal::RoutineInquiry_Data> f_inquiry;
    uint64_t unknown;
  };

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


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

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

    
    kUnrecognizedInquiry,
    
    kCheckLedLitUpState,
  };

  // 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_unrecognizedInquiry : 1;
    mojo::internal::Pointer<internal::CheckLedLitUpStateInquiry_Data> f_check_led_lit_up_state;
    uint64_t unknown;
  };

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


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

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

    
    kUnrecognizedReply,
    
    kCheckLedLitUpState,
  };

  // 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_unrecognizedReply : 1;
    mojo::internal::Pointer<internal::CheckLedLitUpStateReply_Data> f_check_led_lit_up_state;
    uint64_t unknown;
  };

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


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

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

    
    kUnrecognizedArgument,
    
    kMemory,
    
    kFan,
    
    kAudioDriver,
    
    kUfsLifetime,
    
    kBluetoothPower,
    
    kBluetoothDiscovery,
    
    kBluetoothScanning,
    
    kBluetoothPairing,
    
    kCameraAvailability,
    
    kNetworkBandwidth,
  };

  // 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_unrecognizedArgument : 1;
    mojo::internal::Pointer<internal::MemoryRoutineDetail_Data> f_memory;
    mojo::internal::Pointer<internal::FanRoutineDetail_Data> f_fan;
    mojo::internal::Pointer<internal::AudioDriverRoutineDetail_Data> f_audio_driver;
    mojo::internal::Pointer<internal::UfsLifetimeRoutineDetail_Data> f_ufs_lifetime;
    mojo::internal::Pointer<internal::BluetoothPowerRoutineDetail_Data> f_bluetooth_power;
    mojo::internal::Pointer<internal::BluetoothDiscoveryRoutineDetail_Data> f_bluetooth_discovery;
    mojo::internal::Pointer<internal::BluetoothScanningRoutineDetail_Data> f_bluetooth_scanning;
    mojo::internal::Pointer<internal::BluetoothPairingRoutineDetail_Data> f_bluetooth_pairing;
    mojo::internal::Pointer<internal::CameraAvailabilityRoutineDetail_Data> f_camera_availability;
    mojo::internal::Pointer<internal::NetworkBandwidthRoutineDetail_Data> f_network_bandwidth;
    uint64_t unknown;
  };

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

  mojo::internal::StructHeader header_;
  uint8_t max_testing_mem_kib_$flag : 1;
  uint8_t pad0_[3];
  uint32_t max_testing_mem_kib_$value;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<::mojo_base::mojom::internal::TimeDelta_Data> exec_duration;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  int32_t type;
  uint32_t file_size_mib;
  mojo::internal::Pointer<::mojo_base::mojom::internal::TimeDelta_Data> disk_read_duration;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<::mojo_base::mojom::internal::TimeDelta_Data> exec_duration;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<::mojo_base::mojom::internal::TimeDelta_Data> exec_duration;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  int32_t type;
  uint8_t pad0_[4];
  mojo::internal::Pointer<::mojo_base::mojom::internal::TimeDelta_Data> timeout;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  int32_t name;
  int32_t color;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<::mojo_base::mojom::internal::TimeDelta_Data> exec_duration;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<::mojo_base::mojom::internal::TimeDelta_Data> exec_duration;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::String_Data> peripheral_id;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  uint8_t run_camera_service_available_check : 1;
  uint8_t run_camera_diagnostic_service_available_check : 1;
  uint8_t padfinal_[7];

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<::mojo_base::mojom::internal::TimeDelta_Data> exec_duration;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  uint8_t percentage;
  uint8_t pad0_[7];
  internal::RoutineStateUnion_Data state_union;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  internal::RoutineRunningInfo_Data info;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  int32_t type;
  uint8_t pad0_[4];
  double speed_kbps;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  int32_t reason;
  uint8_t pad0_[4];
  mojo::internal::Pointer<mojo::internal::String_Data> message;
  internal::RoutineInteraction_Data interaction;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;

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

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

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

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

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

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    CheckLedLitUpStateInquiry_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  CheckLedLitUpStateReply_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<CheckLedLitUpStateReply_Data>;

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  uint8_t has_passed : 1;
  uint8_t pad0_[7];
  internal::RoutineDetail_Data detail;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  uint64_t bytes_tested;
  mojo::internal::Pointer<internal::MemtesterResult_Data> result;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  uint8_t internal_card_detected : 1;
  uint8_t audio_devices_succeed_to_open : 1;
  uint8_t padfinal_[7];

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  uint8_t pre_eol_info;
  uint8_t device_life_time_est_a;
  uint8_t device_life_time_est_b;
  uint8_t padfinal_[5];

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::Array_Data<int32_t>> passed_items;
  mojo::internal::Pointer<mojo::internal::Array_Data<int32_t>> failed_items;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  uint8_t hci_powered : 1;
  uint8_t dbus_powered : 1;
  uint8_t padfinal_[7];

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<internal::BluetoothPoweredDetail_Data> power_off_result;
  mojo::internal::Pointer<internal::BluetoothPoweredDetail_Data> power_on_result;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  uint8_t hci_discovering : 1;
  uint8_t dbus_discovering : 1;
  uint8_t padfinal_[7];

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<internal::BluetoothDiscoveringDetail_Data> start_discovery_result;
  mojo::internal::Pointer<internal::BluetoothDiscoveringDetail_Data> stop_discovery_result;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::Array_Data<int16_t>> rssi_history;
  mojo::internal::Pointer<mojo::internal::String_Data> name;
  mojo::internal::Pointer<mojo::internal::String_Data> peripheral_id;
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<::mojo_base::mojom::internal::Uuid_Data>>> uuids;

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

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

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

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

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

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    BluetoothScannedPeripheralInfo_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  BluetoothScanningRoutineDetail_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::BluetoothScannedPeripheralInfo_Data>>> peripherals;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  int32_t pair_error;
  int32_t connect_error;
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<::mojo_base::mojom::internal::Uuid_Data>>> uuids;
  uint8_t bluetooth_class_$flag : 1;
  uint8_t is_address_valid : 1;
  uint8_t pad4_[3];
  uint32_t bluetooth_class_$value;
  int32_t address_type;
  uint8_t pad6_[4];
  mojo::internal::Pointer<mojo::internal::String_Data> failed_manufacturer_id;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<internal::BluetoothPairingPeripheralInfo_Data> pairing_peripheral;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  int32_t camera_service_available_check;
  int32_t camera_diagnostic_service_available_check;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::Array_Data<uint8_t>> passed_fan_ids;
  mojo::internal::Pointer<mojo::internal::Array_Data<uint8_t>> failed_fan_ids;
  int32_t fan_count_status;
  uint8_t padfinal_[4];

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  double download_speed_kbps;
  double upload_speed_kbps;

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

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

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

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

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

  UserType user_data_;
};

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

#pragma pack(pop)

}  // namespace internal

}  // ash::cros_healthd::mojom

#endif  // CHROMEOS_ASH_SERVICES_CROS_HEALTHD_PUBLIC_MOJOM_CROS_HEALTHD_ROUTINES_MOJOM_SHARED_INTERNAL_H_