// third_party/blink/public/mojom/bluetooth/web_bluetooth.mojom-params-data.h is auto generated by mojom_bindings_generator.py, do not edit

// Copyright 2019 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef THIRD_PARTY_BLINK_PUBLIC_MOJOM_BLUETOOTH_WEB_BLUETOOTH_MOJOM_PARAMS_DATA_H_
#define THIRD_PARTY_BLINK_PUBLIC_MOJOM_BLUETOOTH_WEB_BLUETOOTH_MOJOM_PARAMS_DATA_H_
#include "mojo/public/cpp/bindings/array_data_view.h"
#include "mojo/public/cpp/bindings/map_data_view.h"
#include "mojo/public/cpp/bindings/string_data_view.h"

#if defined(__clang__)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-private-field"
#endif

namespace mojo::internal {
class ValidationContext;
}


namespace blink::mojom {
namespace internal {
class COMPONENT_EXPORT(MOJOM_SHARED_BLINK_COMMON_EXPORT) WebBluetoothService_GetAvailability_Params_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;

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

  WebBluetoothService_GetAvailability_Params_Data();
  ~WebBluetoothService_GetAvailability_Params_Data() = delete;
};
static_assert(sizeof(WebBluetoothService_GetAvailability_Params_Data) == 8,
              "Bad sizeof(WebBluetoothService_GetAvailability_Params_Data)");
class COMPONENT_EXPORT(MOJOM_SHARED_BLINK_COMMON_EXPORT) WebBluetoothService_GetAvailability_ResponseParams_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

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

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

  WebBluetoothService_GetAvailability_ResponseParams_Data();
  ~WebBluetoothService_GetAvailability_ResponseParams_Data() = delete;
};
static_assert(sizeof(WebBluetoothService_GetAvailability_ResponseParams_Data) == 16,
              "Bad sizeof(WebBluetoothService_GetAvailability_ResponseParams_Data)");
class COMPONENT_EXPORT(MOJOM_SHARED_BLINK_COMMON_EXPORT) WebBluetoothService_RequestDevice_Params_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<internal::WebBluetoothRequestDeviceOptions_Data> options;

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

  WebBluetoothService_RequestDevice_Params_Data();
  ~WebBluetoothService_RequestDevice_Params_Data() = delete;
};
static_assert(sizeof(WebBluetoothService_RequestDevice_Params_Data) == 16,
              "Bad sizeof(WebBluetoothService_RequestDevice_Params_Data)");
class COMPONENT_EXPORT(MOJOM_SHARED_BLINK_COMMON_EXPORT) WebBluetoothService_RequestDevice_ResponseParams_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  int32_t result;
  uint8_t pad0_[4];
  mojo::internal::Pointer<internal::WebBluetoothDevice_Data> device;

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

  WebBluetoothService_RequestDevice_ResponseParams_Data();
  ~WebBluetoothService_RequestDevice_ResponseParams_Data() = delete;
};
static_assert(sizeof(WebBluetoothService_RequestDevice_ResponseParams_Data) == 24,
              "Bad sizeof(WebBluetoothService_RequestDevice_ResponseParams_Data)");
class COMPONENT_EXPORT(MOJOM_SHARED_BLINK_COMMON_EXPORT) WebBluetoothService_GetDevices_Params_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;

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

  WebBluetoothService_GetDevices_Params_Data();
  ~WebBluetoothService_GetDevices_Params_Data() = delete;
};
static_assert(sizeof(WebBluetoothService_GetDevices_Params_Data) == 8,
              "Bad sizeof(WebBluetoothService_GetDevices_Params_Data)");
class COMPONENT_EXPORT(MOJOM_SHARED_BLINK_COMMON_EXPORT) WebBluetoothService_GetDevices_ResponseParams_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::WebBluetoothDevice_Data>>> devices;

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

  WebBluetoothService_GetDevices_ResponseParams_Data();
  ~WebBluetoothService_GetDevices_ResponseParams_Data() = delete;
};
static_assert(sizeof(WebBluetoothService_GetDevices_ResponseParams_Data) == 16,
              "Bad sizeof(WebBluetoothService_GetDevices_ResponseParams_Data)");
class COMPONENT_EXPORT(MOJOM_SHARED_BLINK_COMMON_EXPORT) WebBluetoothService_ForgetDevice_Params_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<internal::WebBluetoothDeviceId_Data> device_id;

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

  WebBluetoothService_ForgetDevice_Params_Data();
  ~WebBluetoothService_ForgetDevice_Params_Data() = delete;
};
static_assert(sizeof(WebBluetoothService_ForgetDevice_Params_Data) == 16,
              "Bad sizeof(WebBluetoothService_ForgetDevice_Params_Data)");
class COMPONENT_EXPORT(MOJOM_SHARED_BLINK_COMMON_EXPORT) WebBluetoothService_ForgetDevice_ResponseParams_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;

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

  WebBluetoothService_ForgetDevice_ResponseParams_Data();
  ~WebBluetoothService_ForgetDevice_ResponseParams_Data() = delete;
};
static_assert(sizeof(WebBluetoothService_ForgetDevice_ResponseParams_Data) == 8,
              "Bad sizeof(WebBluetoothService_ForgetDevice_ResponseParams_Data)");
class COMPONENT_EXPORT(MOJOM_SHARED_BLINK_COMMON_EXPORT) WebBluetoothService_RemoteServerConnect_Params_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<internal::WebBluetoothDeviceId_Data> device_id;
  mojo::internal::AssociatedInterface_Data client;

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

  WebBluetoothService_RemoteServerConnect_Params_Data();
  ~WebBluetoothService_RemoteServerConnect_Params_Data() = delete;
};
static_assert(sizeof(WebBluetoothService_RemoteServerConnect_Params_Data) == 24,
              "Bad sizeof(WebBluetoothService_RemoteServerConnect_Params_Data)");
class COMPONENT_EXPORT(MOJOM_SHARED_BLINK_COMMON_EXPORT) WebBluetoothService_RemoteServerConnect_ResponseParams_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

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

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

  WebBluetoothService_RemoteServerConnect_ResponseParams_Data();
  ~WebBluetoothService_RemoteServerConnect_ResponseParams_Data() = delete;
};
static_assert(sizeof(WebBluetoothService_RemoteServerConnect_ResponseParams_Data) == 16,
              "Bad sizeof(WebBluetoothService_RemoteServerConnect_ResponseParams_Data)");
class COMPONENT_EXPORT(MOJOM_SHARED_BLINK_COMMON_EXPORT) WebBluetoothService_RemoteServerDisconnect_Params_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<internal::WebBluetoothDeviceId_Data> device_id;

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

  WebBluetoothService_RemoteServerDisconnect_Params_Data();
  ~WebBluetoothService_RemoteServerDisconnect_Params_Data() = delete;
};
static_assert(sizeof(WebBluetoothService_RemoteServerDisconnect_Params_Data) == 16,
              "Bad sizeof(WebBluetoothService_RemoteServerDisconnect_Params_Data)");
class COMPONENT_EXPORT(MOJOM_SHARED_BLINK_COMMON_EXPORT) WebBluetoothService_RemoteServerGetPrimaryServices_Params_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<internal::WebBluetoothDeviceId_Data> device_id;
  int32_t quantity;
  uint8_t pad1_[4];
  mojo::internal::Pointer<::bluetooth::mojom::internal::UUID_Data> services_uuid;

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

  WebBluetoothService_RemoteServerGetPrimaryServices_Params_Data();
  ~WebBluetoothService_RemoteServerGetPrimaryServices_Params_Data() = delete;
};
static_assert(sizeof(WebBluetoothService_RemoteServerGetPrimaryServices_Params_Data) == 32,
              "Bad sizeof(WebBluetoothService_RemoteServerGetPrimaryServices_Params_Data)");
class COMPONENT_EXPORT(MOJOM_SHARED_BLINK_COMMON_EXPORT) WebBluetoothService_RemoteServerGetPrimaryServices_ResponseParams_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  int32_t result;
  uint8_t pad0_[4];
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<internal::WebBluetoothRemoteGATTService_Data>>> services;

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

  WebBluetoothService_RemoteServerGetPrimaryServices_ResponseParams_Data();
  ~WebBluetoothService_RemoteServerGetPrimaryServices_ResponseParams_Data() = delete;
};
static_assert(sizeof(WebBluetoothService_RemoteServerGetPrimaryServices_ResponseParams_Data) == 24,
              "Bad sizeof(WebBluetoothService_RemoteServerGetPrimaryServices_ResponseParams_Data)");
class COMPONENT_EXPORT(MOJOM_SHARED_BLINK_COMMON_EXPORT) WebBluetoothService_RemoteServiceGetCharacteristics_Params_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::String_Data> service_instance_id;
  int32_t quantity;
  uint8_t pad1_[4];
  mojo::internal::Pointer<::bluetooth::mojom::internal::UUID_Data> characteristics_uuid;

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

  WebBluetoothService_RemoteServiceGetCharacteristics_Params_Data();
  ~WebBluetoothService_RemoteServiceGetCharacteristics_Params_Data() = delete;
};
static_assert(sizeof(WebBluetoothService_RemoteServiceGetCharacteristics_Params_Data) == 32,
              "Bad sizeof(WebBluetoothService_RemoteServiceGetCharacteristics_Params_Data)");
class COMPONENT_EXPORT(MOJOM_SHARED_BLINK_COMMON_EXPORT) WebBluetoothService_RemoteServiceGetCharacteristics_ResponseParams_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  int32_t result;
  uint8_t pad0_[4];
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<internal::WebBluetoothRemoteGATTCharacteristic_Data>>> characteristics;

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

  WebBluetoothService_RemoteServiceGetCharacteristics_ResponseParams_Data();
  ~WebBluetoothService_RemoteServiceGetCharacteristics_ResponseParams_Data() = delete;
};
static_assert(sizeof(WebBluetoothService_RemoteServiceGetCharacteristics_ResponseParams_Data) == 24,
              "Bad sizeof(WebBluetoothService_RemoteServiceGetCharacteristics_ResponseParams_Data)");
class COMPONENT_EXPORT(MOJOM_SHARED_BLINK_COMMON_EXPORT) WebBluetoothService_RemoteCharacteristicReadValue_Params_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

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

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

  WebBluetoothService_RemoteCharacteristicReadValue_Params_Data();
  ~WebBluetoothService_RemoteCharacteristicReadValue_Params_Data() = delete;
};
static_assert(sizeof(WebBluetoothService_RemoteCharacteristicReadValue_Params_Data) == 16,
              "Bad sizeof(WebBluetoothService_RemoteCharacteristicReadValue_Params_Data)");
class COMPONENT_EXPORT(MOJOM_SHARED_BLINK_COMMON_EXPORT) WebBluetoothService_RemoteCharacteristicReadValue_ResponseParams_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  int32_t result;
  uint8_t pad0_[4];
  mojo::internal::Pointer<::mojo_base::mojom::internal::ReadOnlyBuffer_Data> value;

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

  WebBluetoothService_RemoteCharacteristicReadValue_ResponseParams_Data();
  ~WebBluetoothService_RemoteCharacteristicReadValue_ResponseParams_Data() = delete;
};
static_assert(sizeof(WebBluetoothService_RemoteCharacteristicReadValue_ResponseParams_Data) == 24,
              "Bad sizeof(WebBluetoothService_RemoteCharacteristicReadValue_ResponseParams_Data)");
class COMPONENT_EXPORT(MOJOM_SHARED_BLINK_COMMON_EXPORT) WebBluetoothService_RemoteCharacteristicWriteValue_Params_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::String_Data> characteristic_instance_id;
  mojo::internal::Pointer<::mojo_base::mojom::internal::ReadOnlyBuffer_Data> value;
  int32_t write_type;
  uint8_t padfinal_[4];

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

  WebBluetoothService_RemoteCharacteristicWriteValue_Params_Data();
  ~WebBluetoothService_RemoteCharacteristicWriteValue_Params_Data() = delete;
};
static_assert(sizeof(WebBluetoothService_RemoteCharacteristicWriteValue_Params_Data) == 32,
              "Bad sizeof(WebBluetoothService_RemoteCharacteristicWriteValue_Params_Data)");
class COMPONENT_EXPORT(MOJOM_SHARED_BLINK_COMMON_EXPORT) WebBluetoothService_RemoteCharacteristicWriteValue_ResponseParams_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

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

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

  WebBluetoothService_RemoteCharacteristicWriteValue_ResponseParams_Data();
  ~WebBluetoothService_RemoteCharacteristicWriteValue_ResponseParams_Data() = delete;
};
static_assert(sizeof(WebBluetoothService_RemoteCharacteristicWriteValue_ResponseParams_Data) == 16,
              "Bad sizeof(WebBluetoothService_RemoteCharacteristicWriteValue_ResponseParams_Data)");
class COMPONENT_EXPORT(MOJOM_SHARED_BLINK_COMMON_EXPORT) WebBluetoothService_RemoteCharacteristicStartNotifications_Params_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::String_Data> characteristic_instance_id;
  mojo::internal::AssociatedInterface_Data client;

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

  WebBluetoothService_RemoteCharacteristicStartNotifications_Params_Data();
  ~WebBluetoothService_RemoteCharacteristicStartNotifications_Params_Data() = delete;
};
static_assert(sizeof(WebBluetoothService_RemoteCharacteristicStartNotifications_Params_Data) == 24,
              "Bad sizeof(WebBluetoothService_RemoteCharacteristicStartNotifications_Params_Data)");
class COMPONENT_EXPORT(MOJOM_SHARED_BLINK_COMMON_EXPORT) WebBluetoothService_RemoteCharacteristicStartNotifications_ResponseParams_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

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

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

  WebBluetoothService_RemoteCharacteristicStartNotifications_ResponseParams_Data();
  ~WebBluetoothService_RemoteCharacteristicStartNotifications_ResponseParams_Data() = delete;
};
static_assert(sizeof(WebBluetoothService_RemoteCharacteristicStartNotifications_ResponseParams_Data) == 16,
              "Bad sizeof(WebBluetoothService_RemoteCharacteristicStartNotifications_ResponseParams_Data)");
class COMPONENT_EXPORT(MOJOM_SHARED_BLINK_COMMON_EXPORT) WebBluetoothService_RemoteCharacteristicStopNotifications_Params_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

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

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

  WebBluetoothService_RemoteCharacteristicStopNotifications_Params_Data();
  ~WebBluetoothService_RemoteCharacteristicStopNotifications_Params_Data() = delete;
};
static_assert(sizeof(WebBluetoothService_RemoteCharacteristicStopNotifications_Params_Data) == 16,
              "Bad sizeof(WebBluetoothService_RemoteCharacteristicStopNotifications_Params_Data)");
class COMPONENT_EXPORT(MOJOM_SHARED_BLINK_COMMON_EXPORT) WebBluetoothService_RemoteCharacteristicStopNotifications_ResponseParams_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;

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

  WebBluetoothService_RemoteCharacteristicStopNotifications_ResponseParams_Data();
  ~WebBluetoothService_RemoteCharacteristicStopNotifications_ResponseParams_Data() = delete;
};
static_assert(sizeof(WebBluetoothService_RemoteCharacteristicStopNotifications_ResponseParams_Data) == 8,
              "Bad sizeof(WebBluetoothService_RemoteCharacteristicStopNotifications_ResponseParams_Data)");
class COMPONENT_EXPORT(MOJOM_SHARED_BLINK_COMMON_EXPORT) WebBluetoothService_RemoteCharacteristicGetDescriptors_Params_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::String_Data> characteristics_instance_id;
  int32_t quantity;
  uint8_t pad1_[4];
  mojo::internal::Pointer<::bluetooth::mojom::internal::UUID_Data> descriptor_uuid;

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

  WebBluetoothService_RemoteCharacteristicGetDescriptors_Params_Data();
  ~WebBluetoothService_RemoteCharacteristicGetDescriptors_Params_Data() = delete;
};
static_assert(sizeof(WebBluetoothService_RemoteCharacteristicGetDescriptors_Params_Data) == 32,
              "Bad sizeof(WebBluetoothService_RemoteCharacteristicGetDescriptors_Params_Data)");
class COMPONENT_EXPORT(MOJOM_SHARED_BLINK_COMMON_EXPORT) WebBluetoothService_RemoteCharacteristicGetDescriptors_ResponseParams_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  int32_t result;
  uint8_t pad0_[4];
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<internal::WebBluetoothRemoteGATTDescriptor_Data>>> descriptors;

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

  WebBluetoothService_RemoteCharacteristicGetDescriptors_ResponseParams_Data();
  ~WebBluetoothService_RemoteCharacteristicGetDescriptors_ResponseParams_Data() = delete;
};
static_assert(sizeof(WebBluetoothService_RemoteCharacteristicGetDescriptors_ResponseParams_Data) == 24,
              "Bad sizeof(WebBluetoothService_RemoteCharacteristicGetDescriptors_ResponseParams_Data)");
class COMPONENT_EXPORT(MOJOM_SHARED_BLINK_COMMON_EXPORT) WebBluetoothService_RemoteDescriptorReadValue_Params_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

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

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

  WebBluetoothService_RemoteDescriptorReadValue_Params_Data();
  ~WebBluetoothService_RemoteDescriptorReadValue_Params_Data() = delete;
};
static_assert(sizeof(WebBluetoothService_RemoteDescriptorReadValue_Params_Data) == 16,
              "Bad sizeof(WebBluetoothService_RemoteDescriptorReadValue_Params_Data)");
class COMPONENT_EXPORT(MOJOM_SHARED_BLINK_COMMON_EXPORT) WebBluetoothService_RemoteDescriptorReadValue_ResponseParams_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  int32_t result;
  uint8_t pad0_[4];
  mojo::internal::Pointer<::mojo_base::mojom::internal::ReadOnlyBuffer_Data> value;

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

  WebBluetoothService_RemoteDescriptorReadValue_ResponseParams_Data();
  ~WebBluetoothService_RemoteDescriptorReadValue_ResponseParams_Data() = delete;
};
static_assert(sizeof(WebBluetoothService_RemoteDescriptorReadValue_ResponseParams_Data) == 24,
              "Bad sizeof(WebBluetoothService_RemoteDescriptorReadValue_ResponseParams_Data)");
class COMPONENT_EXPORT(MOJOM_SHARED_BLINK_COMMON_EXPORT) WebBluetoothService_RemoteDescriptorWriteValue_Params_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::String_Data> descriptor_instance_id;
  mojo::internal::Pointer<::mojo_base::mojom::internal::ReadOnlyBuffer_Data> value;

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

  WebBluetoothService_RemoteDescriptorWriteValue_Params_Data();
  ~WebBluetoothService_RemoteDescriptorWriteValue_Params_Data() = delete;
};
static_assert(sizeof(WebBluetoothService_RemoteDescriptorWriteValue_Params_Data) == 24,
              "Bad sizeof(WebBluetoothService_RemoteDescriptorWriteValue_Params_Data)");
class COMPONENT_EXPORT(MOJOM_SHARED_BLINK_COMMON_EXPORT) WebBluetoothService_RemoteDescriptorWriteValue_ResponseParams_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

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

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

  WebBluetoothService_RemoteDescriptorWriteValue_ResponseParams_Data();
  ~WebBluetoothService_RemoteDescriptorWriteValue_ResponseParams_Data() = delete;
};
static_assert(sizeof(WebBluetoothService_RemoteDescriptorWriteValue_ResponseParams_Data) == 16,
              "Bad sizeof(WebBluetoothService_RemoteDescriptorWriteValue_ResponseParams_Data)");
class COMPONENT_EXPORT(MOJOM_SHARED_BLINK_COMMON_EXPORT) WebBluetoothService_RequestScanningStart_Params_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::AssociatedInterface_Data client;
  mojo::internal::Pointer<internal::WebBluetoothRequestLEScanOptions_Data> options;

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

  WebBluetoothService_RequestScanningStart_Params_Data();
  ~WebBluetoothService_RequestScanningStart_Params_Data() = delete;
};
static_assert(sizeof(WebBluetoothService_RequestScanningStart_Params_Data) == 24,
              "Bad sizeof(WebBluetoothService_RequestScanningStart_Params_Data)");
class COMPONENT_EXPORT(MOJOM_SHARED_BLINK_COMMON_EXPORT) WebBluetoothService_RequestScanningStart_ResponseParams_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

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

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

  WebBluetoothService_RequestScanningStart_ResponseParams_Data();
  ~WebBluetoothService_RequestScanningStart_ResponseParams_Data() = delete;
};
static_assert(sizeof(WebBluetoothService_RequestScanningStart_ResponseParams_Data) == 16,
              "Bad sizeof(WebBluetoothService_RequestScanningStart_ResponseParams_Data)");
class COMPONENT_EXPORT(MOJOM_SHARED_BLINK_COMMON_EXPORT) WebBluetoothService_WatchAdvertisementsForDevice_Params_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<internal::WebBluetoothDeviceId_Data> device_id;
  mojo::internal::AssociatedInterface_Data client;

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

  WebBluetoothService_WatchAdvertisementsForDevice_Params_Data();
  ~WebBluetoothService_WatchAdvertisementsForDevice_Params_Data() = delete;
};
static_assert(sizeof(WebBluetoothService_WatchAdvertisementsForDevice_Params_Data) == 24,
              "Bad sizeof(WebBluetoothService_WatchAdvertisementsForDevice_Params_Data)");
class COMPONENT_EXPORT(MOJOM_SHARED_BLINK_COMMON_EXPORT) WebBluetoothService_WatchAdvertisementsForDevice_ResponseParams_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

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

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

  WebBluetoothService_WatchAdvertisementsForDevice_ResponseParams_Data();
  ~WebBluetoothService_WatchAdvertisementsForDevice_ResponseParams_Data() = delete;
};
static_assert(sizeof(WebBluetoothService_WatchAdvertisementsForDevice_ResponseParams_Data) == 16,
              "Bad sizeof(WebBluetoothService_WatchAdvertisementsForDevice_ResponseParams_Data)");
class COMPONENT_EXPORT(MOJOM_SHARED_BLINK_COMMON_EXPORT) WebBluetoothServerClient_GATTServerDisconnected_Params_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;

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

  WebBluetoothServerClient_GATTServerDisconnected_Params_Data();
  ~WebBluetoothServerClient_GATTServerDisconnected_Params_Data() = delete;
};
static_assert(sizeof(WebBluetoothServerClient_GATTServerDisconnected_Params_Data) == 8,
              "Bad sizeof(WebBluetoothServerClient_GATTServerDisconnected_Params_Data)");
class COMPONENT_EXPORT(MOJOM_SHARED_BLINK_COMMON_EXPORT) WebBluetoothCharacteristicClient_RemoteCharacteristicValueChanged_Params_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<::mojo_base::mojom::internal::ReadOnlyBuffer_Data> value;

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

  WebBluetoothCharacteristicClient_RemoteCharacteristicValueChanged_Params_Data();
  ~WebBluetoothCharacteristicClient_RemoteCharacteristicValueChanged_Params_Data() = delete;
};
static_assert(sizeof(WebBluetoothCharacteristicClient_RemoteCharacteristicValueChanged_Params_Data) == 16,
              "Bad sizeof(WebBluetoothCharacteristicClient_RemoteCharacteristicValueChanged_Params_Data)");
class COMPONENT_EXPORT(MOJOM_SHARED_BLINK_COMMON_EXPORT) WebBluetoothAdvertisementClient_AdvertisingEvent_Params_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<internal::WebBluetoothAdvertisingEvent_Data> result;

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

  WebBluetoothAdvertisementClient_AdvertisingEvent_Params_Data();
  ~WebBluetoothAdvertisementClient_AdvertisingEvent_Params_Data() = delete;
};
static_assert(sizeof(WebBluetoothAdvertisementClient_AdvertisingEvent_Params_Data) == 16,
              "Bad sizeof(WebBluetoothAdvertisementClient_AdvertisingEvent_Params_Data)");

}  // namespace internal


class WebBluetoothService_GetAvailability_ParamsDataView {
 public:
  WebBluetoothService_GetAvailability_ParamsDataView() = default;

  WebBluetoothService_GetAvailability_ParamsDataView(
      internal::WebBluetoothService_GetAvailability_Params_Data* data,
      mojo::Message* message)
      : data_(data) {}

  bool is_null() const { return !data_; }
 private:
  internal::WebBluetoothService_GetAvailability_Params_Data* data_ = nullptr;
};


class WebBluetoothService_GetAvailability_ResponseParamsDataView {
 public:
  WebBluetoothService_GetAvailability_ResponseParamsDataView() = default;

  WebBluetoothService_GetAvailability_ResponseParamsDataView(
      internal::WebBluetoothService_GetAvailability_ResponseParams_Data* data,
      mojo::Message* message)
      : data_(data) {}

  bool is_null() const { return !data_; }
  bool is_available() const {
    return data_->is_available;
  }
 private:
  internal::WebBluetoothService_GetAvailability_ResponseParams_Data* data_ = nullptr;
};


class WebBluetoothService_RequestDevice_ParamsDataView {
 public:
  WebBluetoothService_RequestDevice_ParamsDataView() = default;

  WebBluetoothService_RequestDevice_ParamsDataView(
      internal::WebBluetoothService_RequestDevice_Params_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  inline void GetOptionsDataView(
      WebBluetoothRequestDeviceOptionsDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadOptions(UserType* output) {
    
    auto* pointer = data_->options.Get();
    return mojo::internal::Deserialize<::blink::mojom::WebBluetoothRequestDeviceOptionsDataView>(
        pointer, output, message_);
  }
 private:
  internal::WebBluetoothService_RequestDevice_Params_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class WebBluetoothService_RequestDevice_ResponseParamsDataView {
 public:
  WebBluetoothService_RequestDevice_ResponseParamsDataView() = default;

  WebBluetoothService_RequestDevice_ResponseParamsDataView(
      internal::WebBluetoothService_RequestDevice_ResponseParams_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  template <typename UserType>
  [[nodiscard]] bool ReadResult(UserType* output) const {
    auto data_value = data_->result;
    return mojo::internal::Deserialize<::blink::mojom::WebBluetoothResult>(
        data_value, output);
  }
  WebBluetoothResult result() const {
    return ::mojo::internal::ToKnownEnumValueHelper(
          static_cast<::blink::mojom::WebBluetoothResult>(data_->result));
  }
  inline void GetDeviceDataView(
      WebBluetoothDeviceDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadDevice(UserType* output) {
    
static_assert(
    mojo::internal::IsValidUserTypeForOptionalValue<
        ::blink::mojom::WebBluetoothDeviceDataView, UserType>(),
    "Attempting to read the optional `device` field into a type which "
    "cannot represent a null value. Either wrap the destination object "
    "with std::optional, ensure that any corresponding "
    "{Struct/Union/Array/String}Traits define the necessary IsNull and "
    "SetToNull methods, or use `MaybeReadDevice` instead "
    "of `ReadDevice if you're fine with null values being "
    "silently ignored in this case.");
    auto* pointer = data_->device.Get();
    return mojo::internal::Deserialize<::blink::mojom::WebBluetoothDeviceDataView>(
        pointer, output, message_);
  }
 private:
  internal::WebBluetoothService_RequestDevice_ResponseParams_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class WebBluetoothService_GetDevices_ParamsDataView {
 public:
  WebBluetoothService_GetDevices_ParamsDataView() = default;

  WebBluetoothService_GetDevices_ParamsDataView(
      internal::WebBluetoothService_GetDevices_Params_Data* data,
      mojo::Message* message)
      : data_(data) {}

  bool is_null() const { return !data_; }
 private:
  internal::WebBluetoothService_GetDevices_Params_Data* data_ = nullptr;
};


class WebBluetoothService_GetDevices_ResponseParamsDataView {
 public:
  WebBluetoothService_GetDevices_ResponseParamsDataView() = default;

  WebBluetoothService_GetDevices_ResponseParamsDataView(
      internal::WebBluetoothService_GetDevices_ResponseParams_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  inline void GetDevicesDataView(
      mojo::ArrayDataView<WebBluetoothDeviceDataView>* output);

  template <typename UserType>
  [[nodiscard]] bool ReadDevices(UserType* output) {
    
    auto* pointer = data_->devices.Get();
    return mojo::internal::Deserialize<mojo::ArrayDataView<::blink::mojom::WebBluetoothDeviceDataView>>(
        pointer, output, message_);
  }
 private:
  internal::WebBluetoothService_GetDevices_ResponseParams_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class WebBluetoothService_ForgetDevice_ParamsDataView {
 public:
  WebBluetoothService_ForgetDevice_ParamsDataView() = default;

  WebBluetoothService_ForgetDevice_ParamsDataView(
      internal::WebBluetoothService_ForgetDevice_Params_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  inline void GetDeviceIdDataView(
      WebBluetoothDeviceIdDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadDeviceId(UserType* output) {
    
    auto* pointer = data_->device_id.Get();
    return mojo::internal::Deserialize<::blink::mojom::WebBluetoothDeviceIdDataView>(
        pointer, output, message_);
  }
 private:
  internal::WebBluetoothService_ForgetDevice_Params_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class WebBluetoothService_ForgetDevice_ResponseParamsDataView {
 public:
  WebBluetoothService_ForgetDevice_ResponseParamsDataView() = default;

  WebBluetoothService_ForgetDevice_ResponseParamsDataView(
      internal::WebBluetoothService_ForgetDevice_ResponseParams_Data* data,
      mojo::Message* message)
      : data_(data) {}

  bool is_null() const { return !data_; }
 private:
  internal::WebBluetoothService_ForgetDevice_ResponseParams_Data* data_ = nullptr;
};


class WebBluetoothService_RemoteServerConnect_ParamsDataView {
 public:
  WebBluetoothService_RemoteServerConnect_ParamsDataView() = default;

  WebBluetoothService_RemoteServerConnect_ParamsDataView(
      internal::WebBluetoothService_RemoteServerConnect_Params_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  inline void GetDeviceIdDataView(
      WebBluetoothDeviceIdDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadDeviceId(UserType* output) {
    
    auto* pointer = data_->device_id.Get();
    return mojo::internal::Deserialize<::blink::mojom::WebBluetoothDeviceIdDataView>(
        pointer, output, message_);
  }
  template <typename UserType>
  UserType TakeClient() {
    UserType result;
    bool ret =
        mojo::internal::Deserialize<::blink::mojom::WebBluetoothServerClientAssociatedPtrInfoDataView>(
            &data_->client, &result, message_);
    DCHECK(ret);
    return result;
  }
 private:
  internal::WebBluetoothService_RemoteServerConnect_Params_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class WebBluetoothService_RemoteServerConnect_ResponseParamsDataView {
 public:
  WebBluetoothService_RemoteServerConnect_ResponseParamsDataView() = default;

  WebBluetoothService_RemoteServerConnect_ResponseParamsDataView(
      internal::WebBluetoothService_RemoteServerConnect_ResponseParams_Data* data,
      mojo::Message* message)
      : data_(data) {}

  bool is_null() const { return !data_; }
  template <typename UserType>
  [[nodiscard]] bool ReadResult(UserType* output) const {
    auto data_value = data_->result;
    return mojo::internal::Deserialize<::blink::mojom::WebBluetoothResult>(
        data_value, output);
  }
  WebBluetoothResult result() const {
    return ::mojo::internal::ToKnownEnumValueHelper(
          static_cast<::blink::mojom::WebBluetoothResult>(data_->result));
  }
 private:
  internal::WebBluetoothService_RemoteServerConnect_ResponseParams_Data* data_ = nullptr;
};


class WebBluetoothService_RemoteServerDisconnect_ParamsDataView {
 public:
  WebBluetoothService_RemoteServerDisconnect_ParamsDataView() = default;

  WebBluetoothService_RemoteServerDisconnect_ParamsDataView(
      internal::WebBluetoothService_RemoteServerDisconnect_Params_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  inline void GetDeviceIdDataView(
      WebBluetoothDeviceIdDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadDeviceId(UserType* output) {
    
    auto* pointer = data_->device_id.Get();
    return mojo::internal::Deserialize<::blink::mojom::WebBluetoothDeviceIdDataView>(
        pointer, output, message_);
  }
 private:
  internal::WebBluetoothService_RemoteServerDisconnect_Params_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class WebBluetoothService_RemoteServerGetPrimaryServices_ParamsDataView {
 public:
  WebBluetoothService_RemoteServerGetPrimaryServices_ParamsDataView() = default;

  WebBluetoothService_RemoteServerGetPrimaryServices_ParamsDataView(
      internal::WebBluetoothService_RemoteServerGetPrimaryServices_Params_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  inline void GetDeviceIdDataView(
      WebBluetoothDeviceIdDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadDeviceId(UserType* output) {
    
    auto* pointer = data_->device_id.Get();
    return mojo::internal::Deserialize<::blink::mojom::WebBluetoothDeviceIdDataView>(
        pointer, output, message_);
  }
  template <typename UserType>
  [[nodiscard]] bool ReadQuantity(UserType* output) const {
    auto data_value = data_->quantity;
    return mojo::internal::Deserialize<::blink::mojom::WebBluetoothGATTQueryQuantity>(
        data_value, output);
  }
  WebBluetoothGATTQueryQuantity quantity() const {
    return ::mojo::internal::ToKnownEnumValueHelper(
          static_cast<::blink::mojom::WebBluetoothGATTQueryQuantity>(data_->quantity));
  }
  inline void GetServicesUuidDataView(
      ::bluetooth::mojom::UUIDDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadServicesUuid(UserType* output) {
    
static_assert(
    mojo::internal::IsValidUserTypeForOptionalValue<
        ::bluetooth::mojom::UUIDDataView, UserType>(),
    "Attempting to read the optional `services_uuid` field into a type which "
    "cannot represent a null value. Either wrap the destination object "
    "with std::optional, ensure that any corresponding "
    "{Struct/Union/Array/String}Traits define the necessary IsNull and "
    "SetToNull methods, or use `MaybeReadServicesUuid` instead "
    "of `ReadServicesUuid if you're fine with null values being "
    "silently ignored in this case.");
    auto* pointer = data_->services_uuid.Get();
    return mojo::internal::Deserialize<::bluetooth::mojom::UUIDDataView>(
        pointer, output, message_);
  }
 private:
  internal::WebBluetoothService_RemoteServerGetPrimaryServices_Params_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class WebBluetoothService_RemoteServerGetPrimaryServices_ResponseParamsDataView {
 public:
  WebBluetoothService_RemoteServerGetPrimaryServices_ResponseParamsDataView() = default;

  WebBluetoothService_RemoteServerGetPrimaryServices_ResponseParamsDataView(
      internal::WebBluetoothService_RemoteServerGetPrimaryServices_ResponseParams_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  template <typename UserType>
  [[nodiscard]] bool ReadResult(UserType* output) const {
    auto data_value = data_->result;
    return mojo::internal::Deserialize<::blink::mojom::WebBluetoothResult>(
        data_value, output);
  }
  WebBluetoothResult result() const {
    return ::mojo::internal::ToKnownEnumValueHelper(
          static_cast<::blink::mojom::WebBluetoothResult>(data_->result));
  }
  inline void GetServicesDataView(
      mojo::ArrayDataView<WebBluetoothRemoteGATTServiceDataView>* output);

  template <typename UserType>
  [[nodiscard]] bool ReadServices(UserType* output) {
    
static_assert(
    mojo::internal::IsValidUserTypeForOptionalValue<
        mojo::ArrayDataView<::blink::mojom::WebBluetoothRemoteGATTServiceDataView>, UserType>(),
    "Attempting to read the optional `services` field into a type which "
    "cannot represent a null value. Either wrap the destination object "
    "with std::optional, ensure that any corresponding "
    "{Struct/Union/Array/String}Traits define the necessary IsNull and "
    "SetToNull methods, or use `MaybeReadServices` instead "
    "of `ReadServices if you're fine with null values being "
    "silently ignored in this case.");
    auto* pointer = data_->services.Get();
    return mojo::internal::Deserialize<mojo::ArrayDataView<::blink::mojom::WebBluetoothRemoteGATTServiceDataView>>(
        pointer, output, message_);
  }
 private:
  internal::WebBluetoothService_RemoteServerGetPrimaryServices_ResponseParams_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class WebBluetoothService_RemoteServiceGetCharacteristics_ParamsDataView {
 public:
  WebBluetoothService_RemoteServiceGetCharacteristics_ParamsDataView() = default;

  WebBluetoothService_RemoteServiceGetCharacteristics_ParamsDataView(
      internal::WebBluetoothService_RemoteServiceGetCharacteristics_Params_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  inline void GetServiceInstanceIdDataView(
      mojo::StringDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadServiceInstanceId(UserType* output) {
    
    auto* pointer = data_->service_instance_id.Get();
    return mojo::internal::Deserialize<mojo::StringDataView>(
        pointer, output, message_);
  }
  template <typename UserType>
  [[nodiscard]] bool ReadQuantity(UserType* output) const {
    auto data_value = data_->quantity;
    return mojo::internal::Deserialize<::blink::mojom::WebBluetoothGATTQueryQuantity>(
        data_value, output);
  }
  WebBluetoothGATTQueryQuantity quantity() const {
    return ::mojo::internal::ToKnownEnumValueHelper(
          static_cast<::blink::mojom::WebBluetoothGATTQueryQuantity>(data_->quantity));
  }
  inline void GetCharacteristicsUuidDataView(
      ::bluetooth::mojom::UUIDDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadCharacteristicsUuid(UserType* output) {
    
static_assert(
    mojo::internal::IsValidUserTypeForOptionalValue<
        ::bluetooth::mojom::UUIDDataView, UserType>(),
    "Attempting to read the optional `characteristics_uuid` field into a type which "
    "cannot represent a null value. Either wrap the destination object "
    "with std::optional, ensure that any corresponding "
    "{Struct/Union/Array/String}Traits define the necessary IsNull and "
    "SetToNull methods, or use `MaybeReadCharacteristicsUuid` instead "
    "of `ReadCharacteristicsUuid if you're fine with null values being "
    "silently ignored in this case.");
    auto* pointer = data_->characteristics_uuid.Get();
    return mojo::internal::Deserialize<::bluetooth::mojom::UUIDDataView>(
        pointer, output, message_);
  }
 private:
  internal::WebBluetoothService_RemoteServiceGetCharacteristics_Params_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class WebBluetoothService_RemoteServiceGetCharacteristics_ResponseParamsDataView {
 public:
  WebBluetoothService_RemoteServiceGetCharacteristics_ResponseParamsDataView() = default;

  WebBluetoothService_RemoteServiceGetCharacteristics_ResponseParamsDataView(
      internal::WebBluetoothService_RemoteServiceGetCharacteristics_ResponseParams_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  template <typename UserType>
  [[nodiscard]] bool ReadResult(UserType* output) const {
    auto data_value = data_->result;
    return mojo::internal::Deserialize<::blink::mojom::WebBluetoothResult>(
        data_value, output);
  }
  WebBluetoothResult result() const {
    return ::mojo::internal::ToKnownEnumValueHelper(
          static_cast<::blink::mojom::WebBluetoothResult>(data_->result));
  }
  inline void GetCharacteristicsDataView(
      mojo::ArrayDataView<WebBluetoothRemoteGATTCharacteristicDataView>* output);

  template <typename UserType>
  [[nodiscard]] bool ReadCharacteristics(UserType* output) {
    
static_assert(
    mojo::internal::IsValidUserTypeForOptionalValue<
        mojo::ArrayDataView<::blink::mojom::WebBluetoothRemoteGATTCharacteristicDataView>, UserType>(),
    "Attempting to read the optional `characteristics` field into a type which "
    "cannot represent a null value. Either wrap the destination object "
    "with std::optional, ensure that any corresponding "
    "{Struct/Union/Array/String}Traits define the necessary IsNull and "
    "SetToNull methods, or use `MaybeReadCharacteristics` instead "
    "of `ReadCharacteristics if you're fine with null values being "
    "silently ignored in this case.");
    auto* pointer = data_->characteristics.Get();
    return mojo::internal::Deserialize<mojo::ArrayDataView<::blink::mojom::WebBluetoothRemoteGATTCharacteristicDataView>>(
        pointer, output, message_);
  }
 private:
  internal::WebBluetoothService_RemoteServiceGetCharacteristics_ResponseParams_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class WebBluetoothService_RemoteCharacteristicReadValue_ParamsDataView {
 public:
  WebBluetoothService_RemoteCharacteristicReadValue_ParamsDataView() = default;

  WebBluetoothService_RemoteCharacteristicReadValue_ParamsDataView(
      internal::WebBluetoothService_RemoteCharacteristicReadValue_Params_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  inline void GetCharacteristicInstanceIdDataView(
      mojo::StringDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadCharacteristicInstanceId(UserType* output) {
    
    auto* pointer = data_->characteristic_instance_id.Get();
    return mojo::internal::Deserialize<mojo::StringDataView>(
        pointer, output, message_);
  }
 private:
  internal::WebBluetoothService_RemoteCharacteristicReadValue_Params_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class WebBluetoothService_RemoteCharacteristicReadValue_ResponseParamsDataView {
 public:
  WebBluetoothService_RemoteCharacteristicReadValue_ResponseParamsDataView() = default;

  WebBluetoothService_RemoteCharacteristicReadValue_ResponseParamsDataView(
      internal::WebBluetoothService_RemoteCharacteristicReadValue_ResponseParams_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  template <typename UserType>
  [[nodiscard]] bool ReadResult(UserType* output) const {
    auto data_value = data_->result;
    return mojo::internal::Deserialize<::blink::mojom::WebBluetoothResult>(
        data_value, output);
  }
  WebBluetoothResult result() const {
    return ::mojo::internal::ToKnownEnumValueHelper(
          static_cast<::blink::mojom::WebBluetoothResult>(data_->result));
  }
  inline void GetValueDataView(
      ::mojo_base::mojom::ReadOnlyBufferDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadValue(UserType* output) {
    
    auto* pointer = data_->value.Get();
    return mojo::internal::Deserialize<::mojo_base::mojom::ReadOnlyBufferDataView>(
        pointer, output, message_);
  }
 private:
  internal::WebBluetoothService_RemoteCharacteristicReadValue_ResponseParams_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class WebBluetoothService_RemoteCharacteristicWriteValue_ParamsDataView {
 public:
  WebBluetoothService_RemoteCharacteristicWriteValue_ParamsDataView() = default;

  WebBluetoothService_RemoteCharacteristicWriteValue_ParamsDataView(
      internal::WebBluetoothService_RemoteCharacteristicWriteValue_Params_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  inline void GetCharacteristicInstanceIdDataView(
      mojo::StringDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadCharacteristicInstanceId(UserType* output) {
    
    auto* pointer = data_->characteristic_instance_id.Get();
    return mojo::internal::Deserialize<mojo::StringDataView>(
        pointer, output, message_);
  }
  inline void GetValueDataView(
      ::mojo_base::mojom::ReadOnlyBufferDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadValue(UserType* output) {
    
    auto* pointer = data_->value.Get();
    return mojo::internal::Deserialize<::mojo_base::mojom::ReadOnlyBufferDataView>(
        pointer, output, message_);
  }
  template <typename UserType>
  [[nodiscard]] bool ReadWriteType(UserType* output) const {
    auto data_value = data_->write_type;
    return mojo::internal::Deserialize<::blink::mojom::WebBluetoothWriteType>(
        data_value, output);
  }
  WebBluetoothWriteType write_type() const {
    return ::mojo::internal::ToKnownEnumValueHelper(
          static_cast<::blink::mojom::WebBluetoothWriteType>(data_->write_type));
  }
 private:
  internal::WebBluetoothService_RemoteCharacteristicWriteValue_Params_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class WebBluetoothService_RemoteCharacteristicWriteValue_ResponseParamsDataView {
 public:
  WebBluetoothService_RemoteCharacteristicWriteValue_ResponseParamsDataView() = default;

  WebBluetoothService_RemoteCharacteristicWriteValue_ResponseParamsDataView(
      internal::WebBluetoothService_RemoteCharacteristicWriteValue_ResponseParams_Data* data,
      mojo::Message* message)
      : data_(data) {}

  bool is_null() const { return !data_; }
  template <typename UserType>
  [[nodiscard]] bool ReadResult(UserType* output) const {
    auto data_value = data_->result;
    return mojo::internal::Deserialize<::blink::mojom::WebBluetoothResult>(
        data_value, output);
  }
  WebBluetoothResult result() const {
    return ::mojo::internal::ToKnownEnumValueHelper(
          static_cast<::blink::mojom::WebBluetoothResult>(data_->result));
  }
 private:
  internal::WebBluetoothService_RemoteCharacteristicWriteValue_ResponseParams_Data* data_ = nullptr;
};


class WebBluetoothService_RemoteCharacteristicStartNotifications_ParamsDataView {
 public:
  WebBluetoothService_RemoteCharacteristicStartNotifications_ParamsDataView() = default;

  WebBluetoothService_RemoteCharacteristicStartNotifications_ParamsDataView(
      internal::WebBluetoothService_RemoteCharacteristicStartNotifications_Params_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  inline void GetCharacteristicInstanceIdDataView(
      mojo::StringDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadCharacteristicInstanceId(UserType* output) {
    
    auto* pointer = data_->characteristic_instance_id.Get();
    return mojo::internal::Deserialize<mojo::StringDataView>(
        pointer, output, message_);
  }
  template <typename UserType>
  UserType TakeClient() {
    UserType result;
    bool ret =
        mojo::internal::Deserialize<::blink::mojom::WebBluetoothCharacteristicClientAssociatedPtrInfoDataView>(
            &data_->client, &result, message_);
    DCHECK(ret);
    return result;
  }
 private:
  internal::WebBluetoothService_RemoteCharacteristicStartNotifications_Params_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class WebBluetoothService_RemoteCharacteristicStartNotifications_ResponseParamsDataView {
 public:
  WebBluetoothService_RemoteCharacteristicStartNotifications_ResponseParamsDataView() = default;

  WebBluetoothService_RemoteCharacteristicStartNotifications_ResponseParamsDataView(
      internal::WebBluetoothService_RemoteCharacteristicStartNotifications_ResponseParams_Data* data,
      mojo::Message* message)
      : data_(data) {}

  bool is_null() const { return !data_; }
  template <typename UserType>
  [[nodiscard]] bool ReadResult(UserType* output) const {
    auto data_value = data_->result;
    return mojo::internal::Deserialize<::blink::mojom::WebBluetoothResult>(
        data_value, output);
  }
  WebBluetoothResult result() const {
    return ::mojo::internal::ToKnownEnumValueHelper(
          static_cast<::blink::mojom::WebBluetoothResult>(data_->result));
  }
 private:
  internal::WebBluetoothService_RemoteCharacteristicStartNotifications_ResponseParams_Data* data_ = nullptr;
};


class WebBluetoothService_RemoteCharacteristicStopNotifications_ParamsDataView {
 public:
  WebBluetoothService_RemoteCharacteristicStopNotifications_ParamsDataView() = default;

  WebBluetoothService_RemoteCharacteristicStopNotifications_ParamsDataView(
      internal::WebBluetoothService_RemoteCharacteristicStopNotifications_Params_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  inline void GetCharacteristicInstanceIdDataView(
      mojo::StringDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadCharacteristicInstanceId(UserType* output) {
    
    auto* pointer = data_->characteristic_instance_id.Get();
    return mojo::internal::Deserialize<mojo::StringDataView>(
        pointer, output, message_);
  }
 private:
  internal::WebBluetoothService_RemoteCharacteristicStopNotifications_Params_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class WebBluetoothService_RemoteCharacteristicStopNotifications_ResponseParamsDataView {
 public:
  WebBluetoothService_RemoteCharacteristicStopNotifications_ResponseParamsDataView() = default;

  WebBluetoothService_RemoteCharacteristicStopNotifications_ResponseParamsDataView(
      internal::WebBluetoothService_RemoteCharacteristicStopNotifications_ResponseParams_Data* data,
      mojo::Message* message)
      : data_(data) {}

  bool is_null() const { return !data_; }
 private:
  internal::WebBluetoothService_RemoteCharacteristicStopNotifications_ResponseParams_Data* data_ = nullptr;
};


class WebBluetoothService_RemoteCharacteristicGetDescriptors_ParamsDataView {
 public:
  WebBluetoothService_RemoteCharacteristicGetDescriptors_ParamsDataView() = default;

  WebBluetoothService_RemoteCharacteristicGetDescriptors_ParamsDataView(
      internal::WebBluetoothService_RemoteCharacteristicGetDescriptors_Params_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  inline void GetCharacteristicsInstanceIdDataView(
      mojo::StringDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadCharacteristicsInstanceId(UserType* output) {
    
    auto* pointer = data_->characteristics_instance_id.Get();
    return mojo::internal::Deserialize<mojo::StringDataView>(
        pointer, output, message_);
  }
  template <typename UserType>
  [[nodiscard]] bool ReadQuantity(UserType* output) const {
    auto data_value = data_->quantity;
    return mojo::internal::Deserialize<::blink::mojom::WebBluetoothGATTQueryQuantity>(
        data_value, output);
  }
  WebBluetoothGATTQueryQuantity quantity() const {
    return ::mojo::internal::ToKnownEnumValueHelper(
          static_cast<::blink::mojom::WebBluetoothGATTQueryQuantity>(data_->quantity));
  }
  inline void GetDescriptorUuidDataView(
      ::bluetooth::mojom::UUIDDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadDescriptorUuid(UserType* output) {
    
static_assert(
    mojo::internal::IsValidUserTypeForOptionalValue<
        ::bluetooth::mojom::UUIDDataView, UserType>(),
    "Attempting to read the optional `descriptor_uuid` field into a type which "
    "cannot represent a null value. Either wrap the destination object "
    "with std::optional, ensure that any corresponding "
    "{Struct/Union/Array/String}Traits define the necessary IsNull and "
    "SetToNull methods, or use `MaybeReadDescriptorUuid` instead "
    "of `ReadDescriptorUuid if you're fine with null values being "
    "silently ignored in this case.");
    auto* pointer = data_->descriptor_uuid.Get();
    return mojo::internal::Deserialize<::bluetooth::mojom::UUIDDataView>(
        pointer, output, message_);
  }
 private:
  internal::WebBluetoothService_RemoteCharacteristicGetDescriptors_Params_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class WebBluetoothService_RemoteCharacteristicGetDescriptors_ResponseParamsDataView {
 public:
  WebBluetoothService_RemoteCharacteristicGetDescriptors_ResponseParamsDataView() = default;

  WebBluetoothService_RemoteCharacteristicGetDescriptors_ResponseParamsDataView(
      internal::WebBluetoothService_RemoteCharacteristicGetDescriptors_ResponseParams_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  template <typename UserType>
  [[nodiscard]] bool ReadResult(UserType* output) const {
    auto data_value = data_->result;
    return mojo::internal::Deserialize<::blink::mojom::WebBluetoothResult>(
        data_value, output);
  }
  WebBluetoothResult result() const {
    return ::mojo::internal::ToKnownEnumValueHelper(
          static_cast<::blink::mojom::WebBluetoothResult>(data_->result));
  }
  inline void GetDescriptorsDataView(
      mojo::ArrayDataView<WebBluetoothRemoteGATTDescriptorDataView>* output);

  template <typename UserType>
  [[nodiscard]] bool ReadDescriptors(UserType* output) {
    
static_assert(
    mojo::internal::IsValidUserTypeForOptionalValue<
        mojo::ArrayDataView<::blink::mojom::WebBluetoothRemoteGATTDescriptorDataView>, UserType>(),
    "Attempting to read the optional `descriptors` field into a type which "
    "cannot represent a null value. Either wrap the destination object "
    "with std::optional, ensure that any corresponding "
    "{Struct/Union/Array/String}Traits define the necessary IsNull and "
    "SetToNull methods, or use `MaybeReadDescriptors` instead "
    "of `ReadDescriptors if you're fine with null values being "
    "silently ignored in this case.");
    auto* pointer = data_->descriptors.Get();
    return mojo::internal::Deserialize<mojo::ArrayDataView<::blink::mojom::WebBluetoothRemoteGATTDescriptorDataView>>(
        pointer, output, message_);
  }
 private:
  internal::WebBluetoothService_RemoteCharacteristicGetDescriptors_ResponseParams_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class WebBluetoothService_RemoteDescriptorReadValue_ParamsDataView {
 public:
  WebBluetoothService_RemoteDescriptorReadValue_ParamsDataView() = default;

  WebBluetoothService_RemoteDescriptorReadValue_ParamsDataView(
      internal::WebBluetoothService_RemoteDescriptorReadValue_Params_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  inline void GetDescriptorInstanceIdDataView(
      mojo::StringDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadDescriptorInstanceId(UserType* output) {
    
    auto* pointer = data_->descriptor_instance_id.Get();
    return mojo::internal::Deserialize<mojo::StringDataView>(
        pointer, output, message_);
  }
 private:
  internal::WebBluetoothService_RemoteDescriptorReadValue_Params_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class WebBluetoothService_RemoteDescriptorReadValue_ResponseParamsDataView {
 public:
  WebBluetoothService_RemoteDescriptorReadValue_ResponseParamsDataView() = default;

  WebBluetoothService_RemoteDescriptorReadValue_ResponseParamsDataView(
      internal::WebBluetoothService_RemoteDescriptorReadValue_ResponseParams_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  template <typename UserType>
  [[nodiscard]] bool ReadResult(UserType* output) const {
    auto data_value = data_->result;
    return mojo::internal::Deserialize<::blink::mojom::WebBluetoothResult>(
        data_value, output);
  }
  WebBluetoothResult result() const {
    return ::mojo::internal::ToKnownEnumValueHelper(
          static_cast<::blink::mojom::WebBluetoothResult>(data_->result));
  }
  inline void GetValueDataView(
      ::mojo_base::mojom::ReadOnlyBufferDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadValue(UserType* output) {
    
    auto* pointer = data_->value.Get();
    return mojo::internal::Deserialize<::mojo_base::mojom::ReadOnlyBufferDataView>(
        pointer, output, message_);
  }
 private:
  internal::WebBluetoothService_RemoteDescriptorReadValue_ResponseParams_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class WebBluetoothService_RemoteDescriptorWriteValue_ParamsDataView {
 public:
  WebBluetoothService_RemoteDescriptorWriteValue_ParamsDataView() = default;

  WebBluetoothService_RemoteDescriptorWriteValue_ParamsDataView(
      internal::WebBluetoothService_RemoteDescriptorWriteValue_Params_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  inline void GetDescriptorInstanceIdDataView(
      mojo::StringDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadDescriptorInstanceId(UserType* output) {
    
    auto* pointer = data_->descriptor_instance_id.Get();
    return mojo::internal::Deserialize<mojo::StringDataView>(
        pointer, output, message_);
  }
  inline void GetValueDataView(
      ::mojo_base::mojom::ReadOnlyBufferDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadValue(UserType* output) {
    
    auto* pointer = data_->value.Get();
    return mojo::internal::Deserialize<::mojo_base::mojom::ReadOnlyBufferDataView>(
        pointer, output, message_);
  }
 private:
  internal::WebBluetoothService_RemoteDescriptorWriteValue_Params_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class WebBluetoothService_RemoteDescriptorWriteValue_ResponseParamsDataView {
 public:
  WebBluetoothService_RemoteDescriptorWriteValue_ResponseParamsDataView() = default;

  WebBluetoothService_RemoteDescriptorWriteValue_ResponseParamsDataView(
      internal::WebBluetoothService_RemoteDescriptorWriteValue_ResponseParams_Data* data,
      mojo::Message* message)
      : data_(data) {}

  bool is_null() const { return !data_; }
  template <typename UserType>
  [[nodiscard]] bool ReadResult(UserType* output) const {
    auto data_value = data_->result;
    return mojo::internal::Deserialize<::blink::mojom::WebBluetoothResult>(
        data_value, output);
  }
  WebBluetoothResult result() const {
    return ::mojo::internal::ToKnownEnumValueHelper(
          static_cast<::blink::mojom::WebBluetoothResult>(data_->result));
  }
 private:
  internal::WebBluetoothService_RemoteDescriptorWriteValue_ResponseParams_Data* data_ = nullptr;
};


class WebBluetoothService_RequestScanningStart_ParamsDataView {
 public:
  WebBluetoothService_RequestScanningStart_ParamsDataView() = default;

  WebBluetoothService_RequestScanningStart_ParamsDataView(
      internal::WebBluetoothService_RequestScanningStart_Params_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  template <typename UserType>
  UserType TakeClient() {
    UserType result;
    bool ret =
        mojo::internal::Deserialize<::blink::mojom::WebBluetoothAdvertisementClientAssociatedPtrInfoDataView>(
            &data_->client, &result, message_);
    DCHECK(ret);
    return result;
  }
  inline void GetOptionsDataView(
      WebBluetoothRequestLEScanOptionsDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadOptions(UserType* output) {
    
    auto* pointer = data_->options.Get();
    return mojo::internal::Deserialize<::blink::mojom::WebBluetoothRequestLEScanOptionsDataView>(
        pointer, output, message_);
  }
 private:
  internal::WebBluetoothService_RequestScanningStart_Params_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class WebBluetoothService_RequestScanningStart_ResponseParamsDataView {
 public:
  WebBluetoothService_RequestScanningStart_ResponseParamsDataView() = default;

  WebBluetoothService_RequestScanningStart_ResponseParamsDataView(
      internal::WebBluetoothService_RequestScanningStart_ResponseParams_Data* data,
      mojo::Message* message)
      : data_(data) {}

  bool is_null() const { return !data_; }
  template <typename UserType>
  [[nodiscard]] bool ReadResult(UserType* output) const {
    auto data_value = data_->result;
    return mojo::internal::Deserialize<::blink::mojom::WebBluetoothResult>(
        data_value, output);
  }
  WebBluetoothResult result() const {
    return ::mojo::internal::ToKnownEnumValueHelper(
          static_cast<::blink::mojom::WebBluetoothResult>(data_->result));
  }
 private:
  internal::WebBluetoothService_RequestScanningStart_ResponseParams_Data* data_ = nullptr;
};


class WebBluetoothService_WatchAdvertisementsForDevice_ParamsDataView {
 public:
  WebBluetoothService_WatchAdvertisementsForDevice_ParamsDataView() = default;

  WebBluetoothService_WatchAdvertisementsForDevice_ParamsDataView(
      internal::WebBluetoothService_WatchAdvertisementsForDevice_Params_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  inline void GetDeviceIdDataView(
      WebBluetoothDeviceIdDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadDeviceId(UserType* output) {
    
    auto* pointer = data_->device_id.Get();
    return mojo::internal::Deserialize<::blink::mojom::WebBluetoothDeviceIdDataView>(
        pointer, output, message_);
  }
  template <typename UserType>
  UserType TakeClient() {
    UserType result;
    bool ret =
        mojo::internal::Deserialize<::blink::mojom::WebBluetoothAdvertisementClientAssociatedPtrInfoDataView>(
            &data_->client, &result, message_);
    DCHECK(ret);
    return result;
  }
 private:
  internal::WebBluetoothService_WatchAdvertisementsForDevice_Params_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class WebBluetoothService_WatchAdvertisementsForDevice_ResponseParamsDataView {
 public:
  WebBluetoothService_WatchAdvertisementsForDevice_ResponseParamsDataView() = default;

  WebBluetoothService_WatchAdvertisementsForDevice_ResponseParamsDataView(
      internal::WebBluetoothService_WatchAdvertisementsForDevice_ResponseParams_Data* data,
      mojo::Message* message)
      : data_(data) {}

  bool is_null() const { return !data_; }
  template <typename UserType>
  [[nodiscard]] bool ReadResult(UserType* output) const {
    auto data_value = data_->result;
    return mojo::internal::Deserialize<::blink::mojom::WebBluetoothResult>(
        data_value, output);
  }
  WebBluetoothResult result() const {
    return ::mojo::internal::ToKnownEnumValueHelper(
          static_cast<::blink::mojom::WebBluetoothResult>(data_->result));
  }
 private:
  internal::WebBluetoothService_WatchAdvertisementsForDevice_ResponseParams_Data* data_ = nullptr;
};


class WebBluetoothServerClient_GATTServerDisconnected_ParamsDataView {
 public:
  WebBluetoothServerClient_GATTServerDisconnected_ParamsDataView() = default;

  WebBluetoothServerClient_GATTServerDisconnected_ParamsDataView(
      internal::WebBluetoothServerClient_GATTServerDisconnected_Params_Data* data,
      mojo::Message* message)
      : data_(data) {}

  bool is_null() const { return !data_; }
 private:
  internal::WebBluetoothServerClient_GATTServerDisconnected_Params_Data* data_ = nullptr;
};


class WebBluetoothCharacteristicClient_RemoteCharacteristicValueChanged_ParamsDataView {
 public:
  WebBluetoothCharacteristicClient_RemoteCharacteristicValueChanged_ParamsDataView() = default;

  WebBluetoothCharacteristicClient_RemoteCharacteristicValueChanged_ParamsDataView(
      internal::WebBluetoothCharacteristicClient_RemoteCharacteristicValueChanged_Params_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  inline void GetValueDataView(
      ::mojo_base::mojom::ReadOnlyBufferDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadValue(UserType* output) {
    
    auto* pointer = data_->value.Get();
    return mojo::internal::Deserialize<::mojo_base::mojom::ReadOnlyBufferDataView>(
        pointer, output, message_);
  }
 private:
  internal::WebBluetoothCharacteristicClient_RemoteCharacteristicValueChanged_Params_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class WebBluetoothAdvertisementClient_AdvertisingEvent_ParamsDataView {
 public:
  WebBluetoothAdvertisementClient_AdvertisingEvent_ParamsDataView() = default;

  WebBluetoothAdvertisementClient_AdvertisingEvent_ParamsDataView(
      internal::WebBluetoothAdvertisementClient_AdvertisingEvent_Params_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  inline void GetResultDataView(
      WebBluetoothAdvertisingEventDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadResult(UserType* output) {
    
    auto* pointer = data_->result.Get();
    return mojo::internal::Deserialize<::blink::mojom::WebBluetoothAdvertisingEventDataView>(
        pointer, output, message_);
  }
 private:
  internal::WebBluetoothAdvertisementClient_AdvertisingEvent_Params_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};





inline void WebBluetoothService_RequestDevice_ParamsDataView::GetOptionsDataView(
    WebBluetoothRequestDeviceOptionsDataView* output) {
  auto pointer = data_->options.Get();
  *output = WebBluetoothRequestDeviceOptionsDataView(pointer, message_);
}


inline void WebBluetoothService_RequestDevice_ResponseParamsDataView::GetDeviceDataView(
    WebBluetoothDeviceDataView* output) {
  auto pointer = data_->device.Get();
  *output = WebBluetoothDeviceDataView(pointer, message_);
}




inline void WebBluetoothService_GetDevices_ResponseParamsDataView::GetDevicesDataView(
    mojo::ArrayDataView<WebBluetoothDeviceDataView>* output) {
  auto pointer = data_->devices.Get();
  *output = mojo::ArrayDataView<WebBluetoothDeviceDataView>(pointer, message_);
}


inline void WebBluetoothService_ForgetDevice_ParamsDataView::GetDeviceIdDataView(
    WebBluetoothDeviceIdDataView* output) {
  auto pointer = data_->device_id.Get();
  *output = WebBluetoothDeviceIdDataView(pointer, message_);
}




inline void WebBluetoothService_RemoteServerConnect_ParamsDataView::GetDeviceIdDataView(
    WebBluetoothDeviceIdDataView* output) {
  auto pointer = data_->device_id.Get();
  *output = WebBluetoothDeviceIdDataView(pointer, message_);
}




inline void WebBluetoothService_RemoteServerDisconnect_ParamsDataView::GetDeviceIdDataView(
    WebBluetoothDeviceIdDataView* output) {
  auto pointer = data_->device_id.Get();
  *output = WebBluetoothDeviceIdDataView(pointer, message_);
}


inline void WebBluetoothService_RemoteServerGetPrimaryServices_ParamsDataView::GetDeviceIdDataView(
    WebBluetoothDeviceIdDataView* output) {
  auto pointer = data_->device_id.Get();
  *output = WebBluetoothDeviceIdDataView(pointer, message_);
}
inline void WebBluetoothService_RemoteServerGetPrimaryServices_ParamsDataView::GetServicesUuidDataView(
    ::bluetooth::mojom::UUIDDataView* output) {
  auto pointer = data_->services_uuid.Get();
  *output = ::bluetooth::mojom::UUIDDataView(pointer, message_);
}


inline void WebBluetoothService_RemoteServerGetPrimaryServices_ResponseParamsDataView::GetServicesDataView(
    mojo::ArrayDataView<WebBluetoothRemoteGATTServiceDataView>* output) {
  auto pointer = data_->services.Get();
  *output = mojo::ArrayDataView<WebBluetoothRemoteGATTServiceDataView>(pointer, message_);
}


inline void WebBluetoothService_RemoteServiceGetCharacteristics_ParamsDataView::GetServiceInstanceIdDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->service_instance_id.Get();
  *output = mojo::StringDataView(pointer, message_);
}
inline void WebBluetoothService_RemoteServiceGetCharacteristics_ParamsDataView::GetCharacteristicsUuidDataView(
    ::bluetooth::mojom::UUIDDataView* output) {
  auto pointer = data_->characteristics_uuid.Get();
  *output = ::bluetooth::mojom::UUIDDataView(pointer, message_);
}


inline void WebBluetoothService_RemoteServiceGetCharacteristics_ResponseParamsDataView::GetCharacteristicsDataView(
    mojo::ArrayDataView<WebBluetoothRemoteGATTCharacteristicDataView>* output) {
  auto pointer = data_->characteristics.Get();
  *output = mojo::ArrayDataView<WebBluetoothRemoteGATTCharacteristicDataView>(pointer, message_);
}


inline void WebBluetoothService_RemoteCharacteristicReadValue_ParamsDataView::GetCharacteristicInstanceIdDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->characteristic_instance_id.Get();
  *output = mojo::StringDataView(pointer, message_);
}


inline void WebBluetoothService_RemoteCharacteristicReadValue_ResponseParamsDataView::GetValueDataView(
    ::mojo_base::mojom::ReadOnlyBufferDataView* output) {
  auto pointer = data_->value.Get();
  *output = ::mojo_base::mojom::ReadOnlyBufferDataView(pointer, message_);
}


inline void WebBluetoothService_RemoteCharacteristicWriteValue_ParamsDataView::GetCharacteristicInstanceIdDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->characteristic_instance_id.Get();
  *output = mojo::StringDataView(pointer, message_);
}
inline void WebBluetoothService_RemoteCharacteristicWriteValue_ParamsDataView::GetValueDataView(
    ::mojo_base::mojom::ReadOnlyBufferDataView* output) {
  auto pointer = data_->value.Get();
  *output = ::mojo_base::mojom::ReadOnlyBufferDataView(pointer, message_);
}




inline void WebBluetoothService_RemoteCharacteristicStartNotifications_ParamsDataView::GetCharacteristicInstanceIdDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->characteristic_instance_id.Get();
  *output = mojo::StringDataView(pointer, message_);
}




inline void WebBluetoothService_RemoteCharacteristicStopNotifications_ParamsDataView::GetCharacteristicInstanceIdDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->characteristic_instance_id.Get();
  *output = mojo::StringDataView(pointer, message_);
}




inline void WebBluetoothService_RemoteCharacteristicGetDescriptors_ParamsDataView::GetCharacteristicsInstanceIdDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->characteristics_instance_id.Get();
  *output = mojo::StringDataView(pointer, message_);
}
inline void WebBluetoothService_RemoteCharacteristicGetDescriptors_ParamsDataView::GetDescriptorUuidDataView(
    ::bluetooth::mojom::UUIDDataView* output) {
  auto pointer = data_->descriptor_uuid.Get();
  *output = ::bluetooth::mojom::UUIDDataView(pointer, message_);
}


inline void WebBluetoothService_RemoteCharacteristicGetDescriptors_ResponseParamsDataView::GetDescriptorsDataView(
    mojo::ArrayDataView<WebBluetoothRemoteGATTDescriptorDataView>* output) {
  auto pointer = data_->descriptors.Get();
  *output = mojo::ArrayDataView<WebBluetoothRemoteGATTDescriptorDataView>(pointer, message_);
}


inline void WebBluetoothService_RemoteDescriptorReadValue_ParamsDataView::GetDescriptorInstanceIdDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->descriptor_instance_id.Get();
  *output = mojo::StringDataView(pointer, message_);
}


inline void WebBluetoothService_RemoteDescriptorReadValue_ResponseParamsDataView::GetValueDataView(
    ::mojo_base::mojom::ReadOnlyBufferDataView* output) {
  auto pointer = data_->value.Get();
  *output = ::mojo_base::mojom::ReadOnlyBufferDataView(pointer, message_);
}


inline void WebBluetoothService_RemoteDescriptorWriteValue_ParamsDataView::GetDescriptorInstanceIdDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->descriptor_instance_id.Get();
  *output = mojo::StringDataView(pointer, message_);
}
inline void WebBluetoothService_RemoteDescriptorWriteValue_ParamsDataView::GetValueDataView(
    ::mojo_base::mojom::ReadOnlyBufferDataView* output) {
  auto pointer = data_->value.Get();
  *output = ::mojo_base::mojom::ReadOnlyBufferDataView(pointer, message_);
}




inline void WebBluetoothService_RequestScanningStart_ParamsDataView::GetOptionsDataView(
    WebBluetoothRequestLEScanOptionsDataView* output) {
  auto pointer = data_->options.Get();
  *output = WebBluetoothRequestLEScanOptionsDataView(pointer, message_);
}




inline void WebBluetoothService_WatchAdvertisementsForDevice_ParamsDataView::GetDeviceIdDataView(
    WebBluetoothDeviceIdDataView* output) {
  auto pointer = data_->device_id.Get();
  *output = WebBluetoothDeviceIdDataView(pointer, message_);
}






inline void WebBluetoothCharacteristicClient_RemoteCharacteristicValueChanged_ParamsDataView::GetValueDataView(
    ::mojo_base::mojom::ReadOnlyBufferDataView* output) {
  auto pointer = data_->value.Get();
  *output = ::mojo_base::mojom::ReadOnlyBufferDataView(pointer, message_);
}


inline void WebBluetoothAdvertisementClient_AdvertisingEvent_ParamsDataView::GetResultDataView(
    WebBluetoothAdvertisingEventDataView* output) {
  auto pointer = data_->result.Get();
  *output = WebBluetoothAdvertisingEventDataView(pointer, message_);
}



}  // blink::mojom

#if defined(__clang__)
#pragma clang diagnostic pop
#endif

#endif  // THIRD_PARTY_BLINK_PUBLIC_MOJOM_BLUETOOTH_WEB_BLUETOOTH_MOJOM_PARAMS_DATA_H_