// third_party/blink/public/mojom/webauthn/authenticator.mojom-send-validation.h is auto generated by mojom_bindings_generator.py, do not edit

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

#ifndef THIRD_PARTY_BLINK_PUBLIC_MOJOM_WEBAUTHN_AUTHENTICATOR_MOJOM_SEND_VALIDATION_H_
#define THIRD_PARTY_BLINK_PUBLIC_MOJOM_WEBAUTHN_AUTHENTICATOR_MOJOM_SEND_VALIDATION_H_

#include "third_party/blink/public/mojom/webauthn/authenticator.mojom-shared-internal.h"
#include "components/payments/mojom/payment_request_data.mojom-shared.h"
#include "mojo/public/mojom/base/time.mojom-shared.h"
#include "third_party/blink/public/mojom/credentialmanagement/credential_manager.mojom-shared.h"
#include "url/mojom/origin.mojom-shared.h"
#include "url/mojom/url.mojom-shared.h"

#include "third_party/blink/public/mojom/webauthn/authenticator.mojom-data-view.h"

#include "mojo/public/cpp/bindings/lib/send_validation_type.h"
#include "mojo/public/cpp/bindings/lib/send_validation.h"
#include "mojo/public/cpp/bindings/lib/interface_serialization_send_validation.h"
#include "mojo/public/cpp/bindings/lib/has_send_validation_helper.h"

namespace mojo::internal {
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::blink::mojom::AuthenticatorStatus, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::blink::mojom::AuthenticatorTransport, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::blink::mojom::Hint, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::blink::mojom::UserVerificationRequirement, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::blink::mojom::Mediation, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::blink::mojom::ResidentKeyRequirement, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::blink::mojom::AuthenticatorAttachment, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::blink::mojom::ProtectionPolicy, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::blink::mojom::LargeBlobSupport, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::blink::mojom::AttestationConveyancePreference, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::blink::mojom::PublicKeyCredentialType, MaybeConstUserType>
    : std::false_type {};

template <typename MaybeConstUserType, mojo::internal::SendValidation send_validation>
struct SendValidationSerializer<::blink::mojom::CommonCredentialInfoDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::blink::mojom::CommonCredentialInfoDataView, UserType>;
  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::blink::mojom::internal::CommonCredentialInfo_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

      decltype(Traits::id(input)) in_id = Traits::id(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->id)::BaseType> id_fragment(
              fragment.message());
      
      mojo::internal::Serialize<mojo::StringDataView, send_validation>(
        in_id,
        id_fragment);

      fragment->id.Set(
          id_fragment.is_null() ? nullptr : id_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->id.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null id in CommonCredentialInfo struct");

      decltype(Traits::raw_id(input)) in_raw_id = Traits::raw_id(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->raw_id)::BaseType>
          raw_id_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& raw_id_validate_params =
          mojo::internal::GetArrayValidator<0, false, nullptr>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<uint8_t>, send_validation>(
        in_raw_id,
        raw_id_fragment,
        &raw_id_validate_params);

      fragment->raw_id.Set(
          raw_id_fragment.is_null() ? nullptr : raw_id_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->raw_id.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null raw_id in CommonCredentialInfo struct");

      decltype(Traits::client_data_json(input)) in_client_data_json = Traits::client_data_json(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->client_data_json)::BaseType>
          client_data_json_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& client_data_json_validate_params =
          mojo::internal::GetArrayValidator<0, false, nullptr>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<uint8_t>, send_validation>(
        in_client_data_json,
        client_data_json_fragment,
        &client_data_json_validate_params);

      fragment->client_data_json.Set(
          client_data_json_fragment.is_null() ? nullptr : client_data_json_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->client_data_json.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null client_data_json in CommonCredentialInfo struct");

      decltype(Traits::authenticator_data(input)) in_authenticator_data = Traits::authenticator_data(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->authenticator_data)::BaseType>
          authenticator_data_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& authenticator_data_validate_params =
          mojo::internal::GetArrayValidator<0, false, nullptr>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<uint8_t>, send_validation>(
        in_authenticator_data,
        authenticator_data_fragment,
        &authenticator_data_validate_params);

      fragment->authenticator_data.Set(
          authenticator_data_fragment.is_null() ? nullptr : authenticator_data_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->authenticator_data.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null authenticator_data in CommonCredentialInfo struct");
  }
};

template <typename MaybeConstUserType, mojo::internal::SendValidation send_validation>
struct SendValidationSerializer<::blink::mojom::UvmEntryDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::blink::mojom::UvmEntryDataView, UserType>;
  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::blink::mojom::internal::UvmEntry_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

      fragment->user_verification_method = Traits::user_verification_method(input);

      fragment->key_protection_type = Traits::key_protection_type(input);

      fragment->matcher_protection_type = Traits::matcher_protection_type(input);
  }
};

template <typename MaybeConstUserType, mojo::internal::SendValidation send_validation>
struct SendValidationSerializer<::blink::mojom::CmtgKeyResponseDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::blink::mojom::CmtgKeyResponseDataView, UserType>;
  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::blink::mojom::internal::CmtgKeyResponse_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

      decltype(Traits::cmtg_key(input)) in_cmtg_key = Traits::cmtg_key(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->cmtg_key)::BaseType>
          cmtg_key_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& cmtg_key_validate_params =
          mojo::internal::GetArrayValidator<0, false, nullptr>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<uint8_t>, send_validation>(
        in_cmtg_key,
        cmtg_key_fragment,
        &cmtg_key_validate_params);

      fragment->cmtg_key.Set(
          cmtg_key_fragment.is_null() ? nullptr : cmtg_key_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->cmtg_key.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null cmtg_key in CmtgKeyResponse 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>, send_validation>(
        in_signature,
        signature_fragment,
        &signature_validate_params);

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

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

template <typename MaybeConstUserType, mojo::internal::SendValidation send_validation>
struct SendValidationSerializer<::blink::mojom::AuthenticationExtensionsPaymentResponseDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::blink::mojom::AuthenticationExtensionsPaymentResponseDataView, UserType>;
  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::blink::mojom::internal::AuthenticationExtensionsPaymentResponse_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

      decltype(Traits::browser_bound_signature(input)) in_browser_bound_signature = Traits::browser_bound_signature(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->browser_bound_signature)::BaseType>
          browser_bound_signature_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& browser_bound_signature_validate_params =
          mojo::internal::GetArrayValidator<0, false, nullptr>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<uint8_t>, send_validation>(
        in_browser_bound_signature,
        browser_bound_signature_fragment,
        &browser_bound_signature_validate_params);

      fragment->browser_bound_signature.Set(
          browser_bound_signature_fragment.is_null() ? nullptr : browser_bound_signature_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->browser_bound_signature.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null browser_bound_signature in AuthenticationExtensionsPaymentResponse struct");
  }
};

template <typename MaybeConstUserType, mojo::internal::SendValidation send_validation>
struct SendValidationSerializer<::blink::mojom::MakeCredentialAuthenticatorResponseDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::blink::mojom::MakeCredentialAuthenticatorResponseDataView, UserType>;
  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::blink::mojom::internal::MakeCredentialAuthenticatorResponse_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

      decltype(Traits::info(input)) in_info = Traits::info(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->info)::BaseType> info_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::blink::mojom::CommonCredentialInfoDataView, send_validation>(
        in_info,
        info_fragment);

      fragment->info.Set(
          info_fragment.is_null() ? nullptr : info_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->info.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null info in MakeCredentialAuthenticatorResponse struct");

      
      mojo::internal::Serialize<::blink::mojom::AuthenticatorAttachment>(
        Traits::authenticator_attachment(input),
        &fragment->authenticator_attachment);

      decltype(Traits::attestation_object(input)) in_attestation_object = Traits::attestation_object(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->attestation_object)::BaseType>
          attestation_object_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& attestation_object_validate_params =
          mojo::internal::GetArrayValidator<0, false, nullptr>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<uint8_t>, send_validation>(
        in_attestation_object,
        attestation_object_fragment,
        &attestation_object_validate_params);

      fragment->attestation_object.Set(
          attestation_object_fragment.is_null() ? nullptr : attestation_object_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->attestation_object.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null attestation_object in MakeCredentialAuthenticatorResponse struct");

      decltype(Traits::transports(input)) in_transports = Traits::transports(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->transports)::BaseType>
          transports_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& transports_validate_params =
          mojo::internal::GetArrayOfEnumsValidator<0, false, ::blink::mojom::internal::AuthenticatorTransport_Data::Validate>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<::blink::mojom::AuthenticatorTransport>, send_validation>(
        in_transports,
        transports_fragment,
        &transports_validate_params);

      fragment->transports.Set(
          transports_fragment.is_null() ? nullptr : transports_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->transports.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null transports in MakeCredentialAuthenticatorResponse struct");

      fragment->echo_hmac_create_secret = Traits::echo_hmac_create_secret(input);

      fragment->hmac_create_secret = Traits::hmac_create_secret(input);

      fragment->echo_prf = Traits::echo_prf(input);

      fragment->prf = Traits::prf(input);

      decltype(Traits::prf_results(input)) in_prf_results = Traits::prf_results(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->prf_results)::BaseType> prf_results_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::blink::mojom::PRFValuesDataView, send_validation>(
        in_prf_results,
        prf_results_fragment);

      fragment->prf_results.Set(
          prf_results_fragment.is_null() ? nullptr : prf_results_fragment.data());

      fragment->echo_cred_blob = Traits::echo_cred_blob(input);

      fragment->cred_blob = Traits::cred_blob(input);

      decltype(Traits::public_key_der(input)) in_public_key_der = Traits::public_key_der(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->public_key_der)::BaseType>
          public_key_der_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& public_key_der_validate_params =
          mojo::internal::GetArrayValidator<0, false, nullptr>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<uint8_t>, send_validation>(
        in_public_key_der,
        public_key_der_fragment,
        &public_key_der_validate_params);

      fragment->public_key_der.Set(
          public_key_der_fragment.is_null() ? nullptr : public_key_der_fragment.data());

      fragment->public_key_algo = Traits::public_key_algo(input);

      fragment->echo_cred_props = Traits::echo_cred_props(input);

      fragment->has_cred_props_rk = Traits::has_cred_props_rk(input);

      fragment->cred_props_rk = Traits::cred_props_rk(input);

      fragment->echo_large_blob = Traits::echo_large_blob(input);

      fragment->supports_large_blob = Traits::supports_large_blob(input);

      decltype(Traits::payment(input)) in_payment = Traits::payment(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->payment)::BaseType> payment_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::blink::mojom::AuthenticationExtensionsPaymentResponseDataView, send_validation>(
        in_payment,
        payment_fragment);

      fragment->payment.Set(
          payment_fragment.is_null() ? nullptr : payment_fragment.data());

      decltype(Traits::cmtg_key(input)) in_cmtg_key = Traits::cmtg_key(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->cmtg_key)::BaseType> cmtg_key_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::blink::mojom::CmtgKeyResponseDataView, send_validation>(
        in_cmtg_key,
        cmtg_key_fragment);

      fragment->cmtg_key.Set(
          cmtg_key_fragment.is_null() ? nullptr : cmtg_key_fragment.data());
  }
};

template <typename MaybeConstUserType, mojo::internal::SendValidation send_validation>
struct SendValidationSerializer<::blink::mojom::GetAssertionAuthenticatorResponseDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::blink::mojom::GetAssertionAuthenticatorResponseDataView, UserType>;
  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::blink::mojom::internal::GetAssertionAuthenticatorResponse_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

      decltype(Traits::info(input)) in_info = Traits::info(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->info)::BaseType> info_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::blink::mojom::CommonCredentialInfoDataView, send_validation>(
        in_info,
        info_fragment);

      fragment->info.Set(
          info_fragment.is_null() ? nullptr : info_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->info.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null info in GetAssertionAuthenticatorResponse struct");

      
      mojo::internal::Serialize<::blink::mojom::AuthenticatorAttachment>(
        Traits::authenticator_attachment(input),
        &fragment->authenticator_attachment);

      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>, send_validation>(
        in_signature,
        signature_fragment,
        &signature_validate_params);

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

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->signature.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null signature in GetAssertionAuthenticatorResponse struct");

      decltype(Traits::user_handle(input)) in_user_handle = Traits::user_handle(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->user_handle)::BaseType>
          user_handle_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& user_handle_validate_params =
          mojo::internal::GetArrayValidator<0, false, nullptr>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<uint8_t>, send_validation>(
        in_user_handle,
        user_handle_fragment,
        &user_handle_validate_params);

      fragment->user_handle.Set(
          user_handle_fragment.is_null() ? nullptr : user_handle_fragment.data());

      decltype(Traits::extensions(input)) in_extensions = Traits::extensions(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->extensions)::BaseType> extensions_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::blink::mojom::AuthenticationExtensionsClientOutputsDataView, send_validation>(
        in_extensions,
        extensions_fragment);

      fragment->extensions.Set(
          extensions_fragment.is_null() ? nullptr : extensions_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->extensions.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null extensions in GetAssertionAuthenticatorResponse struct");
  }
};

template <typename MaybeConstUserType, mojo::internal::SendValidation send_validation>
struct SendValidationSerializer<::blink::mojom::AuthenticationExtensionsClientOutputsDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::blink::mojom::AuthenticationExtensionsClientOutputsDataView, UserType>;
  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::blink::mojom::internal::AuthenticationExtensionsClientOutputs_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

      fragment->echo_appid_extension = Traits::echo_appid_extension(input);

      fragment->appid_extension = Traits::appid_extension(input);

      fragment->echo_user_verification_methods = Traits::echo_user_verification_methods(input);

      decltype(Traits::user_verification_methods(input)) in_user_verification_methods = Traits::user_verification_methods(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->user_verification_methods)::BaseType>
          user_verification_methods_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& user_verification_methods_validate_params =
          mojo::internal::GetArrayValidator<0, false, nullptr>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<::blink::mojom::UvmEntryDataView>, send_validation>(
        in_user_verification_methods,
        user_verification_methods_fragment,
        &user_verification_methods_validate_params);

      fragment->user_verification_methods.Set(
          user_verification_methods_fragment.is_null() ? nullptr : user_verification_methods_fragment.data());

      fragment->echo_prf = Traits::echo_prf(input);

      decltype(Traits::prf_results(input)) in_prf_results = Traits::prf_results(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->prf_results)::BaseType> prf_results_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::blink::mojom::PRFValuesDataView, send_validation>(
        in_prf_results,
        prf_results_fragment);

      fragment->prf_results.Set(
          prf_results_fragment.is_null() ? nullptr : prf_results_fragment.data());

      fragment->prf_not_evaluated = Traits::prf_not_evaluated(input);

      fragment->echo_large_blob = Traits::echo_large_blob(input);

      decltype(Traits::large_blob(input)) in_large_blob = Traits::large_blob(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->large_blob)::BaseType>
          large_blob_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& large_blob_validate_params =
          mojo::internal::GetArrayValidator<0, false, nullptr>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<uint8_t>, send_validation>(
        in_large_blob,
        large_blob_fragment,
        &large_blob_validate_params);

      fragment->large_blob.Set(
          large_blob_fragment.is_null() ? nullptr : large_blob_fragment.data());

      fragment->echo_large_blob_written = Traits::echo_large_blob_written(input);

      fragment->large_blob_written = Traits::large_blob_written(input);

      decltype(Traits::get_cred_blob(input)) in_get_cred_blob = Traits::get_cred_blob(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->get_cred_blob)::BaseType>
          get_cred_blob_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& get_cred_blob_validate_params =
          mojo::internal::GetArrayValidator<0, false, nullptr>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<uint8_t>, send_validation>(
        in_get_cred_blob,
        get_cred_blob_fragment,
        &get_cred_blob_validate_params);

      fragment->get_cred_blob.Set(
          get_cred_blob_fragment.is_null() ? nullptr : get_cred_blob_fragment.data());

      decltype(Traits::payment(input)) in_payment = Traits::payment(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->payment)::BaseType> payment_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::blink::mojom::AuthenticationExtensionsPaymentResponseDataView, send_validation>(
        in_payment,
        payment_fragment);

      fragment->payment.Set(
          payment_fragment.is_null() ? nullptr : payment_fragment.data());

      decltype(Traits::cmtg_key(input)) in_cmtg_key = Traits::cmtg_key(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->cmtg_key)::BaseType> cmtg_key_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::blink::mojom::CmtgKeyResponseDataView, send_validation>(
        in_cmtg_key,
        cmtg_key_fragment);

      fragment->cmtg_key.Set(
          cmtg_key_fragment.is_null() ? nullptr : cmtg_key_fragment.data());
      fragment->cross_device_fallback_url_$flag = Traits::cross_device_fallback_url(input).has_value();
      if (Traits::cross_device_fallback_url(input).has_value()) {
        fragment->cross_device_fallback_url_$value = Traits::cross_device_fallback_url(input).value();
      }
  }
};

template <typename MaybeConstUserType, mojo::internal::SendValidation send_validation>
struct SendValidationSerializer<::blink::mojom::PublicKeyCredentialRpEntityDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::blink::mojom::PublicKeyCredentialRpEntityDataView, UserType>;
  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::blink::mojom::internal::PublicKeyCredentialRpEntity_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

      decltype(Traits::id(input)) in_id = Traits::id(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->id)::BaseType> id_fragment(
              fragment.message());
      
      mojo::internal::Serialize<mojo::StringDataView, send_validation>(
        in_id,
        id_fragment);

      fragment->id.Set(
          id_fragment.is_null() ? nullptr : id_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->id.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null id in PublicKeyCredentialRpEntity struct");

      decltype(Traits::name(input)) in_name = Traits::name(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->name)::BaseType> name_fragment(
              fragment.message());
      
      mojo::internal::Serialize<mojo::StringDataView, send_validation>(
        in_name,
        name_fragment);

      fragment->name.Set(
          name_fragment.is_null() ? nullptr : name_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->name.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null name in PublicKeyCredentialRpEntity struct");
  }
};

template <typename MaybeConstUserType, mojo::internal::SendValidation send_validation>
struct SendValidationSerializer<::blink::mojom::PublicKeyCredentialUserEntityDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::blink::mojom::PublicKeyCredentialUserEntityDataView, UserType>;
  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::blink::mojom::internal::PublicKeyCredentialUserEntity_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

      decltype(Traits::id(input)) in_id = Traits::id(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->id)::BaseType>
          id_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& id_validate_params =
          mojo::internal::GetArrayValidator<0, false, nullptr>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<uint8_t>, send_validation>(
        in_id,
        id_fragment,
        &id_validate_params);

      fragment->id.Set(
          id_fragment.is_null() ? nullptr : id_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->id.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null id in PublicKeyCredentialUserEntity struct");

      decltype(Traits::name(input)) in_name = Traits::name(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->name)::BaseType> name_fragment(
              fragment.message());
      
      mojo::internal::Serialize<mojo::StringDataView, send_validation>(
        in_name,
        name_fragment);

      fragment->name.Set(
          name_fragment.is_null() ? nullptr : name_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->name.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null name in PublicKeyCredentialUserEntity struct");

      decltype(Traits::display_name(input)) in_display_name = Traits::display_name(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->display_name)::BaseType> display_name_fragment(
              fragment.message());
      
      mojo::internal::Serialize<mojo::StringDataView, send_validation>(
        in_display_name,
        display_name_fragment);

      fragment->display_name.Set(
          display_name_fragment.is_null() ? nullptr : display_name_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->display_name.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null display_name in PublicKeyCredentialUserEntity struct");
  }
};

template <typename MaybeConstUserType, mojo::internal::SendValidation send_validation>
struct SendValidationSerializer<::blink::mojom::PublicKeyCredentialParametersDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::blink::mojom::PublicKeyCredentialParametersDataView, UserType>;
  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::blink::mojom::internal::PublicKeyCredentialParameters_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

      
      mojo::internal::Serialize<::blink::mojom::PublicKeyCredentialType>(
        Traits::type(input),
        &fragment->type);

      fragment->algorithm_identifier = Traits::algorithm_identifier(input);
  }
};

template <typename MaybeConstUserType, mojo::internal::SendValidation send_validation>
struct SendValidationSerializer<::blink::mojom::PRFValuesDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::blink::mojom::PRFValuesDataView, UserType>;
  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::blink::mojom::internal::PRFValues_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

      decltype(Traits::id(input)) in_id = Traits::id(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->id)::BaseType>
          id_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& id_validate_params =
          mojo::internal::GetArrayValidator<0, false, nullptr>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<uint8_t>, send_validation>(
        in_id,
        id_fragment,
        &id_validate_params);

      fragment->id.Set(
          id_fragment.is_null() ? nullptr : id_fragment.data());

      decltype(Traits::first(input)) in_first = Traits::first(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->first)::BaseType>
          first_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& first_validate_params =
          mojo::internal::GetArrayValidator<0, false, nullptr>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<uint8_t>, send_validation>(
        in_first,
        first_fragment,
        &first_validate_params);

      fragment->first.Set(
          first_fragment.is_null() ? nullptr : first_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->first.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null first in PRFValues struct");

      decltype(Traits::second(input)) in_second = Traits::second(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->second)::BaseType>
          second_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& second_validate_params =
          mojo::internal::GetArrayValidator<0, false, nullptr>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<uint8_t>, send_validation>(
        in_second,
        second_fragment,
        &second_validate_params);

      fragment->second.Set(
          second_fragment.is_null() ? nullptr : second_fragment.data());
  }
};

template <typename MaybeConstUserType, mojo::internal::SendValidation send_validation>
struct SendValidationSerializer<::blink::mojom::PaymentOptionsDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::blink::mojom::PaymentOptionsDataView, UserType>;
  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::blink::mojom::internal::PaymentOptions_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

      decltype(Traits::total(input)) in_total = Traits::total(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->total)::BaseType> total_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::payments::mojom::PaymentCurrencyAmountDataView, send_validation>(
        in_total,
        total_fragment);

      fragment->total.Set(
          total_fragment.is_null() ? nullptr : total_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->total.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null total in PaymentOptions struct");

      decltype(Traits::instrument(input)) in_instrument = Traits::instrument(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->instrument)::BaseType> instrument_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::blink::mojom::PaymentCredentialInstrumentDataView, send_validation>(
        in_instrument,
        instrument_fragment);

      fragment->instrument.Set(
          instrument_fragment.is_null() ? nullptr : instrument_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->instrument.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null instrument in PaymentOptions struct");

      decltype(Traits::payee_name(input)) in_payee_name = Traits::payee_name(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->payee_name)::BaseType> payee_name_fragment(
              fragment.message());
      
      mojo::internal::Serialize<mojo::StringDataView, send_validation>(
        in_payee_name,
        payee_name_fragment);

      fragment->payee_name.Set(
          payee_name_fragment.is_null() ? nullptr : payee_name_fragment.data());

      decltype(Traits::payee_origin(input)) in_payee_origin = Traits::payee_origin(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->payee_origin)::BaseType> payee_origin_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::url::mojom::OriginDataView, send_validation>(
        in_payee_origin,
        payee_origin_fragment);

      fragment->payee_origin.Set(
          payee_origin_fragment.is_null() ? nullptr : payee_origin_fragment.data());

      decltype(Traits::payment_entities_logos(input)) in_payment_entities_logos = Traits::payment_entities_logos(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->payment_entities_logos)::BaseType>
          payment_entities_logos_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& payment_entities_logos_validate_params =
          mojo::internal::GetArrayValidator<0, false, nullptr>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<::blink::mojom::ShownPaymentEntityLogoDataView>, send_validation>(
        in_payment_entities_logos,
        payment_entities_logos_fragment,
        &payment_entities_logos_validate_params);

      fragment->payment_entities_logos.Set(
          payment_entities_logos_fragment.is_null() ? nullptr : payment_entities_logos_fragment.data());

      decltype(Traits::browser_bound_public_key(input)) in_browser_bound_public_key = Traits::browser_bound_public_key(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->browser_bound_public_key)::BaseType>
          browser_bound_public_key_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& browser_bound_public_key_validate_params =
          mojo::internal::GetArrayValidator<0, false, nullptr>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<uint8_t>, send_validation>(
        in_browser_bound_public_key,
        browser_bound_public_key_fragment,
        &browser_bound_public_key_validate_params);

      fragment->browser_bound_public_key.Set(
          browser_bound_public_key_fragment.is_null() ? nullptr : browser_bound_public_key_fragment.data());
  }
};

template <typename MaybeConstUserType, mojo::internal::SendValidation send_validation>
struct SendValidationSerializer<::blink::mojom::PaymentCredentialInstrumentDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::blink::mojom::PaymentCredentialInstrumentDataView, UserType>;
  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::blink::mojom::internal::PaymentCredentialInstrument_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

      decltype(Traits::display_name(input)) in_display_name = Traits::display_name(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->display_name)::BaseType> display_name_fragment(
              fragment.message());
      
      mojo::internal::Serialize<mojo::StringDataView, send_validation>(
        in_display_name,
        display_name_fragment);

      fragment->display_name.Set(
          display_name_fragment.is_null() ? nullptr : display_name_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->display_name.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null display_name in PaymentCredentialInstrument struct");

      decltype(Traits::icon(input)) in_icon = Traits::icon(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->icon)::BaseType> icon_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::url::mojom::UrlDataView, send_validation>(
        in_icon,
        icon_fragment);

      fragment->icon.Set(
          icon_fragment.is_null() ? nullptr : icon_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->icon.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null icon in PaymentCredentialInstrument struct");

      fragment->iconMustBeShown = Traits::iconMustBeShown(input);

      decltype(Traits::details(input)) in_details = Traits::details(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->details)::BaseType> details_fragment(
              fragment.message());
      
      mojo::internal::Serialize<mojo::StringDataView, send_validation>(
        in_details,
        details_fragment);

      fragment->details.Set(
          details_fragment.is_null() ? nullptr : details_fragment.data());
  }
};

template <typename MaybeConstUserType, mojo::internal::SendValidation send_validation>
struct SendValidationSerializer<::blink::mojom::ShownPaymentEntityLogoDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::blink::mojom::ShownPaymentEntityLogoDataView, UserType>;
  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::blink::mojom::internal::ShownPaymentEntityLogo_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

      decltype(Traits::url(input)) in_url = Traits::url(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->url)::BaseType> url_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::url::mojom::UrlDataView, send_validation>(
        in_url,
        url_fragment);

      fragment->url.Set(
          url_fragment.is_null() ? nullptr : url_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->url.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null url in ShownPaymentEntityLogo struct");

      decltype(Traits::label(input)) in_label = Traits::label(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->label)::BaseType> label_fragment(
              fragment.message());
      
      mojo::internal::Serialize<mojo::StringDataView, send_validation>(
        in_label,
        label_fragment);

      fragment->label.Set(
          label_fragment.is_null() ? nullptr : label_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->label.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null label in ShownPaymentEntityLogo struct");
  }
};

template <typename MaybeConstUserType, mojo::internal::SendValidation send_validation>
struct SendValidationSerializer<::blink::mojom::RemoteDesktopClientOverrideDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::blink::mojom::RemoteDesktopClientOverrideDataView, UserType>;
  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::blink::mojom::internal::RemoteDesktopClientOverride_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

      decltype(Traits::origin(input)) in_origin = Traits::origin(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->origin)::BaseType> origin_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::url::mojom::OriginDataView, send_validation>(
        in_origin,
        origin_fragment);

      fragment->origin.Set(
          origin_fragment.is_null() ? nullptr : origin_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->origin.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null origin in RemoteDesktopClientOverride struct");

      fragment->same_origin_with_ancestors = Traits::same_origin_with_ancestors(input);
  }
};

template <typename MaybeConstUserType, mojo::internal::SendValidation send_validation>
struct SendValidationSerializer<::blink::mojom::PublicKeyCredentialRequestOptionsDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::blink::mojom::PublicKeyCredentialRequestOptionsDataView, UserType>;
  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::blink::mojom::internal::PublicKeyCredentialRequestOptions_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

      decltype(Traits::challenge(input)) in_challenge = Traits::challenge(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->challenge)::BaseType>
          challenge_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& challenge_validate_params =
          mojo::internal::GetArrayValidator<0, false, nullptr>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<uint8_t>, send_validation>(
        in_challenge,
        challenge_fragment,
        &challenge_validate_params);

      fragment->challenge.Set(
          challenge_fragment.is_null() ? nullptr : challenge_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->challenge.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null challenge in PublicKeyCredentialRequestOptions struct");

      decltype(Traits::timeout(input)) in_timeout = Traits::timeout(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->timeout)::BaseType> timeout_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::mojo_base::mojom::TimeDeltaDataView, send_validation>(
        in_timeout,
        timeout_fragment);

      fragment->timeout.Set(
          timeout_fragment.is_null() ? nullptr : timeout_fragment.data());

      decltype(Traits::relying_party_id(input)) in_relying_party_id = Traits::relying_party_id(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->relying_party_id)::BaseType> relying_party_id_fragment(
              fragment.message());
      
      mojo::internal::Serialize<mojo::StringDataView, send_validation>(
        in_relying_party_id,
        relying_party_id_fragment);

      fragment->relying_party_id.Set(
          relying_party_id_fragment.is_null() ? nullptr : relying_party_id_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->relying_party_id.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null relying_party_id in PublicKeyCredentialRequestOptions struct");

      decltype(Traits::allow_credentials(input)) in_allow_credentials = Traits::allow_credentials(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->allow_credentials)::BaseType>
          allow_credentials_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& allow_credentials_validate_params =
          mojo::internal::GetArrayValidator<0, false, nullptr>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<::blink::mojom::PublicKeyCredentialDescriptorDataView>, send_validation>(
        in_allow_credentials,
        allow_credentials_fragment,
        &allow_credentials_validate_params);

      fragment->allow_credentials.Set(
          allow_credentials_fragment.is_null() ? nullptr : allow_credentials_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->allow_credentials.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null allow_credentials in PublicKeyCredentialRequestOptions struct");

      decltype(Traits::hints(input)) in_hints = Traits::hints(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->hints)::BaseType>
          hints_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& hints_validate_params =
          mojo::internal::GetArrayOfEnumsValidator<0, false, ::blink::mojom::internal::Hint_Data::Validate>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<::blink::mojom::Hint>, send_validation>(
        in_hints,
        hints_fragment,
        &hints_validate_params);

      fragment->hints.Set(
          hints_fragment.is_null() ? nullptr : hints_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->hints.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null hints in PublicKeyCredentialRequestOptions struct");

      
      mojo::internal::Serialize<::blink::mojom::UserVerificationRequirement>(
        Traits::user_verification(input),
        &fragment->user_verification);

      decltype(Traits::extensions(input)) in_extensions = Traits::extensions(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->extensions)::BaseType> extensions_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::blink::mojom::AuthenticationExtensionsClientInputsDataView, send_validation>(
        in_extensions,
        extensions_fragment);

      fragment->extensions.Set(
          extensions_fragment.is_null() ? nullptr : extensions_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->extensions.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null extensions in PublicKeyCredentialRequestOptions struct");
  }
};

template <typename MaybeConstUserType, mojo::internal::SendValidation send_validation>
struct SendValidationSerializer<::blink::mojom::AuthenticationExtensionsClientInputsDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::blink::mojom::AuthenticationExtensionsClientInputsDataView, UserType>;
  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::blink::mojom::internal::AuthenticationExtensionsClientInputs_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

      decltype(Traits::appid(input)) in_appid = Traits::appid(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->appid)::BaseType> appid_fragment(
              fragment.message());
      
      mojo::internal::Serialize<mojo::StringDataView, send_validation>(
        in_appid,
        appid_fragment);

      fragment->appid.Set(
          appid_fragment.is_null() ? nullptr : appid_fragment.data());

      fragment->user_verification_methods = Traits::user_verification_methods(input);

      fragment->prf = Traits::prf(input);

      decltype(Traits::prf_inputs(input)) in_prf_inputs = Traits::prf_inputs(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->prf_inputs)::BaseType>
          prf_inputs_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& prf_inputs_validate_params =
          mojo::internal::GetArrayValidator<0, false, nullptr>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<::blink::mojom::PRFValuesDataView>, send_validation>(
        in_prf_inputs,
        prf_inputs_fragment,
        &prf_inputs_validate_params);

      fragment->prf_inputs.Set(
          prf_inputs_fragment.is_null() ? nullptr : prf_inputs_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->prf_inputs.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null prf_inputs in AuthenticationExtensionsClientInputs struct");

      fragment->large_blob_read = Traits::large_blob_read(input);

      decltype(Traits::large_blob_write(input)) in_large_blob_write = Traits::large_blob_write(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->large_blob_write)::BaseType>
          large_blob_write_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& large_blob_write_validate_params =
          mojo::internal::GetArrayValidator<0, false, nullptr>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<uint8_t>, send_validation>(
        in_large_blob_write,
        large_blob_write_fragment,
        &large_blob_write_validate_params);

      fragment->large_blob_write.Set(
          large_blob_write_fragment.is_null() ? nullptr : large_blob_write_fragment.data());

      fragment->get_cred_blob = Traits::get_cred_blob(input);

      decltype(Traits::remote_desktop_client_override(input)) in_remote_desktop_client_override = Traits::remote_desktop_client_override(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->remote_desktop_client_override)::BaseType> remote_desktop_client_override_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::blink::mojom::RemoteDesktopClientOverrideDataView, send_validation>(
        in_remote_desktop_client_override,
        remote_desktop_client_override_fragment);

      fragment->remote_desktop_client_override.Set(
          remote_desktop_client_override_fragment.is_null() ? nullptr : remote_desktop_client_override_fragment.data());

      decltype(Traits::remote_client_data_json(input)) in_remote_client_data_json = Traits::remote_client_data_json(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->remote_client_data_json)::BaseType> remote_client_data_json_fragment(
              fragment.message());
      
      mojo::internal::Serialize<mojo::StringDataView, send_validation>(
        in_remote_client_data_json,
        remote_client_data_json_fragment);

      fragment->remote_client_data_json.Set(
          remote_client_data_json_fragment.is_null() ? nullptr : remote_client_data_json_fragment.data());

      decltype(Traits::payment_browser_bound_key_parameters(input)) in_payment_browser_bound_key_parameters = Traits::payment_browser_bound_key_parameters(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->payment_browser_bound_key_parameters)::BaseType>
          payment_browser_bound_key_parameters_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& payment_browser_bound_key_parameters_validate_params =
          mojo::internal::GetArrayValidator<0, false, nullptr>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<::blink::mojom::PublicKeyCredentialParametersDataView>, send_validation>(
        in_payment_browser_bound_key_parameters,
        payment_browser_bound_key_parameters_fragment,
        &payment_browser_bound_key_parameters_validate_params);

      fragment->payment_browser_bound_key_parameters.Set(
          payment_browser_bound_key_parameters_fragment.is_null() ? nullptr : payment_browser_bound_key_parameters_fragment.data());

      fragment->cmtg_key = Traits::cmtg_key(input);

      decltype(Traits::cross_device_fallback_url(input)) in_cross_device_fallback_url = Traits::cross_device_fallback_url(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->cross_device_fallback_url)::BaseType> cross_device_fallback_url_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::url::mojom::UrlDataView, send_validation>(
        in_cross_device_fallback_url,
        cross_device_fallback_url_fragment);

      fragment->cross_device_fallback_url.Set(
          cross_device_fallback_url_fragment.is_null() ? nullptr : cross_device_fallback_url_fragment.data());
  }
};

template <typename MaybeConstUserType, mojo::internal::SendValidation send_validation>
struct SendValidationSerializer<::blink::mojom::GetCredentialOptionsDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::blink::mojom::GetCredentialOptionsDataView, UserType>;
  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::blink::mojom::internal::GetCredentialOptions_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

      
      mojo::internal::Serialize<::blink::mojom::Mediation>(
        Traits::mediation(input),
        &fragment->mediation);

      decltype(Traits::public_key(input)) in_public_key = Traits::public_key(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->public_key)::BaseType> public_key_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::blink::mojom::PublicKeyCredentialRequestOptionsDataView, send_validation>(
        in_public_key,
        public_key_fragment);

      fragment->public_key.Set(
          public_key_fragment.is_null() ? nullptr : public_key_fragment.data());

      fragment->password = Traits::password(input);
  }
};

template <typename MaybeConstUserType, mojo::internal::SendValidation send_validation>
struct SendValidationSerializer<::blink::mojom::AuthenticatorSelectionCriteriaDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::blink::mojom::AuthenticatorSelectionCriteriaDataView, UserType>;
  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::blink::mojom::internal::AuthenticatorSelectionCriteria_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

      
      mojo::internal::Serialize<::blink::mojom::AuthenticatorAttachment>(
        Traits::authenticator_attachment(input),
        &fragment->authenticator_attachment);

      
      mojo::internal::Serialize<::blink::mojom::ResidentKeyRequirement>(
        Traits::resident_key(input),
        &fragment->resident_key);

      
      mojo::internal::Serialize<::blink::mojom::UserVerificationRequirement>(
        Traits::user_verification(input),
        &fragment->user_verification);
  }
};

template <typename MaybeConstUserType, mojo::internal::SendValidation send_validation>
struct SendValidationSerializer<::blink::mojom::PublicKeyCredentialCreationOptionsDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::blink::mojom::PublicKeyCredentialCreationOptionsDataView, UserType>;
  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::blink::mojom::internal::PublicKeyCredentialCreationOptions_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

      decltype(Traits::relying_party(input)) in_relying_party = Traits::relying_party(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->relying_party)::BaseType> relying_party_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::blink::mojom::PublicKeyCredentialRpEntityDataView, send_validation>(
        in_relying_party,
        relying_party_fragment);

      fragment->relying_party.Set(
          relying_party_fragment.is_null() ? nullptr : relying_party_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->relying_party.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null relying_party in PublicKeyCredentialCreationOptions struct");

      decltype(Traits::user(input)) in_user = Traits::user(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->user)::BaseType> user_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::blink::mojom::PublicKeyCredentialUserEntityDataView, send_validation>(
        in_user,
        user_fragment);

      fragment->user.Set(
          user_fragment.is_null() ? nullptr : user_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->user.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null user in PublicKeyCredentialCreationOptions struct");

      decltype(Traits::challenge(input)) in_challenge = Traits::challenge(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->challenge)::BaseType>
          challenge_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& challenge_validate_params =
          mojo::internal::GetArrayValidator<0, false, nullptr>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<uint8_t>, send_validation>(
        in_challenge,
        challenge_fragment,
        &challenge_validate_params);

      fragment->challenge.Set(
          challenge_fragment.is_null() ? nullptr : challenge_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->challenge.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null challenge in PublicKeyCredentialCreationOptions struct");

      decltype(Traits::public_key_parameters(input)) in_public_key_parameters = Traits::public_key_parameters(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->public_key_parameters)::BaseType>
          public_key_parameters_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& public_key_parameters_validate_params =
          mojo::internal::GetArrayValidator<0, false, nullptr>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<::blink::mojom::PublicKeyCredentialParametersDataView>, send_validation>(
        in_public_key_parameters,
        public_key_parameters_fragment,
        &public_key_parameters_validate_params);

      fragment->public_key_parameters.Set(
          public_key_parameters_fragment.is_null() ? nullptr : public_key_parameters_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->public_key_parameters.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null public_key_parameters in PublicKeyCredentialCreationOptions struct");

      decltype(Traits::timeout(input)) in_timeout = Traits::timeout(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->timeout)::BaseType> timeout_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::mojo_base::mojom::TimeDeltaDataView, send_validation>(
        in_timeout,
        timeout_fragment);

      fragment->timeout.Set(
          timeout_fragment.is_null() ? nullptr : timeout_fragment.data());

      decltype(Traits::exclude_credentials(input)) in_exclude_credentials = Traits::exclude_credentials(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->exclude_credentials)::BaseType>
          exclude_credentials_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& exclude_credentials_validate_params =
          mojo::internal::GetArrayValidator<0, false, nullptr>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<::blink::mojom::PublicKeyCredentialDescriptorDataView>, send_validation>(
        in_exclude_credentials,
        exclude_credentials_fragment,
        &exclude_credentials_validate_params);

      fragment->exclude_credentials.Set(
          exclude_credentials_fragment.is_null() ? nullptr : exclude_credentials_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->exclude_credentials.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null exclude_credentials in PublicKeyCredentialCreationOptions struct");

      decltype(Traits::authenticator_selection(input)) in_authenticator_selection = Traits::authenticator_selection(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->authenticator_selection)::BaseType> authenticator_selection_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::blink::mojom::AuthenticatorSelectionCriteriaDataView, send_validation>(
        in_authenticator_selection,
        authenticator_selection_fragment);

      fragment->authenticator_selection.Set(
          authenticator_selection_fragment.is_null() ? nullptr : authenticator_selection_fragment.data());

      decltype(Traits::hints(input)) in_hints = Traits::hints(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->hints)::BaseType>
          hints_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& hints_validate_params =
          mojo::internal::GetArrayOfEnumsValidator<0, false, ::blink::mojom::internal::Hint_Data::Validate>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<::blink::mojom::Hint>, send_validation>(
        in_hints,
        hints_fragment,
        &hints_validate_params);

      fragment->hints.Set(
          hints_fragment.is_null() ? nullptr : hints_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->hints.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null hints in PublicKeyCredentialCreationOptions struct");

      
      mojo::internal::Serialize<::blink::mojom::AttestationConveyancePreference>(
        Traits::attestation(input),
        &fragment->attestation);

      fragment->hmac_create_secret = Traits::hmac_create_secret(input);

      fragment->prf_enable = Traits::prf_enable(input);

      decltype(Traits::prf_input(input)) in_prf_input = Traits::prf_input(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->prf_input)::BaseType> prf_input_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::blink::mojom::PRFValuesDataView, send_validation>(
        in_prf_input,
        prf_input_fragment);

      fragment->prf_input.Set(
          prf_input_fragment.is_null() ? nullptr : prf_input_fragment.data());

      
      mojo::internal::Serialize<::blink::mojom::ProtectionPolicy>(
        Traits::protection_policy(input),
        &fragment->protection_policy);

      fragment->enforce_protection_policy = Traits::enforce_protection_policy(input);

      decltype(Traits::appid_exclude(input)) in_appid_exclude = Traits::appid_exclude(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->appid_exclude)::BaseType> appid_exclude_fragment(
              fragment.message());
      
      mojo::internal::Serialize<mojo::StringDataView, send_validation>(
        in_appid_exclude,
        appid_exclude_fragment);

      fragment->appid_exclude.Set(
          appid_exclude_fragment.is_null() ? nullptr : appid_exclude_fragment.data());

      fragment->cred_props = Traits::cred_props(input);

      
      mojo::internal::Serialize<::blink::mojom::LargeBlobSupport>(
        Traits::large_blob_enable(input),
        &fragment->large_blob_enable);

      fragment->is_payment_credential_creation = Traits::is_payment_credential_creation(input);

      decltype(Traits::cred_blob(input)) in_cred_blob = Traits::cred_blob(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->cred_blob)::BaseType>
          cred_blob_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& cred_blob_validate_params =
          mojo::internal::GetArrayValidator<0, false, nullptr>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<uint8_t>, send_validation>(
        in_cred_blob,
        cred_blob_fragment,
        &cred_blob_validate_params);

      fragment->cred_blob.Set(
          cred_blob_fragment.is_null() ? nullptr : cred_blob_fragment.data());

      fragment->min_pin_length_requested = Traits::min_pin_length_requested(input);

      decltype(Traits::remote_desktop_client_override(input)) in_remote_desktop_client_override = Traits::remote_desktop_client_override(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->remote_desktop_client_override)::BaseType> remote_desktop_client_override_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::blink::mojom::RemoteDesktopClientOverrideDataView, send_validation>(
        in_remote_desktop_client_override,
        remote_desktop_client_override_fragment);

      fragment->remote_desktop_client_override.Set(
          remote_desktop_client_override_fragment.is_null() ? nullptr : remote_desktop_client_override_fragment.data());

      decltype(Traits::remote_client_data_json(input)) in_remote_client_data_json = Traits::remote_client_data_json(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->remote_client_data_json)::BaseType> remote_client_data_json_fragment(
              fragment.message());
      
      mojo::internal::Serialize<mojo::StringDataView, send_validation>(
        in_remote_client_data_json,
        remote_client_data_json_fragment);

      fragment->remote_client_data_json.Set(
          remote_client_data_json_fragment.is_null() ? nullptr : remote_client_data_json_fragment.data());

      decltype(Traits::payment_browser_bound_key_parameters(input)) in_payment_browser_bound_key_parameters = Traits::payment_browser_bound_key_parameters(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->payment_browser_bound_key_parameters)::BaseType>
          payment_browser_bound_key_parameters_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& payment_browser_bound_key_parameters_validate_params =
          mojo::internal::GetArrayValidator<0, false, nullptr>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<::blink::mojom::PublicKeyCredentialParametersDataView>, send_validation>(
        in_payment_browser_bound_key_parameters,
        payment_browser_bound_key_parameters_fragment,
        &payment_browser_bound_key_parameters_validate_params);

      fragment->payment_browser_bound_key_parameters.Set(
          payment_browser_bound_key_parameters_fragment.is_null() ? nullptr : payment_browser_bound_key_parameters_fragment.data());

      decltype(Traits::attestation_formats(input)) in_attestation_formats = Traits::attestation_formats(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->attestation_formats)::BaseType>
          attestation_formats_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& attestation_formats_validate_params =
          mojo::internal::GetArrayValidator<0, false, &mojo::internal::GetArrayValidator<0, false, nullptr>()>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<mojo::StringDataView>, send_validation>(
        in_attestation_formats,
        attestation_formats_fragment,
        &attestation_formats_validate_params);

      fragment->attestation_formats.Set(
          attestation_formats_fragment.is_null() ? nullptr : attestation_formats_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->attestation_formats.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null attestation_formats in PublicKeyCredentialCreationOptions struct");

      fragment->is_conditional = Traits::is_conditional(input);

      fragment->cmtg_key = Traits::cmtg_key(input);
  }
};

template <typename MaybeConstUserType, mojo::internal::SendValidation send_validation>
struct SendValidationSerializer<::blink::mojom::PublicKeyCredentialDescriptorDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::blink::mojom::PublicKeyCredentialDescriptorDataView, UserType>;
  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::blink::mojom::internal::PublicKeyCredentialDescriptor_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

      
      mojo::internal::Serialize<::blink::mojom::PublicKeyCredentialType>(
        Traits::type(input),
        &fragment->type);

      decltype(Traits::id(input)) in_id = Traits::id(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->id)::BaseType>
          id_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& id_validate_params =
          mojo::internal::GetArrayValidator<0, false, nullptr>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<uint8_t>, send_validation>(
        in_id,
        id_fragment,
        &id_validate_params);

      fragment->id.Set(
          id_fragment.is_null() ? nullptr : id_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->id.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null id in PublicKeyCredentialDescriptor struct");

      decltype(Traits::transports(input)) in_transports = Traits::transports(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->transports)::BaseType>
          transports_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& transports_validate_params =
          mojo::internal::GetArrayOfEnumsValidator<0, false, ::blink::mojom::internal::AuthenticatorTransport_Data::Validate>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<::blink::mojom::AuthenticatorTransport>, send_validation>(
        in_transports,
        transports_fragment,
        &transports_validate_params);

      fragment->transports.Set(
          transports_fragment.is_null() ? nullptr : transports_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->transports.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null transports in PublicKeyCredentialDescriptor struct");
  }
};

template <typename MaybeConstUserType, mojo::internal::SendValidation send_validation>
struct SendValidationSerializer<::blink::mojom::WebAuthnDOMExceptionDetailsDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::blink::mojom::WebAuthnDOMExceptionDetailsDataView, UserType>;
  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::blink::mojom::internal::WebAuthnDOMExceptionDetails_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

      decltype(Traits::name(input)) in_name = Traits::name(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->name)::BaseType> name_fragment(
              fragment.message());
      
      mojo::internal::Serialize<mojo::StringDataView, send_validation>(
        in_name,
        name_fragment);

      fragment->name.Set(
          name_fragment.is_null() ? nullptr : name_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->name.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null name in WebAuthnDOMExceptionDetails struct");

      decltype(Traits::message(input)) in_message = Traits::message(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->message)::BaseType> message_fragment(
              fragment.message());
      
      mojo::internal::Serialize<mojo::StringDataView, send_validation>(
        in_message,
        message_fragment);

      fragment->message.Set(
          message_fragment.is_null() ? nullptr : message_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->message.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null message in WebAuthnDOMExceptionDetails struct");
  }
};

template <typename MaybeConstUserType, mojo::internal::SendValidation send_validation>
struct SendValidationSerializer<::blink::mojom::PublicKeyCredentialReportOptionsDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::blink::mojom::PublicKeyCredentialReportOptionsDataView, UserType>;
  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::blink::mojom::internal::PublicKeyCredentialReportOptions_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

      decltype(Traits::relying_party_id(input)) in_relying_party_id = Traits::relying_party_id(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->relying_party_id)::BaseType> relying_party_id_fragment(
              fragment.message());
      
      mojo::internal::Serialize<mojo::StringDataView, send_validation>(
        in_relying_party_id,
        relying_party_id_fragment);

      fragment->relying_party_id.Set(
          relying_party_id_fragment.is_null() ? nullptr : relying_party_id_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->relying_party_id.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null relying_party_id in PublicKeyCredentialReportOptions struct");

      decltype(Traits::unknown_credential_id(input)) in_unknown_credential_id = Traits::unknown_credential_id(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->unknown_credential_id)::BaseType>
          unknown_credential_id_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& unknown_credential_id_validate_params =
          mojo::internal::GetArrayValidator<0, false, nullptr>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<uint8_t>, send_validation>(
        in_unknown_credential_id,
        unknown_credential_id_fragment,
        &unknown_credential_id_validate_params);

      fragment->unknown_credential_id.Set(
          unknown_credential_id_fragment.is_null() ? nullptr : unknown_credential_id_fragment.data());

      decltype(Traits::all_accepted_credentials(input)) in_all_accepted_credentials = Traits::all_accepted_credentials(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->all_accepted_credentials)::BaseType> all_accepted_credentials_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::blink::mojom::AllAcceptedCredentialsOptionsDataView, send_validation>(
        in_all_accepted_credentials,
        all_accepted_credentials_fragment);

      fragment->all_accepted_credentials.Set(
          all_accepted_credentials_fragment.is_null() ? nullptr : all_accepted_credentials_fragment.data());

      decltype(Traits::current_user_details(input)) in_current_user_details = Traits::current_user_details(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->current_user_details)::BaseType> current_user_details_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::blink::mojom::CurrentUserDetailsOptionsDataView, send_validation>(
        in_current_user_details,
        current_user_details_fragment);

      fragment->current_user_details.Set(
          current_user_details_fragment.is_null() ? nullptr : current_user_details_fragment.data());
  }
};

template <typename MaybeConstUserType, mojo::internal::SendValidation send_validation>
struct SendValidationSerializer<::blink::mojom::AllAcceptedCredentialsOptionsDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::blink::mojom::AllAcceptedCredentialsOptionsDataView, UserType>;
  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::blink::mojom::internal::AllAcceptedCredentialsOptions_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

      decltype(Traits::user_id(input)) in_user_id = Traits::user_id(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->user_id)::BaseType>
          user_id_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& user_id_validate_params =
          mojo::internal::GetArrayValidator<0, false, nullptr>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<uint8_t>, send_validation>(
        in_user_id,
        user_id_fragment,
        &user_id_validate_params);

      fragment->user_id.Set(
          user_id_fragment.is_null() ? nullptr : user_id_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->user_id.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null user_id in AllAcceptedCredentialsOptions struct");

      decltype(Traits::all_accepted_credentials_ids(input)) in_all_accepted_credentials_ids = Traits::all_accepted_credentials_ids(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->all_accepted_credentials_ids)::BaseType>
          all_accepted_credentials_ids_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& all_accepted_credentials_ids_validate_params =
          mojo::internal::GetArrayValidator<0, false, &mojo::internal::GetArrayValidator<0, false, nullptr>()>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<mojo::ArrayDataView<uint8_t>>, send_validation>(
        in_all_accepted_credentials_ids,
        all_accepted_credentials_ids_fragment,
        &all_accepted_credentials_ids_validate_params);

      fragment->all_accepted_credentials_ids.Set(
          all_accepted_credentials_ids_fragment.is_null() ? nullptr : all_accepted_credentials_ids_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->all_accepted_credentials_ids.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null all_accepted_credentials_ids in AllAcceptedCredentialsOptions struct");
  }
};

template <typename MaybeConstUserType, mojo::internal::SendValidation send_validation>
struct SendValidationSerializer<::blink::mojom::CurrentUserDetailsOptionsDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::blink::mojom::CurrentUserDetailsOptionsDataView, UserType>;
  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::blink::mojom::internal::CurrentUserDetailsOptions_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

      decltype(Traits::user_id(input)) in_user_id = Traits::user_id(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->user_id)::BaseType>
          user_id_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& user_id_validate_params =
          mojo::internal::GetArrayValidator<0, false, nullptr>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<uint8_t>, send_validation>(
        in_user_id,
        user_id_fragment,
        &user_id_validate_params);

      fragment->user_id.Set(
          user_id_fragment.is_null() ? nullptr : user_id_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->user_id.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null user_id in CurrentUserDetailsOptions struct");

      decltype(Traits::name(input)) in_name = Traits::name(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->name)::BaseType> name_fragment(
              fragment.message());
      
      mojo::internal::Serialize<mojo::StringDataView, send_validation>(
        in_name,
        name_fragment);

      fragment->name.Set(
          name_fragment.is_null() ? nullptr : name_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->name.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null name in CurrentUserDetailsOptions struct");

      decltype(Traits::display_name(input)) in_display_name = Traits::display_name(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->display_name)::BaseType> display_name_fragment(
              fragment.message());
      
      mojo::internal::Serialize<mojo::StringDataView, send_validation>(
        in_display_name,
        display_name_fragment);

      fragment->display_name.Set(
          display_name_fragment.is_null() ? nullptr : display_name_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->display_name.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null display_name in CurrentUserDetailsOptions struct");
  }
};

template <typename MaybeConstUserType, mojo::internal::SendValidation send_validation>
struct SendValidationSerializer<::blink::mojom::WebAuthnClientCapabilityDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::blink::mojom::WebAuthnClientCapabilityDataView, UserType>;
  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::blink::mojom::internal::WebAuthnClientCapability_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

      decltype(Traits::name(input)) in_name = Traits::name(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->name)::BaseType> name_fragment(
              fragment.message());
      
      mojo::internal::Serialize<mojo::StringDataView, send_validation>(
        in_name,
        name_fragment);

      fragment->name.Set(
          name_fragment.is_null() ? nullptr : name_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->name.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null name in WebAuthnClientCapability struct");

      fragment->supported = Traits::supported(input);
  }
};

template <typename MaybeConstUserType, mojo::internal::SendValidation send_validation>
struct SendValidationSerializer<::blink::mojom::GetAssertionResponseDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::blink::mojom::GetAssertionResponseDataView, UserType>;
  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::blink::mojom::internal::GetAssertionResponse_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

      
      mojo::internal::Serialize<::blink::mojom::AuthenticatorStatus>(
        Traits::status(input),
        &fragment->status);

      decltype(Traits::credential(input)) in_credential = Traits::credential(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->credential)::BaseType> credential_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::blink::mojom::GetAssertionAuthenticatorResponseDataView, send_validation>(
        in_credential,
        credential_fragment);

      fragment->credential.Set(
          credential_fragment.is_null() ? nullptr : credential_fragment.data());

      decltype(Traits::dom_exception_details(input)) in_dom_exception_details = Traits::dom_exception_details(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->dom_exception_details)::BaseType> dom_exception_details_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::blink::mojom::WebAuthnDOMExceptionDetailsDataView, send_validation>(
        in_dom_exception_details,
        dom_exception_details_fragment);

      fragment->dom_exception_details.Set(
          dom_exception_details_fragment.is_null() ? nullptr : dom_exception_details_fragment.data());
  }
};
template <typename MaybeConstUserType, SendValidation send_validation>
struct SendValidationSerializer<::blink::mojom::GetCredentialResponseDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = UnionTraits<::blink::mojom::GetCredentialResponseDataView, UserType>;
  static void Serialize(MaybeConstUserType& input,
                        MessageFragment<::blink::mojom::internal::GetCredentialResponse_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 ::blink::mojom::GetCredentialResponseDataView::Tag::kGetAssertionResponse: {
    decltype(Traits::get_assertion_response(input))
    in_get_assertion_response = Traits::get_assertion_response(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_get_assertion_response)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<::blink::mojom::GetAssertionResponseDataView, send_validation>(
  in_get_assertion_response,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  send_validation,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null get_assertion_response in GetCredentialResponse union");
    fragment->data.f_get_assertion_response.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
  case ::blink::mojom::GetCredentialResponseDataView::Tag::kPasswordResponse: {
    decltype(Traits::password_response(input))
    in_password_response = Traits::password_response(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_password_response)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<::blink::mojom::CredentialInfoDataView, send_validation>(
  in_password_response,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  send_validation,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null password_response in GetCredentialResponse union");
    fragment->data.f_password_response.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
}
  }
};

}  // namespace mojo::internal

#endif  // THIRD_PARTY_BLINK_PUBLIC_MOJOM_WEBAUTHN_AUTHENTICATOR_MOJOM_SEND_VALIDATION_H_