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

// chromeos/ash/services/cros_healthd/public/mojom/cros_healthd_probe.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_PROBE_MOJOM_SHARED_INTERNAL_H_
#define CHROMEOS_ASH_SERVICES_CROS_HEALTHD_PUBLIC_MOJOM_CROS_HEALTHD_PROBE_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 "chromeos/ash/services/cros_healthd/public/mojom/nullable_primitives.mojom-shared-internal.h"
#include "chromeos/services/network_health/public/mojom/network_health_types.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 ProbeError_Data;
class MultipleProcessResult_Data;
class ProcessInfo_Data;
class BatteryInfo_Data;
class NvmeDeviceInfo_Data;
class EmmcDeviceInfo_Data;
class UfsDeviceInfo_Data;
class NonRemovableBlockDeviceInfo_Data;
class CpuInfo_Data;
class VirtualizationInfo_Data;
class VulnerabilityInfo_Data;
class KeylockerInfo_Data;
class PhysicalCpuInfo_Data;
class CpuVirtualizationInfo_Data;
class LogicalCpuInfo_Data;
class CpuCStateInfo_Data;
class CpuTemperatureChannel_Data;
class TimezoneInfo_Data;
class MemoryInfo_Data;
class MemoryEncryptionInfo_Data;
class BacklightInfo_Data;
class FanInfo_Data;
class StatefulPartitionInfo_Data;
class BluetoothAdapterInfo_Data;
class BluetoothDeviceInfo_Data;
class DEPRECATED_SupportedCapabilities_Data;
class SystemInfo_Data;
class OsInfo_Data;
class OsVersion_Data;
class VpdInfo_Data;
class DmiInfo_Data;
class PsrEvent_Data;
class PsrInfo_Data;
class WirelessInterfaceInfo_Data;
class WirelessLinkInfo_Data;
class AudioInfo_Data;
class AudioNodeInfo_Data;
class AudioHardwareInfo_Data;
class AudioCard_Data;
class HDAudioCodec_Data;
class BootPerformanceInfo_Data;
class BusDevice_Data;
class PciBusInfo_Data;
class UsbBusInfo_Data;
class FwupdFirmwareVersionInfo_Data;
class UsbBusInterfaceInfo_Data;
class TpmInfo_Data;
class TpmVersion_Data;
class TpmStatus_Data;
class TpmDictionaryAttack_Data;
class TpmAttestation_Data;
class TpmSupportedFeatures_Data;
class GraphicsInfo_Data;
class GLESInfo_Data;
class EGLInfo_Data;
class DisplayInfo_Data;
class EmbeddedDisplayInfo_Data;
class ExternalDisplayInfo_Data;
class ThunderboltBusInterfaceInfo_Data;
class ThunderboltBusInfo_Data;
class InputInfo_Data;
class TouchscreenDevice_Data;
class TouchpadDevice_Data;
class InputDevice_Data;
class SensorInfo_Data;
class Sensor_Data;
class ThermalInfo_Data;
class ThermalSensorInfo_Data;
class TelemetryInfo_Data;
class ProcessResult_Data;
class BatteryResult_Data;
class NonRemovableBlockDeviceResult_Data;
class BlockDeviceVendor_Data;
class BlockDeviceProduct_Data;
class BlockDeviceRevision_Data;
class BlockDeviceFirmware_Data;
class BlockDeviceInfo_Data;
class CpuResult_Data;
class TimezoneResult_Data;
class MemoryResult_Data;
class BacklightResult_Data;
class FanResult_Data;
class StatefulPartitionResult_Data;
class BluetoothResult_Data;
class DEPRECATED_SystemResult_Data;
class SystemResult_Data;
class NetworkResult_Data;
class NetworkInterfaceResult_Data;
class NetworkInterfaceInfo_Data;
class AudioResult_Data;
class AudioHardwareResult_Data;
class BootPerformanceResult_Data;
class BusResult_Data;
class BusInfo_Data;
class TpmResult_Data;
class GraphicsResult_Data;
class DisplayResult_Data;
class InputResult_Data;
class SensorResult_Data;
class ThermalResult_Data;

struct CpuArchitectureEnum_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 ProbeCategoryEnum_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:
      case 20:
      case 21:
      case 22:
        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 ErrorType_Data {
 public:
  static bool constexpr kIsExtensible = true;

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

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

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

struct ProcessState_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:
        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 StorageDevicePurpose_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 EncryptionState_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 CryptoAlgorithm_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 BluetoothDeviceType_Data {
 public:
  static bool constexpr kIsExtensible = true;

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

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

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

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

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

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

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

struct BusDeviceClass_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 FwupdVersionFormat_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:
        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 UsbVersion_Data {
 public:
  static bool constexpr kIsExtensible = true;

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

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

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

struct UsbSpecSpeed_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:
        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 TpmGSCVersion_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 DisplayInputType_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 ThunderboltSecurityLevel_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 VirtualizationInfo_SMTControl_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 VulnerabilityInfo_Status_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 CpuVirtualizationInfo_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 OsInfo_EfiPlatformSize_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 PsrEvent_EventType_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:
        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 PsrInfo_LogState_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 InputDevice_ConnectionType_Data {
 public:
  static bool constexpr kIsExtensible = true;

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

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

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

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

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

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

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

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

#pragma pack(push, 1)


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

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

    
    kProcessInfo,
    
    kError,
  };

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

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


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

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

    
    kBatteryInfo,
    
    kError,
  };

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

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


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

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

    
    kBlockDeviceInfo,
    
    kError,
  };

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

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


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

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

    
    kNvmeSubsystemVendor,
    
    kEmmcOemid,
    
    kOther,
    
    kUnknown,
    
    kJedecManfid,
  };

  // 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) {}
    uint32_t f_nvme_subsystem_vendor;
    uint16_t f_emmc_oemid;
    uint16_t f_other;
    uint64_t f_unknown;
    uint16_t f_jedec_manfid;
    uint64_t unknown;
  };

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


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

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

    
    kNvmeSubsystemDevice,
    
    kEmmcPnm,
    
    kOther,
    
    kUnknown,
  };

  // 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) {}
    uint32_t f_nvme_subsystem_device;
    uint64_t f_emmc_pnm;
    uint16_t f_other;
    uint64_t f_unknown;
    uint64_t unknown;
  };

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


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

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

    
    kNvmePcieRev,
    
    kEmmcPrv,
    
    kOther,
    
    kUnknown,
  };

  // 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_nvme_pcie_rev;
    uint8_t f_emmc_prv;
    uint16_t f_other;
    uint64_t f_unknown;
    uint64_t unknown;
  };

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


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

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

    
    kNvmeFirmwareRev,
    
    kEmmcFwrev,
    
    kOther,
    
    kUnknown,
    
    kUfsFwrev,
  };

  // 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) {}
    uint64_t f_nvme_firmware_rev;
    uint64_t f_emmc_fwrev;
    uint16_t f_other;
    uint64_t f_unknown;
    uint64_t f_ufs_fwrev;
    uint64_t unknown;
  };

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


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

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

    
    kUnrecognized,
    
    kNvmeDeviceInfo,
    
    kEmmcDeviceInfo,
    
    kUfsDeviceInfo,
  };

  // 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_unrecognized : 1;
    mojo::internal::Pointer<internal::NvmeDeviceInfo_Data> f_nvme_device_info;
    mojo::internal::Pointer<internal::EmmcDeviceInfo_Data> f_emmc_device_info;
    mojo::internal::Pointer<internal::UfsDeviceInfo_Data> f_ufs_device_info;
    uint64_t unknown;
  };

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


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

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

    
    kCpuInfo,
    
    kError,
  };

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

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


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

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

    
    kTimezoneInfo,
    
    kError,
  };

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

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


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

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

    
    kMemoryInfo,
    
    kError,
  };

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

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


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

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

    
    kBacklightInfo,
    
    kError,
  };

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

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


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

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

    
    kFanInfo,
    
    kError,
  };

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

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


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

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

    
    kPartitionInfo,
    
    kError,
  };

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

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


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

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

    
    kBluetoothAdapterInfo,
    
    kError,
  };

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

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


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

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

    
    kError,
  };

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

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


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

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

    
    kSystemInfo,
    
    kError,
  };

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

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


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

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

    
    kNetworkHealth,
    
    kError,
  };

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

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


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

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

    
    kNetworkInterfaceInfo,
    
    kError,
  };

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

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


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

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

    
    kWirelessInterfaceInfo,
  };

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

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


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

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

    
    kAudioInfo,
    
    kError,
  };

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

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


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

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

    
    kAudioHardwareInfo,
    
    kError,
  };

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

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


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

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

    
    kBootPerformanceInfo,
    
    kError,
  };

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

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


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

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

    
    kBusDevices,
    
    kError,
  };

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

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


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

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

    
    kPciBusInfo,
    
    kUsbBusInfo,
    
    kThunderboltBusInfo,
    
    kUnmappedField,
  };

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

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


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

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

    
    kTpmInfo,
    
    kError,
  };

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

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


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

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

    
    kGraphicsInfo,
    
    kError,
  };

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

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


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

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

    
    kDisplayInfo,
    
    kError,
  };

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

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


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

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

    
    kInputInfo,
    
    kError,
  };

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

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


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

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

    
    kSensorInfo,
    
    kError,
  };

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

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


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

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

    
    kThermalInfo,
    
    kError,
  };

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

  uint32_t size;
  ThermalResult_Tag tag;
  Union_ data;
};
static_assert(sizeof(ThermalResult_Data) == mojo::internal::kUnionDataSize,
              "Bad sizeof(ThermalResult_Data)");
class  ProbeError_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::internal::String_Data> msg;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::Map_Data<uint32_t, mojo::internal::Pointer<internal::ProcessInfo_Data>>> process_infos;
  mojo::internal::Pointer<mojo::internal::Map_Data<uint32_t, mojo::internal::Pointer<internal::ProbeError_Data>>> errors;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::String_Data> command;
  uint32_t user_id;
  int8_t priority;
  int8_t nice;
  uint8_t pad3_[2];
  uint64_t uptime_ticks;
  int32_t state;
  uint32_t total_memory_kib;
  uint32_t resident_memory_kib;
  uint32_t free_memory_kib;
  uint64_t bytes_read;
  uint64_t bytes_written;
  uint64_t read_system_calls;
  uint64_t write_system_calls;
  uint64_t physical_bytes_read;
  uint64_t physical_bytes_written;
  uint64_t cancelled_bytes_written;
  mojo::internal::Pointer<mojo::internal::String_Data> name;
  uint32_t parent_process_id;
  uint32_t process_group_id;
  uint32_t threads;
  uint32_t process_id;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  int64_t cycle_count;
  double voltage_now;
  mojo::internal::Pointer<mojo::internal::String_Data> vendor;
  mojo::internal::Pointer<mojo::internal::String_Data> serial_number;
  double charge_full_design;
  double charge_full;
  double voltage_min_design;
  mojo::internal::Pointer<mojo::internal::String_Data> model_name;
  double charge_now;
  double current_now;
  mojo::internal::Pointer<mojo::internal::String_Data> technology;
  mojo::internal::Pointer<mojo::internal::String_Data> status;
  mojo::internal::Pointer<mojo::internal::String_Data> manufacture_date;
  mojo::internal::Pointer<::ash::cros_healthd::mojom::internal::NullableUint64_Data> temperature;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  uint32_t subsystem_vendor;
  uint32_t subsystem_device;
  uint8_t pcie_rev;
  uint8_t pad2_[7];
  uint64_t firmware_rev;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  uint16_t manfid;
  uint8_t prv;
  uint8_t pad1_[5];
  uint64_t pnm;
  uint64_t fwrev;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  uint16_t jedec_manfid;
  uint8_t pad0_[6];
  uint64_t fwrev;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  uint64_t bytes_read_since_last_boot;
  uint64_t bytes_written_since_last_boot;
  uint64_t read_time_seconds_since_last_boot;
  uint64_t write_time_seconds_since_last_boot;
  uint64_t io_time_seconds_since_last_boot;
  mojo::internal::Pointer<::ash::cros_healthd::mojom::internal::NullableUint64_Data> discard_time_seconds_since_last_boot;
  internal::BlockDeviceVendor_Data vendor_id;
  internal::BlockDeviceProduct_Data product_id;
  internal::BlockDeviceRevision_Data revision;
  mojo::internal::Pointer<mojo::internal::String_Data> name;
  uint64_t size;
  internal::BlockDeviceFirmware_Data firmware_version;
  mojo::internal::Pointer<mojo::internal::String_Data> type;
  int32_t purpose;
  uint8_t manufacturer_id;
  uint8_t pad14_[3];
  mojo::internal::Pointer<mojo::internal::String_Data> path;
  uint32_t serial;
  uint8_t pad16_[4];
  internal::BlockDeviceInfo_Data device_info;
  mojo::internal::Pointer<mojo::internal::String_Data> firmware_string;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  uint32_t num_total_threads;
  int32_t architecture;
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<internal::PhysicalCpuInfo_Data>>> physical_cpus;
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<internal::CpuTemperatureChannel_Data>>> temperature_channels;
  mojo::internal::Pointer<internal::KeylockerInfo_Data> keylocker_info;
  mojo::internal::Pointer<internal::VirtualizationInfo_Data> virtualization;
  mojo::internal::Pointer<mojo::internal::Map_Data<mojo::internal::Pointer<mojo::internal::String_Data>, mojo::internal::Pointer<internal::VulnerabilityInfo_Data>>> vulnerabilities;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  uint8_t has_kvm_device : 1;
  uint8_t is_smt_active : 1;
  uint8_t pad1_[3];
  int32_t smt_control;

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

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

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

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

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

  UserType user_data_;
};

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

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

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

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

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

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

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

  UserType user_data_;
};

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

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

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::String_Data> model_name;
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<internal::LogicalCpuInfo_Data>>> logical_cpus;
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<mojo::internal::String_Data>>> flags;
  mojo::internal::Pointer<internal::CpuVirtualizationInfo_Data> virtualization;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  int32_t type;
  uint8_t is_enabled : 1;
  uint8_t is_locked : 1;
  uint8_t padfinal_[3];

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  uint32_t max_clock_speed_khz;
  uint32_t scaling_max_frequency_khz;
  uint32_t scaling_current_frequency_khz;
  uint32_t core_id;
  uint64_t user_time_user_hz;
  uint64_t system_time_user_hz;
  uint64_t idle_time_user_hz;
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<internal::CpuCStateInfo_Data>>> c_states;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::String_Data> name;
  uint64_t time_in_state_since_last_boot_us;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::String_Data> label;
  int32_t temperature_celsius;
  uint8_t padfinal_[4];

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::String_Data> posix;
  mojo::internal::Pointer<mojo::internal::String_Data> region;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  uint32_t total_memory_kib;
  uint32_t free_memory_kib;
  uint32_t available_memory_kib;
  uint8_t pad2_[4];
  uint64_t page_faults_since_last_boot;
  mojo::internal::Pointer<internal::MemoryEncryptionInfo_Data> memory_encryption_info;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  int32_t encryption_state;
  uint32_t max_key_number;
  uint32_t key_length;
  int32_t active_algorithm;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::String_Data> path;
  uint32_t max_brightness;
  uint32_t brightness;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  uint32_t speed_rpm;
  uint8_t padfinal_[4];

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  uint64_t available_space;
  uint64_t total_space;
  mojo::internal::Pointer<mojo::internal::String_Data> filesystem;
  mojo::internal::Pointer<mojo::internal::String_Data> mount_source;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::String_Data> name;
  mojo::internal::Pointer<mojo::internal::String_Data> address;
  uint8_t powered : 1;
  uint8_t discoverable : 1;
  uint8_t discovering : 1;
  uint8_t pad4_[3];
  uint32_t num_connected_devices;
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<internal::BluetoothDeviceInfo_Data>>> connected_devices;
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<mojo::internal::String_Data>>> uuids;
  mojo::internal::Pointer<mojo::internal::String_Data> modalias;
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<mojo::internal::String_Data>>> service_allow_list;
  mojo::internal::Pointer<internal::DEPRECATED_SupportedCapabilities_Data> deprecated_capabilities;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::String_Data> address;
  mojo::internal::Pointer<mojo::internal::String_Data> name;
  int32_t type;
  uint8_t pad2_[4];
  mojo::internal::Pointer<::ash::cros_healthd::mojom::internal::NullableUint16_Data> appearance;
  mojo::internal::Pointer<mojo::internal::String_Data> modalias;
  mojo::internal::Pointer<::ash::cros_healthd::mojom::internal::NullableInt16_Data> rssi;
  mojo::internal::Pointer<::ash::cros_healthd::mojom::internal::NullableUint16_Data> deprecated_mtu;
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<mojo::internal::String_Data>>> uuids;
  mojo::internal::Pointer<::ash::cros_healthd::mojom::internal::NullableUint8_Data> battery_percentage;
  mojo::internal::Pointer<::ash::cros_healthd::mojom::internal::NullableUint32_Data> bluetooth_class;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<internal::OsInfo_Data> os_info;
  mojo::internal::Pointer<internal::VpdInfo_Data> vpd_info;
  mojo::internal::Pointer<internal::DmiInfo_Data> dmi_info;
  mojo::internal::Pointer<internal::PsrInfo_Data> psr_info;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::String_Data> code_name;
  mojo::internal::Pointer<mojo::internal::String_Data> marketing_name;
  mojo::internal::Pointer<internal::OsVersion_Data> os_version;
  int32_t boot_mode;
  int32_t efi_platform_size;
  mojo::internal::Pointer<mojo::internal::String_Data> oem_name;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::String_Data> release_milestone;
  mojo::internal::Pointer<mojo::internal::String_Data> build_number;
  mojo::internal::Pointer<mojo::internal::String_Data> patch_number;
  mojo::internal::Pointer<mojo::internal::String_Data> release_channel;
  mojo::internal::Pointer<mojo::internal::String_Data> branch_number;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::String_Data> serial_number;
  mojo::internal::Pointer<mojo::internal::String_Data> region;
  mojo::internal::Pointer<mojo::internal::String_Data> mfg_date;
  mojo::internal::Pointer<mojo::internal::String_Data> activate_date;
  mojo::internal::Pointer<mojo::internal::String_Data> sku_number;
  mojo::internal::Pointer<mojo::internal::String_Data> model_name;
  mojo::internal::Pointer<mojo::internal::String_Data> oem_name;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::String_Data> bios_vendor;
  mojo::internal::Pointer<mojo::internal::String_Data> bios_version;
  mojo::internal::Pointer<mojo::internal::String_Data> board_name;
  mojo::internal::Pointer<mojo::internal::String_Data> board_vendor;
  mojo::internal::Pointer<mojo::internal::String_Data> board_version;
  mojo::internal::Pointer<mojo::internal::String_Data> chassis_vendor;
  mojo::internal::Pointer<::ash::cros_healthd::mojom::internal::NullableUint64_Data> chassis_type;
  mojo::internal::Pointer<mojo::internal::String_Data> product_family;
  mojo::internal::Pointer<mojo::internal::String_Data> product_name;
  mojo::internal::Pointer<mojo::internal::String_Data> product_version;
  mojo::internal::Pointer<mojo::internal::String_Data> sys_vendor;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  int32_t type;
  uint32_t time;
  uint32_t data;
  uint8_t padfinal_[4];

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  int32_t log_state;
  uint32_t log_start_date;
  mojo::internal::Pointer<mojo::internal::String_Data> uuid;
  mojo::internal::Pointer<mojo::internal::String_Data> upid;
  mojo::internal::Pointer<mojo::internal::String_Data> oem_name;
  mojo::internal::Pointer<mojo::internal::String_Data> oem_make;
  mojo::internal::Pointer<mojo::internal::String_Data> oem_model;
  mojo::internal::Pointer<mojo::internal::String_Data> manufacture_country;
  mojo::internal::Pointer<mojo::internal::String_Data> oem_data;
  uint32_t uptime_seconds;
  uint32_t s5_counter;
  uint32_t s4_counter;
  uint32_t s3_counter;
  uint32_t warm_reset_counter;
  uint8_t is_supported : 1;
  uint8_t pad14_[3];
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<internal::PsrEvent_Data>>> events;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::String_Data> interface_name;
  uint8_t power_management_on : 1;
  uint8_t pad1_[7];
  mojo::internal::Pointer<internal::WirelessLinkInfo_Data> wireless_link_info;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::String_Data> access_point_address_str;
  uint32_t tx_bit_rate_mbps;
  uint32_t rx_bit_rate_mbps;
  int32_t tx_power_dBm;
  uint8_t encyption_on : 1;
  uint8_t pad4_[3];
  uint32_t link_quality;
  int32_t signal_level_dBm;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  uint8_t output_mute : 1;
  uint8_t input_mute : 1;
  uint8_t pad1_[3];
  uint32_t input_gain;
  uint64_t output_volume;
  mojo::internal::Pointer<mojo::internal::String_Data> output_device_name;
  mojo::internal::Pointer<mojo::internal::String_Data> input_device_name;
  uint32_t underruns;
  uint32_t severe_underruns;
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<internal::AudioNodeInfo_Data>>> output_nodes;
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<internal::AudioNodeInfo_Data>>> input_nodes;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  uint64_t id;
  mojo::internal::Pointer<mojo::internal::String_Data> name;
  mojo::internal::Pointer<mojo::internal::String_Data> device_name;
  uint8_t active : 1;
  uint8_t node_volume;
  uint8_t input_node_gain;
  uint8_t padfinal_[5];

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

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

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

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

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

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    AudioNodeInfo_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  AudioHardwareInfo_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::AudioCard_Data>>> audio_cards;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::String_Data> alsa_id;
  mojo::internal::Pointer<internal::BusDevice_Data> bus_device;
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<internal::HDAudioCodec_Data>>> hd_audio_codecs;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::String_Data> name;
  uint8_t address;
  uint8_t padfinal_[7];

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  double boot_up_seconds;
  double boot_up_timestamp;
  double shutdown_seconds;
  double shutdown_timestamp;
  mojo::internal::Pointer<mojo::internal::String_Data> shutdown_reason;
  mojo::internal::Pointer<::ash::cros_healthd::mojom::internal::NullableDouble_Data> tpm_initialization_seconds;
  uint8_t power_on_to_kernel_seconds_$flag : 1;
  uint8_t kernel_to_pre_startup_seconds_$flag : 1;
  uint8_t kernel_to_post_startup_seconds_$flag : 1;
  uint8_t startup_to_chrome_exec_seconds_$flag : 1;
  uint8_t chrome_exec_to_login_seconds_$flag : 1;
  uint8_t pad10_[7];
  double power_on_to_kernel_seconds_$value;
  double kernel_to_pre_startup_seconds_$value;
  double kernel_to_post_startup_seconds_$value;
  double startup_to_chrome_exec_seconds_$value;
  double chrome_exec_to_login_seconds_$value;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::String_Data> vendor_name;
  mojo::internal::Pointer<mojo::internal::String_Data> product_name;
  int32_t device_class;
  uint8_t pad2_[4];
  internal::BusInfo_Data bus_info;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  uint8_t class_id;
  uint8_t subclass_id;
  uint8_t prog_if_id;
  uint8_t pad2_[1];
  uint16_t vendor_id;
  uint16_t device_id;
  mojo::internal::Pointer<mojo::internal::String_Data> driver;
  mojo::internal::Pointer<::ash::cros_healthd::mojom::internal::NullableUint16_Data> sub_vendor_id;
  mojo::internal::Pointer<::ash::cros_healthd::mojom::internal::NullableUint16_Data> sub_device_id;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  uint8_t class_id;
  uint8_t subclass_id;
  uint8_t protocol_id;
  uint8_t pad2_[1];
  uint16_t vendor_id;
  uint16_t product_id;
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<internal::UsbBusInterfaceInfo_Data>>> interfaces;
  mojo::internal::Pointer<internal::FwupdFirmwareVersionInfo_Data> fwupd_firmware_version_info;
  int32_t version;
  int32_t spec_speed;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::String_Data> version;
  int32_t version_format;
  uint8_t padfinal_[4];

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  uint8_t interface_number;
  uint8_t class_id;
  uint8_t subclass_id;
  uint8_t protocol_id;
  uint8_t pad3_[4];
  mojo::internal::Pointer<mojo::internal::String_Data> driver;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<internal::TpmVersion_Data> version;
  mojo::internal::Pointer<internal::TpmStatus_Data> status;
  mojo::internal::Pointer<internal::TpmDictionaryAttack_Data> dictionary_attack;
  mojo::internal::Pointer<internal::TpmAttestation_Data> attestation;
  mojo::internal::Pointer<internal::TpmSupportedFeatures_Data> supported_features;
  mojo::internal::Pointer<mojo::internal::String_Data> did_vid;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  int32_t gsc_version;
  uint32_t family;
  uint64_t spec_level;
  uint32_t manufacturer;
  uint32_t tpm_model;
  uint64_t firmware_version;
  mojo::internal::Pointer<mojo::internal::String_Data> vendor_specific;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  uint8_t enabled : 1;
  uint8_t owned : 1;
  uint8_t owner_password_is_present : 1;
  uint8_t padfinal_[7];

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  uint32_t counter;
  uint32_t threshold;
  uint8_t lockout_in_effect : 1;
  uint8_t pad2_[3];
  uint32_t lockout_seconds_remaining;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  uint8_t prepared_for_enrollment : 1;
  uint8_t enrolled : 1;
  uint8_t padfinal_[7];

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  uint8_t support_u2f : 1;
  uint8_t support_pinweaver : 1;
  uint8_t support_runtime_selection : 1;
  uint8_t is_allowed : 1;
  uint8_t padfinal_[7];

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<internal::GLESInfo_Data> gles_info;
  mojo::internal::Pointer<internal::EGLInfo_Data> egl_info;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::String_Data> version;
  mojo::internal::Pointer<mojo::internal::String_Data> shading_version;
  mojo::internal::Pointer<mojo::internal::String_Data> vendor;
  mojo::internal::Pointer<mojo::internal::String_Data> renderer;
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<mojo::internal::String_Data>>> extensions;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::String_Data> version;
  mojo::internal::Pointer<mojo::internal::String_Data> vendor;
  mojo::internal::Pointer<mojo::internal::String_Data> client_api;
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<mojo::internal::String_Data>>> extensions;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<internal::EmbeddedDisplayInfo_Data> embedded_display;
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<internal::ExternalDisplayInfo_Data>>> external_displays;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  uint8_t privacy_screen_supported : 1;
  uint8_t privacy_screen_enabled : 1;
  uint8_t pad1_[3];
  int32_t input_type;
  mojo::internal::Pointer<::ash::cros_healthd::mojom::internal::NullableUint32_Data> display_width;
  mojo::internal::Pointer<::ash::cros_healthd::mojom::internal::NullableUint32_Data> display_height;
  mojo::internal::Pointer<::ash::cros_healthd::mojom::internal::NullableUint32_Data> resolution_horizontal;
  mojo::internal::Pointer<::ash::cros_healthd::mojom::internal::NullableUint32_Data> resolution_vertical;
  mojo::internal::Pointer<::ash::cros_healthd::mojom::internal::NullableDouble_Data> refresh_rate;
  mojo::internal::Pointer<mojo::internal::String_Data> manufacturer;
  mojo::internal::Pointer<::ash::cros_healthd::mojom::internal::NullableUint16_Data> model_id;
  mojo::internal::Pointer<::ash::cros_healthd::mojom::internal::NullableUint32_Data> serial_number;
  mojo::internal::Pointer<::ash::cros_healthd::mojom::internal::NullableUint8_Data> manufacture_week;
  mojo::internal::Pointer<::ash::cros_healthd::mojom::internal::NullableUint16_Data> manufacture_year;
  mojo::internal::Pointer<mojo::internal::String_Data> edid_version;
  mojo::internal::Pointer<mojo::internal::String_Data> display_name;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<::ash::cros_healthd::mojom::internal::NullableUint32_Data> display_width;
  mojo::internal::Pointer<::ash::cros_healthd::mojom::internal::NullableUint32_Data> display_height;
  mojo::internal::Pointer<::ash::cros_healthd::mojom::internal::NullableUint32_Data> resolution_horizontal;
  mojo::internal::Pointer<::ash::cros_healthd::mojom::internal::NullableUint32_Data> resolution_vertical;
  mojo::internal::Pointer<::ash::cros_healthd::mojom::internal::NullableDouble_Data> refresh_rate;
  mojo::internal::Pointer<mojo::internal::String_Data> manufacturer;
  mojo::internal::Pointer<::ash::cros_healthd::mojom::internal::NullableUint16_Data> model_id;
  mojo::internal::Pointer<::ash::cros_healthd::mojom::internal::NullableUint32_Data> serial_number;
  mojo::internal::Pointer<::ash::cros_healthd::mojom::internal::NullableUint8_Data> manufacture_week;
  mojo::internal::Pointer<::ash::cros_healthd::mojom::internal::NullableUint16_Data> manufacture_year;
  mojo::internal::Pointer<mojo::internal::String_Data> edid_version;
  int32_t input_type;
  uint8_t pad11_[4];
  mojo::internal::Pointer<mojo::internal::String_Data> display_name;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::String_Data> vendor_name;
  mojo::internal::Pointer<mojo::internal::String_Data> device_name;
  mojo::internal::Pointer<mojo::internal::String_Data> device_type;
  mojo::internal::Pointer<mojo::internal::String_Data> device_uuid;
  uint32_t tx_speed_gbs;
  uint32_t rx_speed_gbs;
  uint8_t authorized : 1;
  uint8_t pad6_[7];
  mojo::internal::Pointer<mojo::internal::String_Data> device_fw_version;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  int32_t security_level;
  uint8_t pad0_[4];
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<internal::ThunderboltBusInterfaceInfo_Data>>> thunderbolt_interfaces;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::String_Data> touchpad_library_name;
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<internal::TouchscreenDevice_Data>>> touchscreen_devices;
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<internal::TouchpadDevice_Data>>> touchpad_devices;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<internal::InputDevice_Data> input_device;
  int32_t touch_points;
  uint8_t has_stylus : 1;
  uint8_t has_stylus_garage_switch : 1;
  uint8_t padfinal_[3];

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<internal::InputDevice_Data> input_device;
  mojo::internal::Pointer<mojo::internal::String_Data> driver_name;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::String_Data> name;
  int32_t connection_type;
  uint8_t is_enabled : 1;
  uint8_t pad2_[3];
  mojo::internal::Pointer<mojo::internal::String_Data> physical_location;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<::ash::cros_healthd::mojom::internal::NullableUint16_Data> lid_angle;
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<internal::Sensor_Data>>> sensors;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::String_Data> name;
  int32_t device_id;
  int32_t type;
  int32_t location;
  uint8_t padfinal_[4];

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

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

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

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

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

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    Sensor_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  ThermalInfo_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::ThermalSensorInfo_Data>>> thermal_sensors;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::String_Data> name;
  double temperature_celsius;
  int32_t source;
  uint8_t padfinal_[4];

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  internal::BatteryResult_Data battery_result;
  internal::NonRemovableBlockDeviceResult_Data block_device_result;
  internal::CpuResult_Data cpu_result;
  internal::TimezoneResult_Data timezone_result;
  internal::MemoryResult_Data memory_result;
  internal::BacklightResult_Data backlight_result;
  internal::FanResult_Data fan_result;
  internal::StatefulPartitionResult_Data stateful_partition_result;
  internal::BluetoothResult_Data bluetooth_result;
  internal::DEPRECATED_SystemResult_Data deprecated_system_result;
  internal::NetworkResult_Data network_result;
  internal::AudioResult_Data audio_result;
  internal::BootPerformanceResult_Data boot_performance_result;
  internal::BusResult_Data bus_result;
  internal::SystemResult_Data system_result;
  internal::TpmResult_Data tpm_result;
  internal::GraphicsResult_Data graphics_result;
  internal::DisplayResult_Data display_result;
  internal::NetworkInterfaceResult_Data network_interface_result;
  internal::InputResult_Data input_result;
  internal::AudioHardwareResult_Data audio_hardware_result;
  internal::SensorResult_Data sensor_result;
  internal::ThermalResult_Data thermal_result;

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

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

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

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

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

  UserType user_data_;
};

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

#pragma pack(pop)

}  // namespace internal

}  // ash::cros_healthd::mojom

#endif  // CHROMEOS_ASH_SERVICES_CROS_HEALTHD_PUBLIC_MOJOM_CROS_HEALTHD_PROBE_MOJOM_SHARED_INTERNAL_H_