// components/unexportable_keys/mojom/unexportable_key_service.mojom-shared.h is auto generated by mojom_bindings_generator.py, do not edit

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

#ifndef COMPONENTS_UNEXPORTABLE_KEYS_MOJOM_UNEXPORTABLE_KEY_SERVICE_MOJOM_SHARED_H_
#define COMPONENTS_UNEXPORTABLE_KEYS_MOJOM_UNEXPORTABLE_KEY_SERVICE_MOJOM_SHARED_H_

#include <stdint.h>

#include <functional>
#include <iosfwd>
#include <type_traits>
#include <utility>
#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"
#include "mojo/public/cpp/system/message_pipe.h"

#include "third_party/perfetto/include/perfetto/tracing/traced_value_forward.h"

#include "components/unexportable_keys/mojom/unexportable_key_service.mojom-shared-internal.h"
#include "mojo/public/mojom/base/time.mojom-shared.h"
#include "mojo/public/mojom/base/unguessable_token.mojom-shared.h"
#include "mojo/public/cpp/bindings/lib/interface_serialization.h"
#include "mojo/public/cpp/system/data_pipe.h"



#include "components/unexportable_keys/mojom/unexportable_key_service.mojom-data-view.h"  // IWYU pragma: export




namespace std {

template <>
struct hash<::unexportable_keys::mojom::SignatureAlgorithm>
    : public mojo::internal::EnumHashImpl<::unexportable_keys::mojom::SignatureAlgorithm> {};

template <>
struct hash<::unexportable_keys::mojom::ServiceError>
    : public mojo::internal::EnumHashImpl<::unexportable_keys::mojom::ServiceError> {};

template <>
struct hash<::unexportable_keys::mojom::BackgroundTaskPriority>
    : public mojo::internal::EnumHashImpl<::unexportable_keys::mojom::BackgroundTaskPriority> {};

template <>
struct hash<::unexportable_keys::mojom::AttestationFormat>
    : public mojo::internal::EnumHashImpl<::unexportable_keys::mojom::AttestationFormat> {};

}  // namespace std

namespace mojo {


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::unexportable_keys::mojom::SignatureAlgorithm, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = EnumTraits<::unexportable_keys::mojom::SignatureAlgorithm, UserType>;

  static void Serialize(UserType input, int32_t* output) {
    *output = static_cast<int32_t>(Traits::ToMojom(input));
  }

  static bool Deserialize(int32_t input, UserType* output) {
    auto known_value = ::mojo::internal::ToKnownEnumValueHelper(
        static_cast<::unexportable_keys::mojom::SignatureAlgorithm>(input));
    if constexpr (requires {
                    {
                      Traits::FromMojom(known_value)
                    } -> std::same_as<UserType>;
                  }) {
      static_assert(std::same_as<::unexportable_keys::mojom::SignatureAlgorithm, UserType> ||
                        HasInfallibleConversion(::unexportable_keys::mojom::SignatureAlgorithm()),
                    "::unexportable_keys::mojom::SignatureAlgorithm does not have an infallible conversion, "
                    "use an optional return type.");
      *output = Traits::FromMojom(known_value);
      return true;
    } else {
      static_assert(
          requires {
            {
              Traits::FromMojom(known_value)
            } -> std::same_as<std::optional<UserType>>;
          }, "FromMojom must return by value or optional.");
      std::optional<UserType> from_mojom = Traits::FromMojom(known_value);
      if (from_mojom) {
        *output = *from_mojom;
      }
      return from_mojom.has_value();
    }
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::unexportable_keys::mojom::ServiceError, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = EnumTraits<::unexportable_keys::mojom::ServiceError, UserType>;

  static void Serialize(UserType input, int32_t* output) {
    *output = static_cast<int32_t>(Traits::ToMojom(input));
  }

  static bool Deserialize(int32_t input, UserType* output) {
    auto known_value = ::mojo::internal::ToKnownEnumValueHelper(
        static_cast<::unexportable_keys::mojom::ServiceError>(input));
    if constexpr (requires {
                    {
                      Traits::FromMojom(known_value)
                    } -> std::same_as<UserType>;
                  }) {
      static_assert(std::same_as<::unexportable_keys::mojom::ServiceError, UserType> ||
                        HasInfallibleConversion(::unexportable_keys::mojom::ServiceError()),
                    "::unexportable_keys::mojom::ServiceError does not have an infallible conversion, "
                    "use an optional return type.");
      *output = Traits::FromMojom(known_value);
      return true;
    } else {
      static_assert(
          requires {
            {
              Traits::FromMojom(known_value)
            } -> std::same_as<std::optional<UserType>>;
          }, "FromMojom must return by value or optional.");
      std::optional<UserType> from_mojom = Traits::FromMojom(known_value);
      if (from_mojom) {
        *output = *from_mojom;
      }
      return from_mojom.has_value();
    }
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::unexportable_keys::mojom::BackgroundTaskPriority, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = EnumTraits<::unexportable_keys::mojom::BackgroundTaskPriority, UserType>;

  static void Serialize(UserType input, int32_t* output) {
    *output = static_cast<int32_t>(Traits::ToMojom(input));
  }

  static bool Deserialize(int32_t input, UserType* output) {
    auto known_value = ::mojo::internal::ToKnownEnumValueHelper(
        static_cast<::unexportable_keys::mojom::BackgroundTaskPriority>(input));
    if constexpr (requires {
                    {
                      Traits::FromMojom(known_value)
                    } -> std::same_as<UserType>;
                  }) {
      static_assert(std::same_as<::unexportable_keys::mojom::BackgroundTaskPriority, UserType> ||
                        HasInfallibleConversion(::unexportable_keys::mojom::BackgroundTaskPriority()),
                    "::unexportable_keys::mojom::BackgroundTaskPriority does not have an infallible conversion, "
                    "use an optional return type.");
      *output = Traits::FromMojom(known_value);
      return true;
    } else {
      static_assert(
          requires {
            {
              Traits::FromMojom(known_value)
            } -> std::same_as<std::optional<UserType>>;
          }, "FromMojom must return by value or optional.");
      std::optional<UserType> from_mojom = Traits::FromMojom(known_value);
      if (from_mojom) {
        *output = *from_mojom;
      }
      return from_mojom.has_value();
    }
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::unexportable_keys::mojom::AttestationFormat, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = EnumTraits<::unexportable_keys::mojom::AttestationFormat, UserType>;

  static void Serialize(UserType input, int32_t* output) {
    *output = static_cast<int32_t>(Traits::ToMojom(input));
  }

  static bool Deserialize(int32_t input, UserType* output) {
    auto known_value = ::mojo::internal::ToKnownEnumValueHelper(
        static_cast<::unexportable_keys::mojom::AttestationFormat>(input));
    if constexpr (requires {
                    {
                      Traits::FromMojom(known_value)
                    } -> std::same_as<UserType>;
                  }) {
      static_assert(std::same_as<::unexportable_keys::mojom::AttestationFormat, UserType> ||
                        HasInfallibleConversion(::unexportable_keys::mojom::AttestationFormat()),
                    "::unexportable_keys::mojom::AttestationFormat does not have an infallible conversion, "
                    "use an optional return type.");
      *output = Traits::FromMojom(known_value);
      return true;
    } else {
      static_assert(
          requires {
            {
              Traits::FromMojom(known_value)
            } -> std::same_as<std::optional<UserType>>;
          }, "FromMojom must return by value or optional.");
      std::optional<UserType> from_mojom = Traits::FromMojom(known_value);
      if (from_mojom) {
        *output = *from_mojom;
      }
      return from_mojom.has_value();
    }
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::unexportable_keys::mojom::UnexportableSigningKeyIdDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::unexportable_keys::mojom::UnexportableSigningKeyIdDataView, UserType>;

  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::unexportable_keys::mojom::internal::UnexportableSigningKeyId_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

    decltype(Traits::key_id(input)) in_key_id = Traits::key_id(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->key_id)::BaseType> key_id_fragment(
            fragment.message());
    
    mojo::internal::Serialize<::mojo_base::mojom::UnguessableTokenDataView>(
      in_key_id,
      key_id_fragment);

    fragment->key_id.Set(
        key_id_fragment.is_null() ? nullptr : key_id_fragment.data());

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(fragment->key_id.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null key_id in UnexportableSigningKeyId struct");
  }

  static bool Deserialize(::unexportable_keys::mojom::internal::UnexportableSigningKeyId_Data* input,
                          UserType* output,
                          Message* message) {
    if (!input)
      return CallSetToNullIfExists<Traits>(output);

    ::unexportable_keys::mojom::UnexportableSigningKeyIdDataView data_view(input, message);
    return CallTraitsRead<Traits>(data_view, output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::unexportable_keys::mojom::UnexportableAttestationKeyIdDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::unexportable_keys::mojom::UnexportableAttestationKeyIdDataView, UserType>;

  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::unexportable_keys::mojom::internal::UnexportableAttestationKeyId_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

    decltype(Traits::key_id(input)) in_key_id = Traits::key_id(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->key_id)::BaseType> key_id_fragment(
            fragment.message());
    
    mojo::internal::Serialize<::mojo_base::mojom::UnguessableTokenDataView>(
      in_key_id,
      key_id_fragment);

    fragment->key_id.Set(
        key_id_fragment.is_null() ? nullptr : key_id_fragment.data());

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(fragment->key_id.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null key_id in UnexportableAttestationKeyId struct");
  }

  static bool Deserialize(::unexportable_keys::mojom::internal::UnexportableAttestationKeyId_Data* input,
                          UserType* output,
                          Message* message) {
    if (!input)
      return CallSetToNullIfExists<Traits>(output);

    ::unexportable_keys::mojom::UnexportableAttestationKeyIdDataView data_view(input, message);
    return CallTraitsRead<Traits>(data_view, output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::unexportable_keys::mojom::NewKeyMetadataDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::unexportable_keys::mojom::NewKeyMetadataDataView, UserType>;

  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::unexportable_keys::mojom::internal::NewKeyMetadata_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

    decltype(Traits::subject_public_key_info(input)) in_subject_public_key_info = Traits::subject_public_key_info(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->subject_public_key_info)::BaseType>
        subject_public_key_info_fragment(fragment.message());
    constexpr const mojo::internal::ContainerValidateParams& subject_public_key_info_validate_params =
        mojo::internal::GetArrayValidator<0, false, nullptr>();
    
    mojo::internal::Serialize<mojo::ArrayDataView<uint8_t>>(
      in_subject_public_key_info,
      subject_public_key_info_fragment,
      &subject_public_key_info_validate_params);

    fragment->subject_public_key_info.Set(
        subject_public_key_info_fragment.is_null() ? nullptr : subject_public_key_info_fragment.data());

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(fragment->subject_public_key_info.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null subject_public_key_info in NewKeyMetadata struct");

    decltype(Traits::wrapped_key(input)) in_wrapped_key = Traits::wrapped_key(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->wrapped_key)::BaseType>
        wrapped_key_fragment(fragment.message());
    constexpr const mojo::internal::ContainerValidateParams& wrapped_key_validate_params =
        mojo::internal::GetArrayValidator<0, false, nullptr>();
    
    mojo::internal::Serialize<mojo::ArrayDataView<uint8_t>>(
      in_wrapped_key,
      wrapped_key_fragment,
      &wrapped_key_validate_params);

    fragment->wrapped_key.Set(
        wrapped_key_fragment.is_null() ? nullptr : wrapped_key_fragment.data());

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(fragment->wrapped_key.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null wrapped_key in NewKeyMetadata struct");

    
    mojo::internal::Serialize<::unexportable_keys::mojom::SignatureAlgorithm>(
      Traits::algorithm(input),
      &fragment->algorithm);

    decltype(Traits::key_tag(input)) in_key_tag = Traits::key_tag(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->key_tag)::BaseType> key_tag_fragment(
            fragment.message());
    
    mojo::internal::Serialize<mojo::StringDataView>(
      in_key_tag,
      key_tag_fragment);

    fragment->key_tag.Set(
        key_tag_fragment.is_null() ? nullptr : key_tag_fragment.data());

    decltype(Traits::creation_time(input)) in_creation_time = Traits::creation_time(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->creation_time)::BaseType> creation_time_fragment(
            fragment.message());
    
    mojo::internal::Serialize<::mojo_base::mojom::TimeDataView>(
      in_creation_time,
      creation_time_fragment);

    fragment->creation_time.Set(
        creation_time_fragment.is_null() ? nullptr : creation_time_fragment.data());
  }

  static bool Deserialize(::unexportable_keys::mojom::internal::NewKeyMetadata_Data* input,
                          UserType* output,
                          Message* message) {
    if (!input)
      return CallSetToNullIfExists<Traits>(output);

    ::unexportable_keys::mojom::NewKeyMetadataDataView data_view(input, message);
    return CallTraitsRead<Traits>(data_view, output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::unexportable_keys::mojom::NewSigningKeyDataDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::unexportable_keys::mojom::NewSigningKeyDataDataView, UserType>;

  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::unexportable_keys::mojom::internal::NewSigningKeyData_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

    decltype(Traits::key_id(input)) in_key_id = Traits::key_id(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->key_id)::BaseType> key_id_fragment(
            fragment.message());
    
    mojo::internal::Serialize<::unexportable_keys::mojom::UnexportableSigningKeyIdDataView>(
      in_key_id,
      key_id_fragment);

    fragment->key_id.Set(
        key_id_fragment.is_null() ? nullptr : key_id_fragment.data());

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(fragment->key_id.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null key_id in NewSigningKeyData struct");

    decltype(Traits::metadata(input)) in_metadata = Traits::metadata(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->metadata)::BaseType> metadata_fragment(
            fragment.message());
    
    mojo::internal::Serialize<::unexportable_keys::mojom::NewKeyMetadataDataView>(
      in_metadata,
      metadata_fragment);

    fragment->metadata.Set(
        metadata_fragment.is_null() ? nullptr : metadata_fragment.data());

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(fragment->metadata.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null metadata in NewSigningKeyData struct");
  }

  static bool Deserialize(::unexportable_keys::mojom::internal::NewSigningKeyData_Data* input,
                          UserType* output,
                          Message* message) {
    if (!input)
      return CallSetToNullIfExists<Traits>(output);

    ::unexportable_keys::mojom::NewSigningKeyDataDataView data_view(input, message);
    return CallTraitsRead<Traits>(data_view, output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::unexportable_keys::mojom::NewAttestationKeyDataDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::unexportable_keys::mojom::NewAttestationKeyDataDataView, UserType>;

  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::unexportable_keys::mojom::internal::NewAttestationKeyData_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

    decltype(Traits::key_id(input)) in_key_id = Traits::key_id(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->key_id)::BaseType> key_id_fragment(
            fragment.message());
    
    mojo::internal::Serialize<::unexportable_keys::mojom::UnexportableAttestationKeyIdDataView>(
      in_key_id,
      key_id_fragment);

    fragment->key_id.Set(
        key_id_fragment.is_null() ? nullptr : key_id_fragment.data());

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(fragment->key_id.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null key_id in NewAttestationKeyData struct");

    decltype(Traits::metadata(input)) in_metadata = Traits::metadata(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->metadata)::BaseType> metadata_fragment(
            fragment.message());
    
    mojo::internal::Serialize<::unexportable_keys::mojom::NewKeyMetadataDataView>(
      in_metadata,
      metadata_fragment);

    fragment->metadata.Set(
        metadata_fragment.is_null() ? nullptr : metadata_fragment.data());

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(fragment->metadata.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null metadata in NewAttestationKeyData struct");
  }

  static bool Deserialize(::unexportable_keys::mojom::internal::NewAttestationKeyData_Data* input,
                          UserType* output,
                          Message* message) {
    if (!input)
      return CallSetToNullIfExists<Traits>(output);

    ::unexportable_keys::mojom::NewAttestationKeyDataDataView data_view(input, message);
    return CallTraitsRead<Traits>(data_view, output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::unexportable_keys::mojom::AttestationStatementDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::unexportable_keys::mojom::AttestationStatementDataView, UserType>;

  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::unexportable_keys::mojom::internal::AttestationStatement_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

    
    mojo::internal::Serialize<::unexportable_keys::mojom::AttestationFormat>(
      Traits::format(input),
      &fragment->format);

    decltype(Traits::statement(input)) in_statement = Traits::statement(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->statement)::BaseType>
        statement_fragment(fragment.message());
    constexpr const mojo::internal::ContainerValidateParams& statement_validate_params =
        mojo::internal::GetArrayValidator<0, false, nullptr>();
    
    mojo::internal::Serialize<mojo::ArrayDataView<uint8_t>>(
      in_statement,
      statement_fragment,
      &statement_validate_params);

    fragment->statement.Set(
        statement_fragment.is_null() ? nullptr : statement_fragment.data());

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(fragment->statement.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null statement in AttestationStatement struct");

    decltype(Traits::signature(input)) in_signature = Traits::signature(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->signature)::BaseType>
        signature_fragment(fragment.message());
    constexpr const mojo::internal::ContainerValidateParams& signature_validate_params =
        mojo::internal::GetArrayValidator<0, false, nullptr>();
    
    mojo::internal::Serialize<mojo::ArrayDataView<uint8_t>>(
      in_signature,
      signature_fragment,
      &signature_validate_params);

    fragment->signature.Set(
        signature_fragment.is_null() ? nullptr : signature_fragment.data());

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(fragment->signature.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null signature in AttestationStatement struct");
  }

  static bool Deserialize(::unexportable_keys::mojom::internal::AttestationStatement_Data* input,
                          UserType* output,
                          Message* message) {
    if (!input)
      return CallSetToNullIfExists<Traits>(output);

    ::unexportable_keys::mojom::AttestationStatementDataView data_view(input, message);
    return CallTraitsRead<Traits>(data_view, output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::unexportable_keys::mojom::UnexportableKeyService_GenerateSigningKey_ResponseParam_ResultDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = UnionTraits<::unexportable_keys::mojom::UnexportableKeyService_GenerateSigningKey_ResponseParam_ResultDataView, UserType>;

  static void Serialize(MaybeConstUserType& input,
                        MessageFragment<::unexportable_keys::mojom::internal::UnexportableKeyService_GenerateSigningKey_ResponseParam_Result_Data>& fragment,
                        bool inlined) {
    
    if (CallIsNullIfExists<Traits>(input)) {
       if (inlined)
        fragment->set_null();
      return;
    }

if (!inlined)
  fragment.Allocate();

    // TODO(azani): Handle unknown and objects.
    // Set the not-null flag.
fragment->size = kUnionDataSize;
fragment->tag = Traits::GetTag(input);
switch (fragment->tag) {
  case ::unexportable_keys::mojom::UnexportableKeyService_GenerateSigningKey_ResponseParam_ResultDataView::Tag::kSuccess: {
    decltype(Traits::success(input))
    in_success = Traits::success(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_success)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<::unexportable_keys::mojom::NewSigningKeyDataDataView>(
  in_success,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  mojo::internal::SendValidation::kDefault,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null success in UnexportableKeyService_GenerateSigningKey_ResponseParam_Result union");
    fragment->data.f_success.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
  case ::unexportable_keys::mojom::UnexportableKeyService_GenerateSigningKey_ResponseParam_ResultDataView::Tag::kFailure: {
    decltype(Traits::failure(input))
    in_failure = Traits::failure(input);
        
mojo::internal::Serialize<::unexportable_keys::mojom::ServiceError>(
  in_failure,
  &fragment->data.f_failure);
    break;
  }
}
  }

  static bool Deserialize(::unexportable_keys::mojom::internal::UnexportableKeyService_GenerateSigningKey_ResponseParam_Result_Data* input,
                          UserType* output,
                          Message* message) {
    if (!input || input->is_null())
      return CallSetToNullIfExists<Traits>(output);

    ::unexportable_keys::mojom::UnexportableKeyService_GenerateSigningKey_ResponseParam_ResultDataView data_view(input, message);
    return CallTraitsRead<Traits>(data_view, output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::unexportable_keys::mojom::UnexportableKeyService_FromWrappedSigningKey_ResponseParam_ResultDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = UnionTraits<::unexportable_keys::mojom::UnexportableKeyService_FromWrappedSigningKey_ResponseParam_ResultDataView, UserType>;

  static void Serialize(MaybeConstUserType& input,
                        MessageFragment<::unexportable_keys::mojom::internal::UnexportableKeyService_FromWrappedSigningKey_ResponseParam_Result_Data>& fragment,
                        bool inlined) {
    
    if (CallIsNullIfExists<Traits>(input)) {
       if (inlined)
        fragment->set_null();
      return;
    }

if (!inlined)
  fragment.Allocate();

    // TODO(azani): Handle unknown and objects.
    // Set the not-null flag.
fragment->size = kUnionDataSize;
fragment->tag = Traits::GetTag(input);
switch (fragment->tag) {
  case ::unexportable_keys::mojom::UnexportableKeyService_FromWrappedSigningKey_ResponseParam_ResultDataView::Tag::kSuccess: {
    decltype(Traits::success(input))
    in_success = Traits::success(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_success)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<::unexportable_keys::mojom::NewSigningKeyDataDataView>(
  in_success,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  mojo::internal::SendValidation::kDefault,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null success in UnexportableKeyService_FromWrappedSigningKey_ResponseParam_Result union");
    fragment->data.f_success.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
  case ::unexportable_keys::mojom::UnexportableKeyService_FromWrappedSigningKey_ResponseParam_ResultDataView::Tag::kFailure: {
    decltype(Traits::failure(input))
    in_failure = Traits::failure(input);
        
mojo::internal::Serialize<::unexportable_keys::mojom::ServiceError>(
  in_failure,
  &fragment->data.f_failure);
    break;
  }
}
  }

  static bool Deserialize(::unexportable_keys::mojom::internal::UnexportableKeyService_FromWrappedSigningKey_ResponseParam_Result_Data* input,
                          UserType* output,
                          Message* message) {
    if (!input || input->is_null())
      return CallSetToNullIfExists<Traits>(output);

    ::unexportable_keys::mojom::UnexportableKeyService_FromWrappedSigningKey_ResponseParam_ResultDataView data_view(input, message);
    return CallTraitsRead<Traits>(data_view, output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::unexportable_keys::mojom::UnexportableKeyService_GenerateAttestationKey_ResponseParam_ResultDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = UnionTraits<::unexportable_keys::mojom::UnexportableKeyService_GenerateAttestationKey_ResponseParam_ResultDataView, UserType>;

  static void Serialize(MaybeConstUserType& input,
                        MessageFragment<::unexportable_keys::mojom::internal::UnexportableKeyService_GenerateAttestationKey_ResponseParam_Result_Data>& fragment,
                        bool inlined) {
    
    if (CallIsNullIfExists<Traits>(input)) {
       if (inlined)
        fragment->set_null();
      return;
    }

if (!inlined)
  fragment.Allocate();

    // TODO(azani): Handle unknown and objects.
    // Set the not-null flag.
fragment->size = kUnionDataSize;
fragment->tag = Traits::GetTag(input);
switch (fragment->tag) {
  case ::unexportable_keys::mojom::UnexportableKeyService_GenerateAttestationKey_ResponseParam_ResultDataView::Tag::kSuccess: {
    decltype(Traits::success(input))
    in_success = Traits::success(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_success)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<::unexportable_keys::mojom::NewAttestationKeyDataDataView>(
  in_success,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  mojo::internal::SendValidation::kDefault,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null success in UnexportableKeyService_GenerateAttestationKey_ResponseParam_Result union");
    fragment->data.f_success.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
  case ::unexportable_keys::mojom::UnexportableKeyService_GenerateAttestationKey_ResponseParam_ResultDataView::Tag::kFailure: {
    decltype(Traits::failure(input))
    in_failure = Traits::failure(input);
        
mojo::internal::Serialize<::unexportable_keys::mojom::ServiceError>(
  in_failure,
  &fragment->data.f_failure);
    break;
  }
}
  }

  static bool Deserialize(::unexportable_keys::mojom::internal::UnexportableKeyService_GenerateAttestationKey_ResponseParam_Result_Data* input,
                          UserType* output,
                          Message* message) {
    if (!input || input->is_null())
      return CallSetToNullIfExists<Traits>(output);

    ::unexportable_keys::mojom::UnexportableKeyService_GenerateAttestationKey_ResponseParam_ResultDataView data_view(input, message);
    return CallTraitsRead<Traits>(data_view, output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::unexportable_keys::mojom::UnexportableKeyService_FromWrappedAttestationKey_ResponseParam_ResultDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = UnionTraits<::unexportable_keys::mojom::UnexportableKeyService_FromWrappedAttestationKey_ResponseParam_ResultDataView, UserType>;

  static void Serialize(MaybeConstUserType& input,
                        MessageFragment<::unexportable_keys::mojom::internal::UnexportableKeyService_FromWrappedAttestationKey_ResponseParam_Result_Data>& fragment,
                        bool inlined) {
    
    if (CallIsNullIfExists<Traits>(input)) {
       if (inlined)
        fragment->set_null();
      return;
    }

if (!inlined)
  fragment.Allocate();

    // TODO(azani): Handle unknown and objects.
    // Set the not-null flag.
fragment->size = kUnionDataSize;
fragment->tag = Traits::GetTag(input);
switch (fragment->tag) {
  case ::unexportable_keys::mojom::UnexportableKeyService_FromWrappedAttestationKey_ResponseParam_ResultDataView::Tag::kSuccess: {
    decltype(Traits::success(input))
    in_success = Traits::success(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_success)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<::unexportable_keys::mojom::NewAttestationKeyDataDataView>(
  in_success,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  mojo::internal::SendValidation::kDefault,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null success in UnexportableKeyService_FromWrappedAttestationKey_ResponseParam_Result union");
    fragment->data.f_success.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
  case ::unexportable_keys::mojom::UnexportableKeyService_FromWrappedAttestationKey_ResponseParam_ResultDataView::Tag::kFailure: {
    decltype(Traits::failure(input))
    in_failure = Traits::failure(input);
        
mojo::internal::Serialize<::unexportable_keys::mojom::ServiceError>(
  in_failure,
  &fragment->data.f_failure);
    break;
  }
}
  }

  static bool Deserialize(::unexportable_keys::mojom::internal::UnexportableKeyService_FromWrappedAttestationKey_ResponseParam_Result_Data* input,
                          UserType* output,
                          Message* message) {
    if (!input || input->is_null())
      return CallSetToNullIfExists<Traits>(output);

    ::unexportable_keys::mojom::UnexportableKeyService_FromWrappedAttestationKey_ResponseParam_ResultDataView data_view(input, message);
    return CallTraitsRead<Traits>(data_view, output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::unexportable_keys::mojom::UnexportableKeyService_Sign_ResponseParam_ResultDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = UnionTraits<::unexportable_keys::mojom::UnexportableKeyService_Sign_ResponseParam_ResultDataView, UserType>;

  static void Serialize(MaybeConstUserType& input,
                        MessageFragment<::unexportable_keys::mojom::internal::UnexportableKeyService_Sign_ResponseParam_Result_Data>& fragment,
                        bool inlined) {
    
    if (CallIsNullIfExists<Traits>(input)) {
       if (inlined)
        fragment->set_null();
      return;
    }

if (!inlined)
  fragment.Allocate();

    // TODO(azani): Handle unknown and objects.
    // Set the not-null flag.
fragment->size = kUnionDataSize;
fragment->tag = Traits::GetTag(input);
switch (fragment->tag) {
  case ::unexportable_keys::mojom::UnexportableKeyService_Sign_ResponseParam_ResultDataView::Tag::kSuccess: {
    decltype(Traits::success(input))
    in_success = Traits::success(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_success)::BaseType>
    value_fragment(fragment.message());
        constexpr const mojo::internal::ContainerValidateParams& success_validate_params =
            mojo::internal::GetArrayValidator<0, false, nullptr>();
        
mojo::internal::Serialize<mojo::ArrayDataView<uint8_t>>(
  in_success,
  value_fragment,
  &success_validate_params);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  mojo::internal::SendValidation::kDefault,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null success in UnexportableKeyService_Sign_ResponseParam_Result union");
    fragment->data.f_success.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
  case ::unexportable_keys::mojom::UnexportableKeyService_Sign_ResponseParam_ResultDataView::Tag::kFailure: {
    decltype(Traits::failure(input))
    in_failure = Traits::failure(input);
        
mojo::internal::Serialize<::unexportable_keys::mojom::ServiceError>(
  in_failure,
  &fragment->data.f_failure);
    break;
  }
}
  }

  static bool Deserialize(::unexportable_keys::mojom::internal::UnexportableKeyService_Sign_ResponseParam_Result_Data* input,
                          UserType* output,
                          Message* message) {
    if (!input || input->is_null())
      return CallSetToNullIfExists<Traits>(output);

    ::unexportable_keys::mojom::UnexportableKeyService_Sign_ResponseParam_ResultDataView data_view(input, message);
    return CallTraitsRead<Traits>(data_view, output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::unexportable_keys::mojom::UnexportableKeyService_Certify_ResponseParam_ResultDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = UnionTraits<::unexportable_keys::mojom::UnexportableKeyService_Certify_ResponseParam_ResultDataView, UserType>;

  static void Serialize(MaybeConstUserType& input,
                        MessageFragment<::unexportable_keys::mojom::internal::UnexportableKeyService_Certify_ResponseParam_Result_Data>& fragment,
                        bool inlined) {
    
    if (CallIsNullIfExists<Traits>(input)) {
       if (inlined)
        fragment->set_null();
      return;
    }

if (!inlined)
  fragment.Allocate();

    // TODO(azani): Handle unknown and objects.
    // Set the not-null flag.
fragment->size = kUnionDataSize;
fragment->tag = Traits::GetTag(input);
switch (fragment->tag) {
  case ::unexportable_keys::mojom::UnexportableKeyService_Certify_ResponseParam_ResultDataView::Tag::kSuccess: {
    decltype(Traits::success(input))
    in_success = Traits::success(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_success)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<::unexportable_keys::mojom::AttestationStatementDataView>(
  in_success,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  mojo::internal::SendValidation::kDefault,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null success in UnexportableKeyService_Certify_ResponseParam_Result union");
    fragment->data.f_success.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
  case ::unexportable_keys::mojom::UnexportableKeyService_Certify_ResponseParam_ResultDataView::Tag::kFailure: {
    decltype(Traits::failure(input))
    in_failure = Traits::failure(input);
        
mojo::internal::Serialize<::unexportable_keys::mojom::ServiceError>(
  in_failure,
  &fragment->data.f_failure);
    break;
  }
}
  }

  static bool Deserialize(::unexportable_keys::mojom::internal::UnexportableKeyService_Certify_ResponseParam_Result_Data* input,
                          UserType* output,
                          Message* message) {
    if (!input || input->is_null())
      return CallSetToNullIfExists<Traits>(output);

    ::unexportable_keys::mojom::UnexportableKeyService_Certify_ResponseParam_ResultDataView data_view(input, message);
    return CallTraitsRead<Traits>(data_view, output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::unexportable_keys::mojom::UnexportableKeyService_GetAllKeysForGarbageCollection_ResponseParam_ResultDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = UnionTraits<::unexportable_keys::mojom::UnexportableKeyService_GetAllKeysForGarbageCollection_ResponseParam_ResultDataView, UserType>;

  static void Serialize(MaybeConstUserType& input,
                        MessageFragment<::unexportable_keys::mojom::internal::UnexportableKeyService_GetAllKeysForGarbageCollection_ResponseParam_Result_Data>& fragment,
                        bool inlined) {
    
    if (CallIsNullIfExists<Traits>(input)) {
       if (inlined)
        fragment->set_null();
      return;
    }

if (!inlined)
  fragment.Allocate();

    // TODO(azani): Handle unknown and objects.
    // Set the not-null flag.
fragment->size = kUnionDataSize;
fragment->tag = Traits::GetTag(input);
switch (fragment->tag) {
  case ::unexportable_keys::mojom::UnexportableKeyService_GetAllKeysForGarbageCollection_ResponseParam_ResultDataView::Tag::kSuccess: {
    decltype(Traits::success(input))
    in_success = Traits::success(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_success)::BaseType>
    value_fragment(fragment.message());
        constexpr const mojo::internal::ContainerValidateParams& success_validate_params =
            mojo::internal::GetArrayValidator<0, false, nullptr>();
        
mojo::internal::Serialize<mojo::ArrayDataView<::unexportable_keys::mojom::NewSigningKeyDataDataView>>(
  in_success,
  value_fragment,
  &success_validate_params);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  mojo::internal::SendValidation::kDefault,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null success in UnexportableKeyService_GetAllKeysForGarbageCollection_ResponseParam_Result union");
    fragment->data.f_success.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
  case ::unexportable_keys::mojom::UnexportableKeyService_GetAllKeysForGarbageCollection_ResponseParam_ResultDataView::Tag::kFailure: {
    decltype(Traits::failure(input))
    in_failure = Traits::failure(input);
        
mojo::internal::Serialize<::unexportable_keys::mojom::ServiceError>(
  in_failure,
  &fragment->data.f_failure);
    break;
  }
}
  }

  static bool Deserialize(::unexportable_keys::mojom::internal::UnexportableKeyService_GetAllKeysForGarbageCollection_ResponseParam_Result_Data* input,
                          UserType* output,
                          Message* message) {
    if (!input || input->is_null())
      return CallSetToNullIfExists<Traits>(output);

    ::unexportable_keys::mojom::UnexportableKeyService_GetAllKeysForGarbageCollection_ResponseParam_ResultDataView data_view(input, message);
    return CallTraitsRead<Traits>(data_view, output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::unexportable_keys::mojom::UnexportableKeyService_DeleteKeys_ResponseParam_ResultDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = UnionTraits<::unexportable_keys::mojom::UnexportableKeyService_DeleteKeys_ResponseParam_ResultDataView, UserType>;

  static void Serialize(MaybeConstUserType& input,
                        MessageFragment<::unexportable_keys::mojom::internal::UnexportableKeyService_DeleteKeys_ResponseParam_Result_Data>& fragment,
                        bool inlined) {
    
    if (CallIsNullIfExists<Traits>(input)) {
       if (inlined)
        fragment->set_null();
      return;
    }

if (!inlined)
  fragment.Allocate();

    // TODO(azani): Handle unknown and objects.
    // Set the not-null flag.
fragment->size = kUnionDataSize;
fragment->tag = Traits::GetTag(input);
switch (fragment->tag) {
  case ::unexportable_keys::mojom::UnexportableKeyService_DeleteKeys_ResponseParam_ResultDataView::Tag::kSuccess: {
    decltype(Traits::success(input))
    in_success = Traits::success(input);
    fragment->data.f_success = in_success;
    break;
  }
  case ::unexportable_keys::mojom::UnexportableKeyService_DeleteKeys_ResponseParam_ResultDataView::Tag::kFailure: {
    decltype(Traits::failure(input))
    in_failure = Traits::failure(input);
        
mojo::internal::Serialize<::unexportable_keys::mojom::ServiceError>(
  in_failure,
  &fragment->data.f_failure);
    break;
  }
}
  }

  static bool Deserialize(::unexportable_keys::mojom::internal::UnexportableKeyService_DeleteKeys_ResponseParam_Result_Data* input,
                          UserType* output,
                          Message* message) {
    if (!input || input->is_null())
      return CallSetToNullIfExists<Traits>(output);

    ::unexportable_keys::mojom::UnexportableKeyService_DeleteKeys_ResponseParam_ResultDataView data_view(input, message);
    return CallTraitsRead<Traits>(data_view, output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::unexportable_keys::mojom::UnexportableKeyService_DeleteAllKeys_ResponseParam_ResultDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = UnionTraits<::unexportable_keys::mojom::UnexportableKeyService_DeleteAllKeys_ResponseParam_ResultDataView, UserType>;

  static void Serialize(MaybeConstUserType& input,
                        MessageFragment<::unexportable_keys::mojom::internal::UnexportableKeyService_DeleteAllKeys_ResponseParam_Result_Data>& fragment,
                        bool inlined) {
    
    if (CallIsNullIfExists<Traits>(input)) {
       if (inlined)
        fragment->set_null();
      return;
    }

if (!inlined)
  fragment.Allocate();

    // TODO(azani): Handle unknown and objects.
    // Set the not-null flag.
fragment->size = kUnionDataSize;
fragment->tag = Traits::GetTag(input);
switch (fragment->tag) {
  case ::unexportable_keys::mojom::UnexportableKeyService_DeleteAllKeys_ResponseParam_ResultDataView::Tag::kSuccess: {
    decltype(Traits::success(input))
    in_success = Traits::success(input);
    fragment->data.f_success = in_success;
    break;
  }
  case ::unexportable_keys::mojom::UnexportableKeyService_DeleteAllKeys_ResponseParam_ResultDataView::Tag::kFailure: {
    decltype(Traits::failure(input))
    in_failure = Traits::failure(input);
        
mojo::internal::Serialize<::unexportable_keys::mojom::ServiceError>(
  in_failure,
  &fragment->data.f_failure);
    break;
  }
}
  }

  static bool Deserialize(::unexportable_keys::mojom::internal::UnexportableKeyService_DeleteAllKeys_ResponseParam_Result_Data* input,
                          UserType* output,
                          Message* message) {
    if (!input || input->is_null())
      return CallSetToNullIfExists<Traits>(output);

    ::unexportable_keys::mojom::UnexportableKeyService_DeleteAllKeys_ResponseParam_ResultDataView data_view(input, message);
    return CallTraitsRead<Traits>(data_view, output);
  }
};

}  // namespace internal

}  // namespace mojo


namespace unexportable_keys::mojom {

inline void UnexportableSigningKeyIdDataView::GetKeyIdDataView(
    ::mojo_base::mojom::UnguessableTokenDataView* output) {
  auto pointer = data_->key_id.Get();
  *output = ::mojo_base::mojom::UnguessableTokenDataView(pointer, message_);
}


inline void UnexportableAttestationKeyIdDataView::GetKeyIdDataView(
    ::mojo_base::mojom::UnguessableTokenDataView* output) {
  auto pointer = data_->key_id.Get();
  *output = ::mojo_base::mojom::UnguessableTokenDataView(pointer, message_);
}


inline void NewKeyMetadataDataView::GetSubjectPublicKeyInfoDataView(
    mojo::ArrayDataView<uint8_t>* output) {
  auto pointer = data_->subject_public_key_info.Get();
  *output = mojo::ArrayDataView<uint8_t>(pointer, message_);
}
inline void NewKeyMetadataDataView::GetWrappedKeyDataView(
    mojo::ArrayDataView<uint8_t>* output) {
  auto pointer = data_->wrapped_key.Get();
  *output = mojo::ArrayDataView<uint8_t>(pointer, message_);
}
inline void NewKeyMetadataDataView::GetKeyTagDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->key_tag.Get();
  *output = mojo::StringDataView(pointer, message_);
}
inline void NewKeyMetadataDataView::GetCreationTimeDataView(
    ::mojo_base::mojom::TimeDataView* output) {
  auto pointer = data_->creation_time.Get();
  *output = ::mojo_base::mojom::TimeDataView(pointer, message_);
}


inline void NewSigningKeyDataDataView::GetKeyIdDataView(
    UnexportableSigningKeyIdDataView* output) {
  auto pointer = data_->key_id.Get();
  *output = UnexportableSigningKeyIdDataView(pointer, message_);
}
inline void NewSigningKeyDataDataView::GetMetadataDataView(
    NewKeyMetadataDataView* output) {
  auto pointer = data_->metadata.Get();
  *output = NewKeyMetadataDataView(pointer, message_);
}


inline void NewAttestationKeyDataDataView::GetKeyIdDataView(
    UnexportableAttestationKeyIdDataView* output) {
  auto pointer = data_->key_id.Get();
  *output = UnexportableAttestationKeyIdDataView(pointer, message_);
}
inline void NewAttestationKeyDataDataView::GetMetadataDataView(
    NewKeyMetadataDataView* output) {
  auto pointer = data_->metadata.Get();
  *output = NewKeyMetadataDataView(pointer, message_);
}


inline void AttestationStatementDataView::GetStatementDataView(
    mojo::ArrayDataView<uint8_t>* output) {
  auto pointer = data_->statement.Get();
  *output = mojo::ArrayDataView<uint8_t>(pointer, message_);
}
inline void AttestationStatementDataView::GetSignatureDataView(
    mojo::ArrayDataView<uint8_t>* output) {
  auto pointer = data_->signature.Get();
  *output = mojo::ArrayDataView<uint8_t>(pointer, message_);
}


inline void UnexportableKeyService_GenerateSigningKey_ResponseParam_ResultDataView::GetSuccessDataView(
    NewSigningKeyDataDataView* output) const {
  CHECK(is_success());
  *output = NewSigningKeyDataDataView(data_->data.f_success.Get(), message_);
}

inline void UnexportableKeyService_FromWrappedSigningKey_ResponseParam_ResultDataView::GetSuccessDataView(
    NewSigningKeyDataDataView* output) const {
  CHECK(is_success());
  *output = NewSigningKeyDataDataView(data_->data.f_success.Get(), message_);
}

inline void UnexportableKeyService_GenerateAttestationKey_ResponseParam_ResultDataView::GetSuccessDataView(
    NewAttestationKeyDataDataView* output) const {
  CHECK(is_success());
  *output = NewAttestationKeyDataDataView(data_->data.f_success.Get(), message_);
}

inline void UnexportableKeyService_FromWrappedAttestationKey_ResponseParam_ResultDataView::GetSuccessDataView(
    NewAttestationKeyDataDataView* output) const {
  CHECK(is_success());
  *output = NewAttestationKeyDataDataView(data_->data.f_success.Get(), message_);
}

inline void UnexportableKeyService_Sign_ResponseParam_ResultDataView::GetSuccessDataView(
    mojo::ArrayDataView<uint8_t>* output) const {
  CHECK(is_success());
  *output = mojo::ArrayDataView<uint8_t>(data_->data.f_success.Get(), message_);
}

inline void UnexportableKeyService_Certify_ResponseParam_ResultDataView::GetSuccessDataView(
    AttestationStatementDataView* output) const {
  CHECK(is_success());
  *output = AttestationStatementDataView(data_->data.f_success.Get(), message_);
}

inline void UnexportableKeyService_GetAllKeysForGarbageCollection_ResponseParam_ResultDataView::GetSuccessDataView(
    mojo::ArrayDataView<NewSigningKeyDataDataView>* output) const {
  CHECK(is_success());
  *output = mojo::ArrayDataView<NewSigningKeyDataDataView>(data_->data.f_success.Get(), message_);
}




}  // unexportable_keys::mojom

// Declare TraceFormatTraits for enums, which should be defined in ::perfetto
// namespace.

namespace perfetto {

template <>
struct  TraceFormatTraits<::unexportable_keys::mojom::SignatureAlgorithm> {
 static void WriteIntoTrace(perfetto::TracedValue context, ::unexportable_keys::mojom::SignatureAlgorithm value);
};

} // namespace perfetto

namespace perfetto {

template <>
struct  TraceFormatTraits<::unexportable_keys::mojom::ServiceError> {
 static void WriteIntoTrace(perfetto::TracedValue context, ::unexportable_keys::mojom::ServiceError value);
};

} // namespace perfetto

namespace perfetto {

template <>
struct  TraceFormatTraits<::unexportable_keys::mojom::BackgroundTaskPriority> {
 static void WriteIntoTrace(perfetto::TracedValue context, ::unexportable_keys::mojom::BackgroundTaskPriority value);
};

} // namespace perfetto

namespace perfetto {

template <>
struct  TraceFormatTraits<::unexportable_keys::mojom::AttestationFormat> {
 static void WriteIntoTrace(perfetto::TracedValue context, ::unexportable_keys::mojom::AttestationFormat value);
};

} // namespace perfetto

#endif  // COMPONENTS_UNEXPORTABLE_KEYS_MOJOM_UNEXPORTABLE_KEY_SERVICE_MOJOM_SHARED_H_