// services/network/public/mojom/device_bound_sessions.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 SERVICES_NETWORK_PUBLIC_MOJOM_DEVICE_BOUND_SESSIONS_MOJOM_SEND_VALIDATION_H_
#define SERVICES_NETWORK_PUBLIC_MOJOM_DEVICE_BOUND_SESSIONS_MOJOM_SEND_VALIDATION_H_

#include "services/network/public/mojom/device_bound_sessions.mojom-shared-internal.h"
#include "mojo/public/mojom/base/time.mojom-shared.h"
#include "mojo/public/mojom/base/unguessable_token.mojom-shared.h"
#include "sandbox/policy/mojom/context.mojom-shared.h"
#include "services/network/public/mojom/clear_data_filter.mojom-shared.h"
#include "services/network/public/mojom/cookie_manager.mojom-shared.h"
#include "services/network/public/mojom/schemeful_site.mojom-shared.h"
#include "url/mojom/url.mojom-shared.h"

#include "services/network/public/mojom/device_bound_sessions.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<::network::mojom::DeviceBoundSessionAccessType, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::network::mojom::DeviceBoundSessionUsage, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::network::mojom::DeviceBoundSessionDeletionReason, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::network::mojom::DeviceBoundSessionScopeSpecificationType, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::network::mojom::DeviceBoundSessionError, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::network::mojom::DeviceBoundSessionRefreshResult, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::network::mojom::DeviceBoundSessionChallengeResult, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::network::mojom::DeviceBoundSessionInclusionResult, MaybeConstUserType>
    : std::false_type {};

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

      decltype(Traits::site(input)) in_site = Traits::site(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->site)::BaseType> site_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::network::mojom::SchemefulSiteDataView, send_validation>(
        in_site,
        site_fragment);

      fragment->site.Set(
          site_fragment.is_null() ? nullptr : site_fragment.data());

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

      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 DeviceBoundSessionKey struct");
  }
};

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

      
      mojo::internal::Serialize<::network::mojom::DeviceBoundSessionAccessType>(
        Traits::access_type(input),
        &fragment->access_type);

      decltype(Traits::session_key(input)) in_session_key = Traits::session_key(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->session_key)::BaseType> session_key_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::network::mojom::DeviceBoundSessionKeyDataView, send_validation>(
        in_session_key,
        session_key_fragment);

      fragment->session_key.Set(
          session_key_fragment.is_null() ? nullptr : session_key_fragment.data());

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

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

      fragment->cookies.Set(
          cookies_fragment.is_null() ? nullptr : cookies_fragment.data());

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

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

      decltype(Traits::session_key(input)) in_session_key = Traits::session_key(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->session_key)::BaseType> session_key_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::network::mojom::DeviceBoundSessionKeyDataView, send_validation>(
        in_session_key,
        session_key_fragment);

      fragment->session_key.Set(
          session_key_fragment.is_null() ? nullptr : session_key_fragment.data());

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

      
      mojo::internal::Serialize<::network::mojom::DeviceBoundSessionUsage>(
        Traits::usage(input),
        &fragment->usage);
  }
};

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

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

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

      fragment->domain.Set(
          domain_fragment.is_null() ? nullptr : domain_fragment.data());

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

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

      fragment->path.Set(
          path_fragment.is_null() ? nullptr : path_fragment.data());

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

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

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

      decltype(Traits::specifications(input)) in_specifications = Traits::specifications(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->specifications)::BaseType>
          specifications_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& specifications_validate_params =
          mojo::internal::GetArrayValidator<0, false, nullptr>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<::network::mojom::DeviceBoundSessionScopeSpecificationDataView>, send_validation>(
        in_specifications,
        specifications_fragment,
        &specifications_validate_params);

      fragment->specifications.Set(
          specifications_fragment.is_null() ? nullptr : specifications_fragment.data());

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

      decltype(Traits::origin(input)) in_origin = Traits::origin(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->origin)::BaseType> origin_fragment(
              fragment.message());
      
      mojo::internal::Serialize<mojo::StringDataView, 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 DeviceBoundSessionScope struct");
  }
};

template <typename MaybeConstUserType, mojo::internal::SendValidation send_validation>
struct SendValidationSerializer<::network::mojom::DeviceBoundSessionCredentialDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::network::mojom::DeviceBoundSessionCredentialDataView, UserType>;
  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::network::mojom::internal::DeviceBoundSessionCredential_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 DeviceBoundSessionCredential struct");

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

      fragment->attributes.Set(
          attributes_fragment.is_null() ? nullptr : attributes_fragment.data());

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

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

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

      fragment->session_id.Set(
          session_id_fragment.is_null() ? nullptr : session_id_fragment.data());

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

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

      fragment->fetcher_url.Set(
          fetcher_url_fragment.is_null() ? nullptr : fetcher_url_fragment.data());

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

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

      fragment->refresh_url.Set(
          refresh_url_fragment.is_null() ? nullptr : refresh_url_fragment.data());

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

      decltype(Traits::scope(input)) in_scope = Traits::scope(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->scope)::BaseType> scope_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::network::mojom::DeviceBoundSessionScopeDataView, send_validation>(
        in_scope,
        scope_fragment);

      fragment->scope.Set(
          scope_fragment.is_null() ? nullptr : scope_fragment.data());

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

      decltype(Traits::credentials(input)) in_credentials = Traits::credentials(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->credentials)::BaseType>
          credentials_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& credentials_validate_params =
          mojo::internal::GetArrayValidator<0, false, nullptr>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<::network::mojom::DeviceBoundSessionCredentialDataView>, send_validation>(
        in_credentials,
        credentials_fragment,
        &credentials_validate_params);

      fragment->credentials.Set(
          credentials_fragment.is_null() ? nullptr : credentials_fragment.data());

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

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

      fragment->allowed_refresh_initiators.Set(
          allowed_refresh_initiators_fragment.is_null() ? nullptr : allowed_refresh_initiators_fragment.data());

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

template <typename MaybeConstUserType, mojo::internal::SendValidation send_validation>
struct SendValidationSerializer<::network::mojom::DeviceBoundSessionCookieCravingDisplayDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::network::mojom::DeviceBoundSessionCookieCravingDisplayDataView, UserType>;
  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::network::mojom::internal::DeviceBoundSessionCookieCravingDisplay_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 DeviceBoundSessionCookieCravingDisplay struct");

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

      fragment->domain.Set(
          domain_fragment.is_null() ? nullptr : domain_fragment.data());

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

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

      fragment->path.Set(
          path_fragment.is_null() ? nullptr : path_fragment.data());

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

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

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

      
      mojo::internal::Serialize<::network::mojom::CookieSameSite>(
        Traits::same_site(input),
        &fragment->same_site);
  }
};

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

      
      mojo::internal::Serialize<::network::mojom::DeviceBoundSessionInclusionResult>(
        Traits::rule_type(input),
        &fragment->rule_type);

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

      fragment->host_pattern.Set(
          host_pattern_fragment.is_null() ? nullptr : host_pattern_fragment.data());

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

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

      fragment->path_prefix.Set(
          path_prefix_fragment.is_null() ? nullptr : path_prefix_fragment.data());

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

template <typename MaybeConstUserType, mojo::internal::SendValidation send_validation>
struct SendValidationSerializer<::network::mojom::DeviceBoundSessionInclusionRulesDisplayDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::network::mojom::DeviceBoundSessionInclusionRulesDisplayDataView, UserType>;
  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::network::mojom::internal::DeviceBoundSessionInclusionRulesDisplay_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<mojo::StringDataView, 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 DeviceBoundSessionInclusionRulesDisplay struct");

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

      decltype(Traits::url_rules(input)) in_url_rules = Traits::url_rules(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->url_rules)::BaseType>
          url_rules_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& url_rules_validate_params =
          mojo::internal::GetArrayValidator<0, false, nullptr>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<::network::mojom::DeviceBoundSessionUrlRuleDisplayDataView>, send_validation>(
        in_url_rules,
        url_rules_fragment,
        &url_rules_validate_params);

      fragment->url_rules.Set(
          url_rules_fragment.is_null() ? nullptr : url_rules_fragment.data());

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

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

      decltype(Traits::key(input)) in_key = Traits::key(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->key)::BaseType> key_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::network::mojom::DeviceBoundSessionKeyDataView, send_validation>(
        in_key,
        key_fragment);

      fragment->key.Set(
          key_fragment.is_null() ? nullptr : key_fragment.data());

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

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

      fragment->refresh_url.Set(
          refresh_url_fragment.is_null() ? nullptr : refresh_url_fragment.data());

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

      decltype(Traits::inclusion_rules(input)) in_inclusion_rules = Traits::inclusion_rules(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->inclusion_rules)::BaseType> inclusion_rules_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::network::mojom::DeviceBoundSessionInclusionRulesDisplayDataView, send_validation>(
        in_inclusion_rules,
        inclusion_rules_fragment);

      fragment->inclusion_rules.Set(
          inclusion_rules_fragment.is_null() ? nullptr : inclusion_rules_fragment.data());

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

      decltype(Traits::cookie_cravings(input)) in_cookie_cravings = Traits::cookie_cravings(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->cookie_cravings)::BaseType>
          cookie_cravings_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& cookie_cravings_validate_params =
          mojo::internal::GetArrayValidator<0, false, nullptr>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<::network::mojom::DeviceBoundSessionCookieCravingDisplayDataView>, send_validation>(
        in_cookie_cravings,
        cookie_cravings_fragment,
        &cookie_cravings_validate_params);

      fragment->cookie_cravings.Set(
          cookie_cravings_fragment.is_null() ? nullptr : cookie_cravings_fragment.data());

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

      decltype(Traits::expiry_date(input)) in_expiry_date = Traits::expiry_date(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->expiry_date)::BaseType> expiry_date_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::mojo_base::mojom::TimeDataView, send_validation>(
        in_expiry_date,
        expiry_date_fragment);

      fragment->expiry_date.Set(
          expiry_date_fragment.is_null() ? nullptr : expiry_date_fragment.data());

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

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

      fragment->cached_challenge.Set(
          cached_challenge_fragment.is_null() ? nullptr : cached_challenge_fragment.data());

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

      fragment->allowed_refresh_initiators.Set(
          allowed_refresh_initiators_fragment.is_null() ? nullptr : allowed_refresh_initiators_fragment.data());

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

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

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

      fragment->request_url.Set(
          request_url_fragment.is_null() ? nullptr : request_url_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->request_url.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null request_url in DeviceBoundSessionFailedRequest struct");
      fragment->net_error_$flag = Traits::net_error(input).has_value();
      if (Traits::net_error(input).has_value()) {
        fragment->net_error_$value = Traits::net_error(input).value();
      }
      fragment->response_error_$flag = Traits::response_error(input).has_value();
      if (Traits::response_error(input).has_value()) {
        fragment->response_error_$value = Traits::response_error(input).value();
      }

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

      fragment->response_error_body.Set(
          response_error_body_fragment.is_null() ? nullptr : response_error_body_fragment.data());
  }
};

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

      
      mojo::internal::Serialize<::network::mojom::DeviceBoundSessionError>(
        Traits::fetch_error(input),
        &fragment->fetch_error);

      decltype(Traits::new_session_display(input)) in_new_session_display = Traits::new_session_display(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->new_session_display)::BaseType> new_session_display_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::network::mojom::DeviceBoundSessionDisplayDataView, send_validation>(
        in_new_session_display,
        new_session_display_fragment);

      fragment->new_session_display.Set(
          new_session_display_fragment.is_null() ? nullptr : new_session_display_fragment.data());

      decltype(Traits::failed_request(input)) in_failed_request = Traits::failed_request(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->failed_request)::BaseType> failed_request_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::network::mojom::DeviceBoundSessionFailedRequestDataView, send_validation>(
        in_failed_request,
        failed_request_fragment);

      fragment->failed_request.Set(
          failed_request_fragment.is_null() ? nullptr : failed_request_fragment.data());
  }
};

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

      
      mojo::internal::Serialize<::network::mojom::DeviceBoundSessionRefreshResult>(
        Traits::refresh_result(input),
        &fragment->refresh_result);
      fragment->fetch_error_$flag = Traits::fetch_error(input).has_value();
      if (Traits::fetch_error(input).has_value()) {
        
        mojo::internal::Serialize<::network::mojom::DeviceBoundSessionError>(
          Traits::fetch_error(input).value(),
          &fragment->fetch_error_$value);
      } else {
        fragment->fetch_error_$value =
            static_cast<int32_t>(::network::mojom::DeviceBoundSessionError::kMinValue);
      }

      decltype(Traits::new_session_display(input)) in_new_session_display = Traits::new_session_display(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->new_session_display)::BaseType> new_session_display_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::network::mojom::DeviceBoundSessionDisplayDataView, send_validation>(
        in_new_session_display,
        new_session_display_fragment);

      fragment->new_session_display.Set(
          new_session_display_fragment.is_null() ? nullptr : new_session_display_fragment.data());

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

      decltype(Traits::failed_request(input)) in_failed_request = Traits::failed_request(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->failed_request)::BaseType> failed_request_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::network::mojom::DeviceBoundSessionFailedRequestDataView, send_validation>(
        in_failed_request,
        failed_request_fragment);

      fragment->failed_request.Set(
          failed_request_fragment.is_null() ? nullptr : failed_request_fragment.data());
  }
};

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

      
      mojo::internal::Serialize<::network::mojom::DeviceBoundSessionDeletionReason>(
        Traits::deletion_reason(input),
        &fragment->deletion_reason);
  }
};

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

      
      mojo::internal::Serialize<::network::mojom::DeviceBoundSessionChallengeResult>(
        Traits::challenge_result(input),
        &fragment->challenge_result);

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

      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 DeviceBoundSessionChallengeDetails struct");
  }
};

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

      decltype(Traits::event_id(input)) in_event_id = Traits::event_id(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->event_id)::BaseType> event_id_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::mojo_base::mojom::UnguessableTokenDataView, send_validation>(
        in_event_id,
        event_id_fragment);

      fragment->event_id.Set(
          event_id_fragment.is_null() ? nullptr : event_id_fragment.data());

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

      decltype(Traits::site(input)) in_site = Traits::site(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->site)::BaseType> site_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::network::mojom::SchemefulSiteDataView, send_validation>(
        in_site,
        site_fragment);

      fragment->site.Set(
          site_fragment.is_null() ? nullptr : site_fragment.data());

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

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

      fragment->session_id.Set(
          session_id_fragment.is_null() ? nullptr : session_id_fragment.data());

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

      decltype(Traits::event_type_details(input)) in_event_type_details = Traits::event_type_details(input);
      mojo::internal::MessageFragment<decltype(fragment->event_type_details)>
          event_type_details_fragment(fragment.message());
      event_type_details_fragment.Claim(&fragment->event_type_details);
      
      mojo::internal::Serialize<::network::mojom::DeviceBoundSessionEventTypeDetailsDataView, send_validation>(
        in_event_type_details,
        event_type_details_fragment,
        true);

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->event_type_details.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null event_type_details in DeviceBoundSessionEvent struct");
  }
};
template <typename MaybeConstUserType, SendValidation send_validation>
struct SendValidationSerializer<::network::mojom::DeviceBoundSessionEventTypeDetailsDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = UnionTraits<::network::mojom::DeviceBoundSessionEventTypeDetailsDataView, UserType>;
  static void Serialize(MaybeConstUserType& input,
                        MessageFragment<::network::mojom::internal::DeviceBoundSessionEventTypeDetails_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 ::network::mojom::DeviceBoundSessionEventTypeDetailsDataView::Tag::kCreation: {
    decltype(Traits::creation(input))
    in_creation = Traits::creation(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_creation)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<::network::mojom::DeviceBoundSessionCreationDetailsDataView, send_validation>(
  in_creation,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  send_validation,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null creation in DeviceBoundSessionEventTypeDetails union");
    fragment->data.f_creation.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
  case ::network::mojom::DeviceBoundSessionEventTypeDetailsDataView::Tag::kRefresh: {
    decltype(Traits::refresh(input))
    in_refresh = Traits::refresh(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_refresh)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<::network::mojom::DeviceBoundSessionRefreshDetailsDataView, send_validation>(
  in_refresh,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  send_validation,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null refresh in DeviceBoundSessionEventTypeDetails union");
    fragment->data.f_refresh.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
  case ::network::mojom::DeviceBoundSessionEventTypeDetailsDataView::Tag::kTermination: {
    decltype(Traits::termination(input))
    in_termination = Traits::termination(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_termination)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<::network::mojom::DeviceBoundSessionTerminationDetailsDataView, send_validation>(
  in_termination,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  send_validation,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null termination in DeviceBoundSessionEventTypeDetails union");
    fragment->data.f_termination.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
  case ::network::mojom::DeviceBoundSessionEventTypeDetailsDataView::Tag::kChallenge: {
    decltype(Traits::challenge(input))
    in_challenge = Traits::challenge(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_challenge)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<::network::mojom::DeviceBoundSessionChallengeDetailsDataView, send_validation>(
  in_challenge,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  send_validation,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null challenge in DeviceBoundSessionEventTypeDetails union");
    fragment->data.f_challenge.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
}
  }
};

}  // namespace mojo::internal

#endif  // SERVICES_NETWORK_PUBLIC_MOJOM_DEVICE_BOUND_SESSIONS_MOJOM_SEND_VALIDATION_H_