// components/enterprise/connectors/connectors_internals.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 COMPONENTS_ENTERPRISE_CONNECTORS_CONNECTORS_INTERNALS_MOJOM_SEND_VALIDATION_H_
#define COMPONENTS_ENTERPRISE_CONNECTORS_CONNECTORS_INTERNALS_MOJOM_SEND_VALIDATION_H_

#include "components/enterprise/connectors/connectors_internals.mojom-shared-internal.h"
#include "mojo/public/mojom/base/time.mojom-shared.h"

#include "components/enterprise/connectors/connectors_internals.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<::connectors_internals::mojom::KeyManagerInitializedValue, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::connectors_internals::mojom::KeyTrustLevel, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::connectors_internals::mojom::KeyType, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::connectors_internals::mojom::KeyManagerPermanentFailure, MaybeConstUserType>
    : std::false_type {};

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

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

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

      
      mojo::internal::Serialize<::connectors_internals::mojom::KeyTrustLevel>(
        Traits::trust_level(input),
        &fragment->trust_level);

      
      mojo::internal::Serialize<::connectors_internals::mojom::KeyType>(
        Traits::key_type(input),
        &fragment->key_type);

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

      fragment->encoded_spki_hash.Set(
          encoded_spki_hash_fragment.is_null() ? nullptr : encoded_spki_hash_fragment.data());

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

      decltype(Traits::key_upload_status(input)) in_key_upload_status = Traits::key_upload_status(input);
      mojo::internal::MessageFragment<decltype(fragment->key_upload_status)>
          key_upload_status_fragment(fragment.message());
      key_upload_status_fragment.Claim(&fragment->key_upload_status);
      
      mojo::internal::Serialize<::connectors_internals::mojom::KeyUploadStatusDataView, send_validation>(
        in_key_upload_status,
        key_upload_status_fragment,
        true);

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

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

      
      mojo::internal::Serialize<::connectors_internals::mojom::KeyManagerInitializedValue>(
        Traits::is_key_manager_initialized(input),
        &fragment->is_key_manager_initialized);

      decltype(Traits::loaded_key_info(input)) in_loaded_key_info = Traits::loaded_key_info(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->loaded_key_info)::BaseType> loaded_key_info_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::connectors_internals::mojom::LoadedKeyInfoDataView, send_validation>(
        in_loaded_key_info,
        loaded_key_info_fragment);

      fragment->loaded_key_info.Set(
          loaded_key_info_fragment.is_null() ? nullptr : loaded_key_info_fragment.data());

      
      mojo::internal::Serialize<::connectors_internals::mojom::KeyManagerPermanentFailure>(
        Traits::permanent_failure(input),
        &fragment->permanent_failure);
  }
};

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

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

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

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

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

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

      fragment->policy_enabled_levels.Set(
          policy_enabled_levels_fragment.is_null() ? nullptr : policy_enabled_levels_fragment.data());

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

      decltype(Traits::key_info(input)) in_key_info = Traits::key_info(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->key_info)::BaseType> key_info_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::connectors_internals::mojom::KeyInfoDataView, send_validation>(
        in_key_info,
        key_info_fragment);

      fragment->key_info.Set(
          key_info_fragment.is_null() ? nullptr : key_info_fragment.data());

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

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

      fragment->signals_json.Set(
          signals_json_fragment.is_null() ? nullptr : signals_json_fragment.data());

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

      decltype(Traits::consent_metadata(input)) in_consent_metadata = Traits::consent_metadata(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->consent_metadata)::BaseType> consent_metadata_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::connectors_internals::mojom::ConsentMetadataDataView, send_validation>(
        in_consent_metadata,
        consent_metadata_fragment);

      fragment->consent_metadata.Set(
          consent_metadata_fragment.is_null() ? nullptr : consent_metadata_fragment.data());
  }
};

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

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

      fragment->serial_number.Set(
          serial_number_fragment.is_null() ? nullptr : serial_number_fragment.data());

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

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

      fragment->fingerprint.Set(
          fingerprint_fragment.is_null() ? nullptr : fingerprint_fragment.data());

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

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

      fragment->creation_date_string.Set(
          creation_date_string_fragment.is_null() ? nullptr : creation_date_string_fragment.data());

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

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

      fragment->expiration_date_string.Set(
          expiration_date_string_fragment.is_null() ? nullptr : expiration_date_string_fragment.data());

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

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

      fragment->subject_display_name.Set(
          subject_display_name_fragment.is_null() ? nullptr : subject_display_name_fragment.data());

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

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

      fragment->issuer_display_name.Set(
          issuer_display_name_fragment.is_null() ? nullptr : issuer_display_name_fragment.data());

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

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

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

      fragment->identity_name.Set(
          identity_name_fragment.is_null() ? nullptr : identity_name_fragment.data());

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

      decltype(Traits::loaded_key_info(input)) in_loaded_key_info = Traits::loaded_key_info(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->loaded_key_info)::BaseType> loaded_key_info_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::connectors_internals::mojom::LoadedKeyInfoDataView, send_validation>(
        in_loaded_key_info,
        loaded_key_info_fragment);

      fragment->loaded_key_info.Set(
          loaded_key_info_fragment.is_null() ? nullptr : loaded_key_info_fragment.data());

      decltype(Traits::certificate_metadata(input)) in_certificate_metadata = Traits::certificate_metadata(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->certificate_metadata)::BaseType> certificate_metadata_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::connectors_internals::mojom::CertificateMetadataDataView, send_validation>(
        in_certificate_metadata,
        certificate_metadata_fragment);

      fragment->certificate_metadata.Set(
          certificate_metadata_fragment.is_null() ? nullptr : certificate_metadata_fragment.data());
  }
};

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

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

      fragment->policy_enabled_levels.Set(
          policy_enabled_levels_fragment.is_null() ? nullptr : policy_enabled_levels_fragment.data());

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

      decltype(Traits::managed_profile_identity(input)) in_managed_profile_identity = Traits::managed_profile_identity(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->managed_profile_identity)::BaseType> managed_profile_identity_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::connectors_internals::mojom::ClientIdentityDataView, send_validation>(
        in_managed_profile_identity,
        managed_profile_identity_fragment);

      fragment->managed_profile_identity.Set(
          managed_profile_identity_fragment.is_null() ? nullptr : managed_profile_identity_fragment.data());

      decltype(Traits::managed_browser_identity(input)) in_managed_browser_identity = Traits::managed_browser_identity(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->managed_browser_identity)::BaseType> managed_browser_identity_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::connectors_internals::mojom::ClientIdentityDataView, send_validation>(
        in_managed_browser_identity,
        managed_browser_identity_fragment);

      fragment->managed_browser_identity.Set(
          managed_browser_identity_fragment.is_null() ? nullptr : managed_browser_identity_fragment.data());
  }
};

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

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

      fragment->error_info.Set(
          error_info_fragment.is_null() ? nullptr : error_info_fragment.data());

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

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

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

      fragment->last_upload_attempt_timestamp.Set(
          last_upload_attempt_timestamp_fragment.is_null() ? nullptr : last_upload_attempt_timestamp_fragment.data());

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

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

      fragment->last_upload_success_timestamp.Set(
          last_upload_success_timestamp_fragment.is_null() ? nullptr : last_upload_success_timestamp_fragment.data());

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

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

      fragment->last_signals_upload_config.Set(
          last_signals_upload_config_fragment.is_null() ? nullptr : last_signals_upload_config_fragment.data());

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

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

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

      fragment->signals_json.Set(
          signals_json_fragment.is_null() ? nullptr : signals_json_fragment.data());
  }
};

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

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

      fragment->pvd_id.Set(
          pvd_id_fragment.is_null() ? nullptr : pvd_id_fragment.data());

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

      decltype(Traits::expiration_time(input)) in_expiration_time = Traits::expiration_time(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->expiration_time)::BaseType> expiration_time_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::mojo_base::mojom::JSTimeDataView, send_validation>(
        in_expiration_time,
        expiration_time_fragment);

      fragment->expiration_time.Set(
          expiration_time_fragment.is_null() ? nullptr : expiration_time_fragment.data());

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

      fragment->routes_json.Set(
          routes_json_fragment.is_null() ? nullptr : routes_json_fragment.data());

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

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

      fragment->policy_json.Set(
          policy_json_fragment.is_null() ? nullptr : policy_json_fragment.data());

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

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

      decltype(Traits::pvd_configs(input)) in_pvd_configs = Traits::pvd_configs(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->pvd_configs)::BaseType>
          pvd_configs_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& pvd_configs_validate_params =
          mojo::internal::GetArrayValidator<0, false, nullptr>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<::connectors_internals::mojom::ProvisioningDomainConfigDataView>, send_validation>(
        in_pvd_configs,
        pvd_configs_fragment,
        &pvd_configs_validate_params);

      fragment->pvd_configs.Set(
          pvd_configs_fragment.is_null() ? nullptr : pvd_configs_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->pvd_configs.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null pvd_configs in ProvisioningDomainState struct");
  }
};
template <typename MaybeConstUserType, SendValidation send_validation>
struct SendValidationSerializer<::connectors_internals::mojom::KeyUploadStatusDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = UnionTraits<::connectors_internals::mojom::KeyUploadStatusDataView, UserType>;
  static void Serialize(MaybeConstUserType& input,
                        MessageFragment<::connectors_internals::mojom::internal::KeyUploadStatus_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 ::connectors_internals::mojom::KeyUploadStatusDataView::Tag::kSyncKeyResponseCode: {
    decltype(Traits::sync_key_response_code(input))
    in_sync_key_response_code = Traits::sync_key_response_code(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_sync_key_response_code)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<::connectors_internals::mojom::Int32ValueDataView, send_validation>(
  in_sync_key_response_code,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  send_validation,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null sync_key_response_code in KeyUploadStatus union");
    fragment->data.f_sync_key_response_code.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
  case ::connectors_internals::mojom::KeyUploadStatusDataView::Tag::kUploadClientError: {
    decltype(Traits::upload_client_error(input))
    in_upload_client_error = Traits::upload_client_error(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_upload_client_error)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<mojo::StringDataView, send_validation>(
  in_upload_client_error,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  send_validation,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null upload_client_error in KeyUploadStatus union");
    fragment->data.f_upload_client_error.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
}
  }
};

}  // namespace mojo::internal

#endif  // COMPONENTS_ENTERPRISE_CONNECTORS_CONNECTORS_INTERNALS_MOJOM_SEND_VALIDATION_H_