// components/unexportable_keys/mojom/unexportable_key_service.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 COMPONENTS_UNEXPORTABLE_KEYS_MOJOM_UNEXPORTABLE_KEY_SERVICE_MOJOM_PARAMS_DATA_H_
#define COMPONENTS_UNEXPORTABLE_KEYS_MOJOM_UNEXPORTABLE_KEY_SERVICE_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 unexportable_keys::mojom {
namespace internal {
class  UnexportableKeyService_GenerateSigningKey_Params_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::Array_Data<int32_t>> acceptable_algorithms;
  int32_t priority;
  uint8_t padfinal_[4];

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

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

  mojo::internal::StructHeader header_;
  internal::UnexportableKeyService_GenerateSigningKey_ResponseParam_Result_Data result;

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

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::Array_Data<uint8_t>> wrapped_key;
  int32_t priority;
  uint8_t padfinal_[4];

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

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

  mojo::internal::StructHeader header_;
  internal::UnexportableKeyService_FromWrappedSigningKey_ResponseParam_Result_Data result;

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

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::Array_Data<int32_t>> acceptable_algorithms;
  int32_t priority;
  uint8_t padfinal_[4];

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

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

  mojo::internal::StructHeader header_;
  internal::UnexportableKeyService_GenerateAttestationKey_ResponseParam_Result_Data result;

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

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::Array_Data<uint8_t>> wrapped_key;
  int32_t priority;
  uint8_t padfinal_[4];

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

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

  mojo::internal::StructHeader header_;
  internal::UnexportableKeyService_FromWrappedAttestationKey_ResponseParam_Result_Data result;

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

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<internal::UnexportableSigningKeyId_Data> key_id;
  mojo::internal::Pointer<mojo::internal::Array_Data<uint8_t>> data;
  int32_t priority;
  uint8_t padfinal_[4];

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

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

  mojo::internal::StructHeader header_;
  internal::UnexportableKeyService_Sign_ResponseParam_Result_Data result;

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

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<internal::UnexportableAttestationKeyId_Data> attestation_key_id;
  mojo::internal::Pointer<internal::UnexportableSigningKeyId_Data> signing_key_id;
  mojo::internal::Pointer<mojo::internal::Array_Data<uint8_t>> challenge;
  int32_t priority;
  uint8_t padfinal_[4];

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

  UnexportableKeyService_Certify_Params_Data();
  ~UnexportableKeyService_Certify_Params_Data() = delete;
};
static_assert(sizeof(UnexportableKeyService_Certify_Params_Data) == 40,
              "Bad sizeof(UnexportableKeyService_Certify_Params_Data)");
class  UnexportableKeyService_Certify_ResponseParams_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  internal::UnexportableKeyService_Certify_ResponseParam_Result_Data result;

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

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

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

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

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

  mojo::internal::StructHeader header_;
  internal::UnexportableKeyService_GetAllKeysForGarbageCollection_ResponseParam_Result_Data result;

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

  UnexportableKeyService_GetAllKeysForGarbageCollection_ResponseParams_Data();
  ~UnexportableKeyService_GetAllKeysForGarbageCollection_ResponseParams_Data() = delete;
};
static_assert(sizeof(UnexportableKeyService_GetAllKeysForGarbageCollection_ResponseParams_Data) == 24,
              "Bad sizeof(UnexportableKeyService_GetAllKeysForGarbageCollection_ResponseParams_Data)");
class  UnexportableKeyService_DeleteKeys_Params_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::UnexportableSigningKeyId_Data>>> key_ids;
  int32_t priority;
  uint8_t padfinal_[4];

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

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

  mojo::internal::StructHeader header_;
  internal::UnexportableKeyService_DeleteKeys_ResponseParam_Result_Data result;

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

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

  mojo::internal::StructHeader header_;

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

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

  mojo::internal::StructHeader header_;
  internal::UnexportableKeyService_DeleteAllKeys_ResponseParam_Result_Data result;

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

  UnexportableKeyService_DeleteAllKeys_ResponseParams_Data();
  ~UnexportableKeyService_DeleteAllKeys_ResponseParams_Data() = delete;
};
static_assert(sizeof(UnexportableKeyService_DeleteAllKeys_ResponseParams_Data) == 24,
              "Bad sizeof(UnexportableKeyService_DeleteAllKeys_ResponseParams_Data)");

}  // namespace internal


class UnexportableKeyService_GenerateSigningKey_ParamsDataView {
 public:
  UnexportableKeyService_GenerateSigningKey_ParamsDataView() = default;

  UnexportableKeyService_GenerateSigningKey_ParamsDataView(
      internal::UnexportableKeyService_GenerateSigningKey_Params_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

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

  template <typename UserType>
  [[nodiscard]] bool ReadAcceptableAlgorithms(UserType* output) {
    
    auto* pointer = data_->acceptable_algorithms.Get();
    return mojo::internal::Deserialize<mojo::ArrayDataView<::unexportable_keys::mojom::SignatureAlgorithm>>(
        pointer, output, message_);
  }
  template <typename UserType>
  [[nodiscard]] bool ReadPriority(UserType* output) const {
    auto data_value = data_->priority;
    return mojo::internal::Deserialize<::unexportable_keys::mojom::BackgroundTaskPriority>(
        data_value, output);
  }
  BackgroundTaskPriority priority() const {
    return ::mojo::internal::ToKnownEnumValueHelper(
          static_cast<::unexportable_keys::mojom::BackgroundTaskPriority>(data_->priority));
  }
 private:
  internal::UnexportableKeyService_GenerateSigningKey_Params_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class UnexportableKeyService_GenerateSigningKey_ResponseParamsDataView {
 public:
  UnexportableKeyService_GenerateSigningKey_ResponseParamsDataView() = default;

  UnexportableKeyService_GenerateSigningKey_ResponseParamsDataView(
      internal::UnexportableKeyService_GenerateSigningKey_ResponseParams_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

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

  template <typename UserType>
  [[nodiscard]] bool ReadResult(UserType* output) {
    
    auto* pointer = !data_->result.is_null() ? &data_->result : nullptr;
    return mojo::internal::Deserialize<::unexportable_keys::mojom::UnexportableKeyService_GenerateSigningKey_ResponseParam_ResultDataView>(
        pointer, output, message_);
  }
 private:
  internal::UnexportableKeyService_GenerateSigningKey_ResponseParams_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class UnexportableKeyService_FromWrappedSigningKey_ParamsDataView {
 public:
  UnexportableKeyService_FromWrappedSigningKey_ParamsDataView() = default;

  UnexportableKeyService_FromWrappedSigningKey_ParamsDataView(
      internal::UnexportableKeyService_FromWrappedSigningKey_Params_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

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

  template <typename UserType>
  [[nodiscard]] bool ReadWrappedKey(UserType* output) {
    
    auto* pointer = data_->wrapped_key.Get();
    return mojo::internal::Deserialize<mojo::ArrayDataView<uint8_t>>(
        pointer, output, message_);
  }
  template <typename UserType>
  [[nodiscard]] bool ReadPriority(UserType* output) const {
    auto data_value = data_->priority;
    return mojo::internal::Deserialize<::unexportable_keys::mojom::BackgroundTaskPriority>(
        data_value, output);
  }
  BackgroundTaskPriority priority() const {
    return ::mojo::internal::ToKnownEnumValueHelper(
          static_cast<::unexportable_keys::mojom::BackgroundTaskPriority>(data_->priority));
  }
 private:
  internal::UnexportableKeyService_FromWrappedSigningKey_Params_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class UnexportableKeyService_FromWrappedSigningKey_ResponseParamsDataView {
 public:
  UnexportableKeyService_FromWrappedSigningKey_ResponseParamsDataView() = default;

  UnexportableKeyService_FromWrappedSigningKey_ResponseParamsDataView(
      internal::UnexportableKeyService_FromWrappedSigningKey_ResponseParams_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

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

  template <typename UserType>
  [[nodiscard]] bool ReadResult(UserType* output) {
    
    auto* pointer = !data_->result.is_null() ? &data_->result : nullptr;
    return mojo::internal::Deserialize<::unexportable_keys::mojom::UnexportableKeyService_FromWrappedSigningKey_ResponseParam_ResultDataView>(
        pointer, output, message_);
  }
 private:
  internal::UnexportableKeyService_FromWrappedSigningKey_ResponseParams_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class UnexportableKeyService_GenerateAttestationKey_ParamsDataView {
 public:
  UnexportableKeyService_GenerateAttestationKey_ParamsDataView() = default;

  UnexportableKeyService_GenerateAttestationKey_ParamsDataView(
      internal::UnexportableKeyService_GenerateAttestationKey_Params_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

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

  template <typename UserType>
  [[nodiscard]] bool ReadAcceptableAlgorithms(UserType* output) {
    
    auto* pointer = data_->acceptable_algorithms.Get();
    return mojo::internal::Deserialize<mojo::ArrayDataView<::unexportable_keys::mojom::SignatureAlgorithm>>(
        pointer, output, message_);
  }
  template <typename UserType>
  [[nodiscard]] bool ReadPriority(UserType* output) const {
    auto data_value = data_->priority;
    return mojo::internal::Deserialize<::unexportable_keys::mojom::BackgroundTaskPriority>(
        data_value, output);
  }
  BackgroundTaskPriority priority() const {
    return ::mojo::internal::ToKnownEnumValueHelper(
          static_cast<::unexportable_keys::mojom::BackgroundTaskPriority>(data_->priority));
  }
 private:
  internal::UnexportableKeyService_GenerateAttestationKey_Params_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class UnexportableKeyService_GenerateAttestationKey_ResponseParamsDataView {
 public:
  UnexportableKeyService_GenerateAttestationKey_ResponseParamsDataView() = default;

  UnexportableKeyService_GenerateAttestationKey_ResponseParamsDataView(
      internal::UnexportableKeyService_GenerateAttestationKey_ResponseParams_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

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

  template <typename UserType>
  [[nodiscard]] bool ReadResult(UserType* output) {
    
    auto* pointer = !data_->result.is_null() ? &data_->result : nullptr;
    return mojo::internal::Deserialize<::unexportable_keys::mojom::UnexportableKeyService_GenerateAttestationKey_ResponseParam_ResultDataView>(
        pointer, output, message_);
  }
 private:
  internal::UnexportableKeyService_GenerateAttestationKey_ResponseParams_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class UnexportableKeyService_FromWrappedAttestationKey_ParamsDataView {
 public:
  UnexportableKeyService_FromWrappedAttestationKey_ParamsDataView() = default;

  UnexportableKeyService_FromWrappedAttestationKey_ParamsDataView(
      internal::UnexportableKeyService_FromWrappedAttestationKey_Params_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

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

  template <typename UserType>
  [[nodiscard]] bool ReadWrappedKey(UserType* output) {
    
    auto* pointer = data_->wrapped_key.Get();
    return mojo::internal::Deserialize<mojo::ArrayDataView<uint8_t>>(
        pointer, output, message_);
  }
  template <typename UserType>
  [[nodiscard]] bool ReadPriority(UserType* output) const {
    auto data_value = data_->priority;
    return mojo::internal::Deserialize<::unexportable_keys::mojom::BackgroundTaskPriority>(
        data_value, output);
  }
  BackgroundTaskPriority priority() const {
    return ::mojo::internal::ToKnownEnumValueHelper(
          static_cast<::unexportable_keys::mojom::BackgroundTaskPriority>(data_->priority));
  }
 private:
  internal::UnexportableKeyService_FromWrappedAttestationKey_Params_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class UnexportableKeyService_FromWrappedAttestationKey_ResponseParamsDataView {
 public:
  UnexportableKeyService_FromWrappedAttestationKey_ResponseParamsDataView() = default;

  UnexportableKeyService_FromWrappedAttestationKey_ResponseParamsDataView(
      internal::UnexportableKeyService_FromWrappedAttestationKey_ResponseParams_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

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

  template <typename UserType>
  [[nodiscard]] bool ReadResult(UserType* output) {
    
    auto* pointer = !data_->result.is_null() ? &data_->result : nullptr;
    return mojo::internal::Deserialize<::unexportable_keys::mojom::UnexportableKeyService_FromWrappedAttestationKey_ResponseParam_ResultDataView>(
        pointer, output, message_);
  }
 private:
  internal::UnexportableKeyService_FromWrappedAttestationKey_ResponseParams_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class UnexportableKeyService_Sign_ParamsDataView {
 public:
  UnexportableKeyService_Sign_ParamsDataView() = default;

  UnexportableKeyService_Sign_ParamsDataView(
      internal::UnexportableKeyService_Sign_Params_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  inline void GetKeyIdDataView(
      UnexportableSigningKeyIdDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadKeyId(UserType* output) {
    
    auto* pointer = data_->key_id.Get();
    return mojo::internal::Deserialize<::unexportable_keys::mojom::UnexportableSigningKeyIdDataView>(
        pointer, output, message_);
  }
  inline void GetDataDataView(
      mojo::ArrayDataView<uint8_t>* output);

  template <typename UserType>
  [[nodiscard]] bool ReadData(UserType* output) {
    
    auto* pointer = data_->data.Get();
    return mojo::internal::Deserialize<mojo::ArrayDataView<uint8_t>>(
        pointer, output, message_);
  }
  template <typename UserType>
  [[nodiscard]] bool ReadPriority(UserType* output) const {
    auto data_value = data_->priority;
    return mojo::internal::Deserialize<::unexportable_keys::mojom::BackgroundTaskPriority>(
        data_value, output);
  }
  BackgroundTaskPriority priority() const {
    return ::mojo::internal::ToKnownEnumValueHelper(
          static_cast<::unexportable_keys::mojom::BackgroundTaskPriority>(data_->priority));
  }
 private:
  internal::UnexportableKeyService_Sign_Params_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class UnexportableKeyService_Sign_ResponseParamsDataView {
 public:
  UnexportableKeyService_Sign_ResponseParamsDataView() = default;

  UnexportableKeyService_Sign_ResponseParamsDataView(
      internal::UnexportableKeyService_Sign_ResponseParams_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

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

  template <typename UserType>
  [[nodiscard]] bool ReadResult(UserType* output) {
    
    auto* pointer = !data_->result.is_null() ? &data_->result : nullptr;
    return mojo::internal::Deserialize<::unexportable_keys::mojom::UnexportableKeyService_Sign_ResponseParam_ResultDataView>(
        pointer, output, message_);
  }
 private:
  internal::UnexportableKeyService_Sign_ResponseParams_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class UnexportableKeyService_Certify_ParamsDataView {
 public:
  UnexportableKeyService_Certify_ParamsDataView() = default;

  UnexportableKeyService_Certify_ParamsDataView(
      internal::UnexportableKeyService_Certify_Params_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  inline void GetAttestationKeyIdDataView(
      UnexportableAttestationKeyIdDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadAttestationKeyId(UserType* output) {
    
    auto* pointer = data_->attestation_key_id.Get();
    return mojo::internal::Deserialize<::unexportable_keys::mojom::UnexportableAttestationKeyIdDataView>(
        pointer, output, message_);
  }
  inline void GetSigningKeyIdDataView(
      UnexportableSigningKeyIdDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadSigningKeyId(UserType* output) {
    
    auto* pointer = data_->signing_key_id.Get();
    return mojo::internal::Deserialize<::unexportable_keys::mojom::UnexportableSigningKeyIdDataView>(
        pointer, output, message_);
  }
  inline void GetChallengeDataView(
      mojo::ArrayDataView<uint8_t>* output);

  template <typename UserType>
  [[nodiscard]] bool ReadChallenge(UserType* output) {
    
    auto* pointer = data_->challenge.Get();
    return mojo::internal::Deserialize<mojo::ArrayDataView<uint8_t>>(
        pointer, output, message_);
  }
  template <typename UserType>
  [[nodiscard]] bool ReadPriority(UserType* output) const {
    auto data_value = data_->priority;
    return mojo::internal::Deserialize<::unexportable_keys::mojom::BackgroundTaskPriority>(
        data_value, output);
  }
  BackgroundTaskPriority priority() const {
    return ::mojo::internal::ToKnownEnumValueHelper(
          static_cast<::unexportable_keys::mojom::BackgroundTaskPriority>(data_->priority));
  }
 private:
  internal::UnexportableKeyService_Certify_Params_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class UnexportableKeyService_Certify_ResponseParamsDataView {
 public:
  UnexportableKeyService_Certify_ResponseParamsDataView() = default;

  UnexportableKeyService_Certify_ResponseParamsDataView(
      internal::UnexportableKeyService_Certify_ResponseParams_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

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

  template <typename UserType>
  [[nodiscard]] bool ReadResult(UserType* output) {
    
    auto* pointer = !data_->result.is_null() ? &data_->result : nullptr;
    return mojo::internal::Deserialize<::unexportable_keys::mojom::UnexportableKeyService_Certify_ResponseParam_ResultDataView>(
        pointer, output, message_);
  }
 private:
  internal::UnexportableKeyService_Certify_ResponseParams_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class UnexportableKeyService_GetAllKeysForGarbageCollection_ParamsDataView {
 public:
  UnexportableKeyService_GetAllKeysForGarbageCollection_ParamsDataView() = default;

  UnexportableKeyService_GetAllKeysForGarbageCollection_ParamsDataView(
      internal::UnexportableKeyService_GetAllKeysForGarbageCollection_Params_Data* data,
      mojo::Message* message)
      : data_(data) {}

  bool is_null() const { return !data_; }
  template <typename UserType>
  [[nodiscard]] bool ReadPriority(UserType* output) const {
    auto data_value = data_->priority;
    return mojo::internal::Deserialize<::unexportable_keys::mojom::BackgroundTaskPriority>(
        data_value, output);
  }
  BackgroundTaskPriority priority() const {
    return ::mojo::internal::ToKnownEnumValueHelper(
          static_cast<::unexportable_keys::mojom::BackgroundTaskPriority>(data_->priority));
  }
 private:
  internal::UnexportableKeyService_GetAllKeysForGarbageCollection_Params_Data* data_ = nullptr;
};


class UnexportableKeyService_GetAllKeysForGarbageCollection_ResponseParamsDataView {
 public:
  UnexportableKeyService_GetAllKeysForGarbageCollection_ResponseParamsDataView() = default;

  UnexportableKeyService_GetAllKeysForGarbageCollection_ResponseParamsDataView(
      internal::UnexportableKeyService_GetAllKeysForGarbageCollection_ResponseParams_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

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

  template <typename UserType>
  [[nodiscard]] bool ReadResult(UserType* output) {
    
    auto* pointer = !data_->result.is_null() ? &data_->result : nullptr;
    return mojo::internal::Deserialize<::unexportable_keys::mojom::UnexportableKeyService_GetAllKeysForGarbageCollection_ResponseParam_ResultDataView>(
        pointer, output, message_);
  }
 private:
  internal::UnexportableKeyService_GetAllKeysForGarbageCollection_ResponseParams_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class UnexportableKeyService_DeleteKeys_ParamsDataView {
 public:
  UnexportableKeyService_DeleteKeys_ParamsDataView() = default;

  UnexportableKeyService_DeleteKeys_ParamsDataView(
      internal::UnexportableKeyService_DeleteKeys_Params_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

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

  template <typename UserType>
  [[nodiscard]] bool ReadKeyIds(UserType* output) {
    
    auto* pointer = data_->key_ids.Get();
    return mojo::internal::Deserialize<mojo::ArrayDataView<::unexportable_keys::mojom::UnexportableSigningKeyIdDataView>>(
        pointer, output, message_);
  }
  template <typename UserType>
  [[nodiscard]] bool ReadPriority(UserType* output) const {
    auto data_value = data_->priority;
    return mojo::internal::Deserialize<::unexportable_keys::mojom::BackgroundTaskPriority>(
        data_value, output);
  }
  BackgroundTaskPriority priority() const {
    return ::mojo::internal::ToKnownEnumValueHelper(
          static_cast<::unexportable_keys::mojom::BackgroundTaskPriority>(data_->priority));
  }
 private:
  internal::UnexportableKeyService_DeleteKeys_Params_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class UnexportableKeyService_DeleteKeys_ResponseParamsDataView {
 public:
  UnexportableKeyService_DeleteKeys_ResponseParamsDataView() = default;

  UnexportableKeyService_DeleteKeys_ResponseParamsDataView(
      internal::UnexportableKeyService_DeleteKeys_ResponseParams_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

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

  template <typename UserType>
  [[nodiscard]] bool ReadResult(UserType* output) {
    
    auto* pointer = !data_->result.is_null() ? &data_->result : nullptr;
    return mojo::internal::Deserialize<::unexportable_keys::mojom::UnexportableKeyService_DeleteKeys_ResponseParam_ResultDataView>(
        pointer, output, message_);
  }
 private:
  internal::UnexportableKeyService_DeleteKeys_ResponseParams_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class UnexportableKeyService_DeleteAllKeys_ParamsDataView {
 public:
  UnexportableKeyService_DeleteAllKeys_ParamsDataView() = default;

  UnexportableKeyService_DeleteAllKeys_ParamsDataView(
      internal::UnexportableKeyService_DeleteAllKeys_Params_Data* data,
      mojo::Message* message)
      : data_(data) {}

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


class UnexportableKeyService_DeleteAllKeys_ResponseParamsDataView {
 public:
  UnexportableKeyService_DeleteAllKeys_ResponseParamsDataView() = default;

  UnexportableKeyService_DeleteAllKeys_ResponseParamsDataView(
      internal::UnexportableKeyService_DeleteAllKeys_ResponseParams_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

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

  template <typename UserType>
  [[nodiscard]] bool ReadResult(UserType* output) {
    
    auto* pointer = !data_->result.is_null() ? &data_->result : nullptr;
    return mojo::internal::Deserialize<::unexportable_keys::mojom::UnexportableKeyService_DeleteAllKeys_ResponseParam_ResultDataView>(
        pointer, output, message_);
  }
 private:
  internal::UnexportableKeyService_DeleteAllKeys_ResponseParams_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};

inline void UnexportableKeyService_GenerateSigningKey_ParamsDataView::GetAcceptableAlgorithmsDataView(
    mojo::ArrayDataView<SignatureAlgorithm>* output) {
  auto pointer = data_->acceptable_algorithms.Get();
  *output = mojo::ArrayDataView<SignatureAlgorithm>(pointer, message_);
}


inline void UnexportableKeyService_GenerateSigningKey_ResponseParamsDataView::GetResultDataView(
    UnexportableKeyService_GenerateSigningKey_ResponseParam_ResultDataView* output) {
  auto pointer = &data_->result;
  *output = UnexportableKeyService_GenerateSigningKey_ResponseParam_ResultDataView(pointer, message_);
}


inline void UnexportableKeyService_FromWrappedSigningKey_ParamsDataView::GetWrappedKeyDataView(
    mojo::ArrayDataView<uint8_t>* output) {
  auto pointer = data_->wrapped_key.Get();
  *output = mojo::ArrayDataView<uint8_t>(pointer, message_);
}


inline void UnexportableKeyService_FromWrappedSigningKey_ResponseParamsDataView::GetResultDataView(
    UnexportableKeyService_FromWrappedSigningKey_ResponseParam_ResultDataView* output) {
  auto pointer = &data_->result;
  *output = UnexportableKeyService_FromWrappedSigningKey_ResponseParam_ResultDataView(pointer, message_);
}


inline void UnexportableKeyService_GenerateAttestationKey_ParamsDataView::GetAcceptableAlgorithmsDataView(
    mojo::ArrayDataView<SignatureAlgorithm>* output) {
  auto pointer = data_->acceptable_algorithms.Get();
  *output = mojo::ArrayDataView<SignatureAlgorithm>(pointer, message_);
}


inline void UnexportableKeyService_GenerateAttestationKey_ResponseParamsDataView::GetResultDataView(
    UnexportableKeyService_GenerateAttestationKey_ResponseParam_ResultDataView* output) {
  auto pointer = &data_->result;
  *output = UnexportableKeyService_GenerateAttestationKey_ResponseParam_ResultDataView(pointer, message_);
}


inline void UnexportableKeyService_FromWrappedAttestationKey_ParamsDataView::GetWrappedKeyDataView(
    mojo::ArrayDataView<uint8_t>* output) {
  auto pointer = data_->wrapped_key.Get();
  *output = mojo::ArrayDataView<uint8_t>(pointer, message_);
}


inline void UnexportableKeyService_FromWrappedAttestationKey_ResponseParamsDataView::GetResultDataView(
    UnexportableKeyService_FromWrappedAttestationKey_ResponseParam_ResultDataView* output) {
  auto pointer = &data_->result;
  *output = UnexportableKeyService_FromWrappedAttestationKey_ResponseParam_ResultDataView(pointer, message_);
}


inline void UnexportableKeyService_Sign_ParamsDataView::GetKeyIdDataView(
    UnexportableSigningKeyIdDataView* output) {
  auto pointer = data_->key_id.Get();
  *output = UnexportableSigningKeyIdDataView(pointer, message_);
}
inline void UnexportableKeyService_Sign_ParamsDataView::GetDataDataView(
    mojo::ArrayDataView<uint8_t>* output) {
  auto pointer = data_->data.Get();
  *output = mojo::ArrayDataView<uint8_t>(pointer, message_);
}


inline void UnexportableKeyService_Sign_ResponseParamsDataView::GetResultDataView(
    UnexportableKeyService_Sign_ResponseParam_ResultDataView* output) {
  auto pointer = &data_->result;
  *output = UnexportableKeyService_Sign_ResponseParam_ResultDataView(pointer, message_);
}


inline void UnexportableKeyService_Certify_ParamsDataView::GetAttestationKeyIdDataView(
    UnexportableAttestationKeyIdDataView* output) {
  auto pointer = data_->attestation_key_id.Get();
  *output = UnexportableAttestationKeyIdDataView(pointer, message_);
}
inline void UnexportableKeyService_Certify_ParamsDataView::GetSigningKeyIdDataView(
    UnexportableSigningKeyIdDataView* output) {
  auto pointer = data_->signing_key_id.Get();
  *output = UnexportableSigningKeyIdDataView(pointer, message_);
}
inline void UnexportableKeyService_Certify_ParamsDataView::GetChallengeDataView(
    mojo::ArrayDataView<uint8_t>* output) {
  auto pointer = data_->challenge.Get();
  *output = mojo::ArrayDataView<uint8_t>(pointer, message_);
}


inline void UnexportableKeyService_Certify_ResponseParamsDataView::GetResultDataView(
    UnexportableKeyService_Certify_ResponseParam_ResultDataView* output) {
  auto pointer = &data_->result;
  *output = UnexportableKeyService_Certify_ResponseParam_ResultDataView(pointer, message_);
}




inline void UnexportableKeyService_GetAllKeysForGarbageCollection_ResponseParamsDataView::GetResultDataView(
    UnexportableKeyService_GetAllKeysForGarbageCollection_ResponseParam_ResultDataView* output) {
  auto pointer = &data_->result;
  *output = UnexportableKeyService_GetAllKeysForGarbageCollection_ResponseParam_ResultDataView(pointer, message_);
}


inline void UnexportableKeyService_DeleteKeys_ParamsDataView::GetKeyIdsDataView(
    mojo::ArrayDataView<UnexportableSigningKeyIdDataView>* output) {
  auto pointer = data_->key_ids.Get();
  *output = mojo::ArrayDataView<UnexportableSigningKeyIdDataView>(pointer, message_);
}


inline void UnexportableKeyService_DeleteKeys_ResponseParamsDataView::GetResultDataView(
    UnexportableKeyService_DeleteKeys_ResponseParam_ResultDataView* output) {
  auto pointer = &data_->result;
  *output = UnexportableKeyService_DeleteKeys_ResponseParam_ResultDataView(pointer, message_);
}




inline void UnexportableKeyService_DeleteAllKeys_ResponseParamsDataView::GetResultDataView(
    UnexportableKeyService_DeleteAllKeys_ResponseParam_ResultDataView* output) {
  auto pointer = &data_->result;
  *output = UnexportableKeyService_DeleteAllKeys_ResponseParam_ResultDataView(pointer, message_);
}



}  // unexportable_keys::mojom

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

#endif  // COMPONENTS_UNEXPORTABLE_KEYS_MOJOM_UNEXPORTABLE_KEY_SERVICE_MOJOM_PARAMS_DATA_H_