// chrome/browser/glic/host/glic.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 CHROME_BROWSER_GLIC_HOST_GLIC_MOJOM_SEND_VALIDATION_H_
#define CHROME_BROWSER_GLIC_HOST_GLIC_MOJOM_SEND_VALIDATION_H_

#include "chrome/browser/glic/host/glic.mojom-shared-internal.h"
#include "chrome/browser/glic/host/glic_features.mojom-shared.h"
#include "chrome/common/actor_webui.mojom-shared.h"
#include "chrome/common/glic_enums.mojom-shared.h"
#include "components/content_settings/core/common/content_settings_types.mojom-shared.h"
#include "mojo/public/mojom/base/absl_status.mojom-shared.h"
#include "mojo/public/mojom/base/big_buffer.mojom-shared.h"
#include "mojo/public/mojom/base/byte_string.mojom-shared.h"
#include "mojo/public/mojom/base/proto_wrapper.mojom-shared.h"
#include "mojo/public/mojom/base/string16.mojom-shared.h"
#include "mojo/public/mojom/base/time.mojom-shared.h"
#include "mojo/public/mojom/base/unguessable_token.mojom-shared.h"
#include "mojo/public/mojom/base/values.mojom-shared.h"
#include "mojo/public/mojom/base/version.mojom-shared.h"
#include "skia/public/mojom/bitmap.mojom-shared.h"
#include "third_party/blink/public/mojom/content_extraction/ai_page_content_metadata.mojom-shared.h"
#include "ui/gfx/geometry/mojom/geometry.mojom-shared.h"
#include "url/mojom/origin.mojom-shared.h"
#include "url/mojom/url.mojom-shared.h"

#include "chrome/browser/glic/host/glic.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<::glic::mojom::GlicExperimentalTriggeringState, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::glic::mojom::FileUploadPolicyState, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::glic::mojom::ActuationEligibility, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::glic::mojom::MetricUserInputReactionType, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::glic::mojom::PerformActionsErrorReason, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::glic::mojom::CreateTaskErrorReason, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::glic::mojom::ActorTaskState, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::glic::mojom::ActorTaskPauseReason, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::glic::mojom::ActorTaskStopReason, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::glic::mojom::ActorTaskInterruptReason, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::glic::mojom::CaptureScreenshotErrorReason, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::glic::mojom::SbThreatType, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::glic::mojom::Platform, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::glic::mojom::FormFactor, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::glic::mojom::ScreenshotImageFormat, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::glic::mojom::ScreenshotCompressionQuality, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::glic::mojom::ScrollToErrorReason, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::glic::mojom::SkillSource, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::glic::mojom::SkillsWebClientEvent, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::glic::mojom::PinTrigger, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::glic::mojom::UnpinTrigger, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::glic::mojom::CancelActionsResult, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::glic::mojom::SwitchConversationErrorReason, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::glic::mojom::RegisterConversationErrorReason, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::glic::mojom::PanelStateKind, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::glic::mojom::FreOverride, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::glic::mojom::InvocationSource, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::glic::mojom::ActuationTarget, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::glic::mojom::WebClientMode, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::glic::mojom::PromptType, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::glic::mojom::MicrophoneStatus, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::glic::mojom::WebClientModel, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::glic::mojom::WebUseCounter, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::glic::mojom::ClientErrorDialogType, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::glic::mojom::ResponseStopCause, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::glic::mojom::AdditionalContextSource, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::glic::mojom::ExperimentalTriggeringUpdateType, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::glic::mojom::SubscriberObservationType, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::glic::mojom::LightweightPageFeature, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::glic::mojom::CaptureRegionErrorReason, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::glic::mojom::ScreenshotEncryptionScheme, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::glic::mojom::SettingsPageField, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::glic::mojom::HostCapability, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::glic::mojom::ClientCapabilities, MaybeConstUserType>
    : std::false_type {};

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

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

      fragment->project_id.Set(
          project_id_fragment.is_null() ? nullptr : project_id_fragment.data());

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

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

      fragment->app_id.Set(
          app_id_fragment.is_null() ? nullptr : app_id_fragment.data());

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

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

      fragment->location.Set(
          location_fragment.is_null() ? nullptr : location_fragment.data());

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

      decltype(Traits::gemini_enterprise_settings(input)) in_gemini_enterprise_settings = Traits::gemini_enterprise_settings(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->gemini_enterprise_settings)::BaseType> gemini_enterprise_settings_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::glic::mojom::GeminiEnterpriseSettingsDataView, send_validation>(
        in_gemini_enterprise_settings,
        gemini_enterprise_settings_fragment);

      fragment->gemini_enterprise_settings.Set(
          gemini_enterprise_settings_fragment.is_null() ? nullptr : gemini_enterprise_settings_fragment.data());

      
      mojo::internal::Serialize<::glic::mojom::ActuationEligibility>(
        Traits::actuation_eligibility(input),
        &fragment->actuation_eligibility);

      
      mojo::internal::Serialize<::glic::mojom::ActuationEligibility>(
        Traits::glic_api_actuation_eligibility(input),
        &fragment->glic_api_actuation_eligibility);

      
      mojo::internal::Serialize<::glic::mojom::GlicExperimentalTriggeringState>(
        Traits::glic_experimental_triggering_state(input),
        &fragment->glic_experimental_triggering_state);
  }
};

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

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

      fragment->guest_url.Set(
          guest_url_fragment.is_null() ? nullptr : guest_url_fragment.data());

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

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

      fragment->autopush_guest_url.Set(
          autopush_guest_url_fragment.is_null() ? nullptr : autopush_guest_url_fragment.data());

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

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

      fragment->staging_guest_url.Set(
          staging_guest_url_fragment.is_null() ? nullptr : staging_guest_url_fragment.data());

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

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

      fragment->preprod_guest_url.Set(
          preprod_guest_url_fragment.is_null() ? nullptr : preprod_guest_url_fragment.data());

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

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

      fragment->prod_guest_url.Set(
          prod_guest_url_fragment.is_null() ? nullptr : prod_guest_url_fragment.data());

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

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

      fragment->web_continuity_originating_host_url.Set(
          web_continuity_originating_host_url_fragment.is_null() ? nullptr : web_continuity_originating_host_url_fragment.data());

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

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

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

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

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

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

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

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

      fragment->additional_content.Set(
          additional_content_fragment.is_null() ? nullptr : additional_content_fragment.data());
  }
};

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

      decltype(Traits::get_context_result(input)) in_get_context_result = Traits::get_context_result(input);
      mojo::internal::MessageFragment<decltype(fragment->get_context_result)>
          get_context_result_fragment(fragment.message());
      get_context_result_fragment.Claim(&fragment->get_context_result);
      
      mojo::internal::Serialize<::glic::mojom::GetContextResultDataView, send_validation>(
        in_get_context_result,
        get_context_result_fragment,
        true);

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->get_context_result.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null get_context_result in GetContextResultWithActionResultCode struct");
      fragment->action_result_$flag = Traits::action_result(input).has_value();
      if (Traits::action_result(input).has_value()) {
        fragment->action_result_$value = Traits::action_result(input).value();
      }
  }
};

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

      decltype(Traits::avatar_icon(input)) in_avatar_icon = Traits::avatar_icon(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->avatar_icon)::BaseType> avatar_icon_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::skia::mojom::BitmapN32DataView, send_validation>(
        in_avatar_icon,
        avatar_icon_fragment);

      fragment->avatar_icon.Set(
          avatar_icon_fragment.is_null() ? nullptr : avatar_icon_fragment.data());

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

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

      fragment->given_name.Set(
          given_name_fragment.is_null() ? nullptr : given_name_fragment.data());

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

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

      fragment->local_profile_name.Set(
          local_profile_name_fragment.is_null() ? nullptr : local_profile_name_fragment.data());

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

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

      fragment->email.Set(
          email_fragment.is_null() ? nullptr : email_fragment.data());

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

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

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

      
      mojo::internal::Serialize<::glic::mojom::SbThreatType>(
        Traits::threat_type(input),
        &fragment->threat_type);

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

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

      decltype(Traits::sb_verdict_result(input)) in_sb_verdict_result = Traits::sb_verdict_result(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->sb_verdict_result)::BaseType> sb_verdict_result_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::glic::mojom::SafeBrowsingVerdictDataView, send_validation>(
        in_sb_verdict_result,
        sb_verdict_result_fragment);

      fragment->sb_verdict_result.Set(
          sb_verdict_result_fragment.is_null() ? nullptr : sb_verdict_result_fragment.data());

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

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

      decltype(Traits::panel_state(input)) in_panel_state = Traits::panel_state(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->panel_state)::BaseType> panel_state_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::glic::mojom::PanelStateDataView, send_validation>(
        in_panel_state,
        panel_state_fragment);

      fragment->panel_state.Set(
          panel_state_fragment.is_null() ? nullptr : panel_state_fragment.data());

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

      decltype(Traits::focused_tab_data(input)) in_focused_tab_data = Traits::focused_tab_data(input);
      mojo::internal::MessageFragment<decltype(fragment->focused_tab_data)>
          focused_tab_data_fragment(fragment.message());
      focused_tab_data_fragment.Claim(&fragment->focused_tab_data);
      
      mojo::internal::Serialize<::glic::mojom::FocusedTabDataDataView, send_validation>(
        in_focused_tab_data,
        focused_tab_data_fragment,
        true);

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

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

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

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

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

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

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

      fragment->hotkey.Set(
          hotkey_fragment.is_null() ? nullptr : hotkey_fragment.data());

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

      decltype(Traits::chrome_version(input)) in_chrome_version = Traits::chrome_version(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->chrome_version)::BaseType> chrome_version_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::mojo_base::mojom::VersionDataView, send_validation>(
        in_chrome_version,
        chrome_version_fragment);

      fragment->chrome_version.Set(
          chrome_version_fragment.is_null() ? nullptr : chrome_version_fragment.data());

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

      
      mojo::internal::Serialize<::glic::mojom::Platform>(
        Traits::platform(input),
        &fragment->platform);

      
      mojo::internal::Serialize<::glic::mojom::FormFactor>(
        Traits::form_factor(input),
        &fragment->form_factor);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

      decltype(Traits::host_capabilities(input)) in_host_capabilities = Traits::host_capabilities(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->host_capabilities)::BaseType>
          host_capabilities_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& host_capabilities_validate_params =
          mojo::internal::GetArrayOfEnumsValidator<0, false, ::glic::mojom::internal::HostCapability_Data::Validate>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<::glic::mojom::HostCapability>, send_validation>(
        in_host_capabilities,
        host_capabilities_fragment,
        &host_capabilities_validate_params);

      fragment->host_capabilities.Set(
          host_capabilities_fragment.is_null() ? nullptr : host_capabilities_fragment.data());

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

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

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

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

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

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

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

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

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

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

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

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

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

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

      decltype(Traits::gemini_enterprise_settings(input)) in_gemini_enterprise_settings = Traits::gemini_enterprise_settings(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->gemini_enterprise_settings)::BaseType> gemini_enterprise_settings_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::glic::mojom::GeminiEnterpriseSettingsDataView, send_validation>(
        in_gemini_enterprise_settings,
        gemini_enterprise_settings_fragment);

      fragment->gemini_enterprise_settings.Set(
          gemini_enterprise_settings_fragment.is_null() ? nullptr : gemini_enterprise_settings_fragment.data());

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

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

      
      mojo::internal::Serialize<::glic::mojom::FileUploadPolicyState>(
        Traits::file_upload_policy_state(input),
        &fragment->file_upload_policy_state);
  }
};

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

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

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

      
      mojo::internal::Serialize<::glic::mojom::ScreenshotImageFormat>(
        Traits::screenshot_image_format(input),
        &fragment->screenshot_image_format);

      
      mojo::internal::Serialize<::glic::mojom::ScreenshotCompressionQuality>(
        Traits::screenshot_compression_quality(input),
        &fragment->screenshot_compression_quality);
  }
};

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

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

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

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

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

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

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

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

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

      decltype(Traits::screenshot_collection_options(input)) in_screenshot_collection_options = Traits::screenshot_collection_options(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->screenshot_collection_options)::BaseType> screenshot_collection_options_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::glic::mojom::ScreenshotCollectionOptionsDataView, send_validation>(
        in_screenshot_collection_options,
        screenshot_collection_options_fragment);

      fragment->screenshot_collection_options.Set(
          screenshot_collection_options_fragment.is_null() ? nullptr : screenshot_collection_options_fragment.data());

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

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

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

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

      fragment->query.Set(
          query_fragment.is_null() ? nullptr : query_fragment.data());
  }
};

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

      decltype(Traits::selector(input)) in_selector = Traits::selector(input);
      mojo::internal::MessageFragment<decltype(fragment->selector)>
          selector_fragment(fragment.message());
      selector_fragment.Claim(&fragment->selector);
      
      mojo::internal::Serialize<::glic::mojom::ScrollToSelectorDataView, send_validation>(
        in_selector,
        selector_fragment,
        true);

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

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

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

      fragment->document_id.Set(
          document_id_fragment.is_null() ? nullptr : document_id_fragment.data());

      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());
  }
};

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

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

      fragment->text.Set(
          text_fragment.is_null() ? nullptr : text_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->text.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null text in ScrollToTextSelector struct");
      fragment->search_range_start_node_id_$flag = Traits::search_range_start_node_id(input).has_value();
      if (Traits::search_range_start_node_id(input).has_value()) {
        fragment->search_range_start_node_id_$value = Traits::search_range_start_node_id(input).value();
      }
  }
};

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

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

      fragment->text_start.Set(
          text_start_fragment.is_null() ? nullptr : text_start_fragment.data());

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

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

      fragment->text_end.Set(
          text_end_fragment.is_null() ? nullptr : text_end_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->text_end.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null text_end in ScrollToTextFragmentSelector struct");
      fragment->search_range_start_node_id_$flag = Traits::search_range_start_node_id(input).has_value();
      if (Traits::search_range_start_node_id(input).has_value()) {
        fragment->search_range_start_node_id_$value = Traits::search_range_start_node_id(input).value();
      }
  }
};

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

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

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

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

      fragment->suggestion.Set(
          suggestion_fragment.is_null() ? nullptr : suggestion_fragment.data());

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

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

      
      mojo::internal::Serialize<::glic::mojom::SkillSource>(
        Traits::source(input),
        &fragment->source);

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

      fragment->description.Set(
          description_fragment.is_null() ? nullptr : description_fragment.data());

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

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

      fragment->curated_by.Set(
          curated_by_fragment.is_null() ? nullptr : curated_by_fragment.data());

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

      fragment->image_url.Set(
          image_url_fragment.is_null() ? nullptr : image_url_fragment.data());

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

      fragment->category.Set(
          category_fragment.is_null() ? nullptr : category_fragment.data());

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

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

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

      decltype(Traits::preview(input)) in_preview = Traits::preview(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->preview)::BaseType> preview_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::glic::mojom::SkillPreviewDataView, send_validation>(
        in_preview,
        preview_fragment);

      fragment->preview.Set(
          preview_fragment.is_null() ? nullptr : preview_fragment.data());

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

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

      fragment->prompt.Set(
          prompt_fragment.is_null() ? nullptr : prompt_fragment.data());

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

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

      fragment->source_skill_id.Set(
          source_skill_id_fragment.is_null() ? nullptr : source_skill_id_fragment.data());
  }
};

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

      
      mojo::internal::Serialize<::glic::mojom::SkillSource>(
        Traits::source(input),
        &fragment->source);

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

      fragment->prompt.Set(
          prompt_fragment.is_null() ? nullptr : prompt_fragment.data());

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

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

      fragment->description.Set(
          description_fragment.is_null() ? nullptr : description_fragment.data());

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

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

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

      decltype(Traits::suggestions(input)) in_suggestions = Traits::suggestions(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->suggestions)::BaseType>
          suggestions_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& suggestions_validate_params =
          mojo::internal::GetArrayValidator<0, false, nullptr>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<::glic::mojom::SuggestionContentDataView>, send_validation>(
        in_suggestions,
        suggestions_fragment,
        &suggestions_validate_params);

      fragment->suggestions.Set(
          suggestions_fragment.is_null() ? nullptr : suggestions_fragment.data());

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

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

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

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

      decltype(Traits::suggestions(input)) in_suggestions = Traits::suggestions(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->suggestions)::BaseType>
          suggestions_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& suggestions_validate_params =
          mojo::internal::GetArrayValidator<0, false, nullptr>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<::glic::mojom::SuggestionContentDataView>, send_validation>(
        in_suggestions,
        suggestions_fragment,
        &suggestions_validate_params);

      fragment->suggestions.Set(
          suggestions_fragment.is_null() ? nullptr : suggestions_fragment.data());

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

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

      
      mojo::internal::Serialize<::glic::mojom::InvocationSource>(
        Traits::invocation_source(input),
        &fragment->invocation_source);
  }
};

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

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

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

      fragment->supported_tools.Set(
          supported_tools_fragment.is_null() ? nullptr : supported_tools_fragment.data());

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

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

      decltype(Traits::tab_data(input)) in_tab_data = Traits::tab_data(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->tab_data)::BaseType> tab_data_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::glic::mojom::TabDataDataView, send_validation>(
        in_tab_data,
        tab_data_fragment);

      fragment->tab_data.Set(
          tab_data_fragment.is_null() ? nullptr : tab_data_fragment.data());

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

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

      
      mojo::internal::Serialize<::glic::mojom::PinTrigger>(
        Traits::pin_trigger(input),
        &fragment->pin_trigger);
  }
};

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

      
      mojo::internal::Serialize<::glic::mojom::UnpinTrigger>(
        Traits::unpin_trigger(input),
        &fragment->unpin_trigger);
  }
};

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

template <typename MaybeConstUserType, mojo::internal::SendValidation send_validation>
struct SendValidationSerializer<::glic::mojom::CreateActorTabOptionsDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::glic::mojom::CreateActorTabOptionsDataView, UserType>;
  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::glic::mojom::internal::CreateActorTabOptions_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();
      fragment->initiator_tab_id_$flag = Traits::initiator_tab_id(input).has_value();
      if (Traits::initiator_tab_id(input).has_value()) {
        fragment->initiator_tab_id_$value = Traits::initiator_tab_id(input).value();
      }
      fragment->initiator_window_id_$flag = Traits::initiator_window_id(input).has_value();
      if (Traits::initiator_window_id(input).has_value()) {
        fragment->initiator_window_id_$value = Traits::initiator_window_id(input).value();
      }

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

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

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

      decltype(Traits::options(input)) in_options = Traits::options(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->options)::BaseType> options_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::glic::mojom::TabContextOptionsDataView, send_validation>(
        in_options,
        options_fragment);

      fragment->options.Set(
          options_fragment.is_null() ? nullptr : options_fragment.data());

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

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

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

      fragment->pattern.Set(
          pattern_fragment.is_null() ? nullptr : pattern_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->pattern.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null pattern in ActivateTabOptions struct");
      fragment->fallback_window_id_$flag = Traits::fallback_window_id(input).has_value();
      if (Traits::fallback_window_id(input).has_value()) {
        fragment->fallback_window_id_$value = Traits::fallback_window_id(input).value();
      }
  }
};

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

      fragment->open_in_background = Traits::open_in_background(input);
      fragment->window_id_$flag = Traits::window_id(input).has_value();
      if (Traits::window_id(input).has_value()) {
        fragment->window_id_$value = Traits::window_id(input).value();
      }
  }
};

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

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

      fragment->conversation_id.Set(
          conversation_id_fragment.is_null() ? nullptr : conversation_id_fragment.data());

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

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

      fragment->conversation_title.Set(
          conversation_title_fragment.is_null() ? nullptr : conversation_title_fragment.data());

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

      decltype(Traits::client_data(input)) in_client_data = Traits::client_data(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->client_data)::BaseType> client_data_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::mojo_base::mojom::ByteStringDataView, send_validation>(
        in_client_data,
        client_data_fragment);

      fragment->client_data.Set(
          client_data_fragment.is_null() ? nullptr : client_data_fragment.data());

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

      fragment->turn_id.Set(
          turn_id_fragment.is_null() ? nullptr : turn_id_fragment.data());
  }
};

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

      decltype(Traits::panel_state(input)) in_panel_state = Traits::panel_state(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->panel_state)::BaseType> panel_state_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::glic::mojom::PanelStateDataView, send_validation>(
        in_panel_state,
        panel_state_fragment);

      fragment->panel_state.Set(
          panel_state_fragment.is_null() ? nullptr : panel_state_fragment.data());

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

      
      mojo::internal::Serialize<::glic::mojom::InvocationSource>(
        Traits::invocation_source(input),
        &fragment->invocation_source);

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

      fragment->prompt_suggestion.Set(
          prompt_suggestion_fragment.is_null() ? nullptr : prompt_suggestion_fragment.data());

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

      decltype(Traits::skill_to_invoke(input)) in_skill_to_invoke = Traits::skill_to_invoke(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->skill_to_invoke)::BaseType> skill_to_invoke_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::glic::mojom::SkillDataView, send_validation>(
        in_skill_to_invoke,
        skill_to_invoke_fragment);

      fragment->skill_to_invoke.Set(
          skill_to_invoke_fragment.is_null() ? nullptr : skill_to_invoke_fragment.data());

      decltype(Traits::recently_active_conversations(input)) in_recently_active_conversations = Traits::recently_active_conversations(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->recently_active_conversations)::BaseType>
          recently_active_conversations_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& recently_active_conversations_validate_params =
          mojo::internal::GetArrayValidator<0, false, nullptr>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<::glic::mojom::ConversationInfoDataView>, send_validation>(
        in_recently_active_conversations,
        recently_active_conversations_fragment,
        &recently_active_conversations_validate_params);

      fragment->recently_active_conversations.Set(
          recently_active_conversations_fragment.is_null() ? nullptr : recently_active_conversations_fragment.data());

      decltype(Traits::conversation_info(input)) in_conversation_info = Traits::conversation_info(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->conversation_info)::BaseType> conversation_info_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::glic::mojom::ConversationInfoDataView, send_validation>(
        in_conversation_info,
        conversation_info_fragment);

      fragment->conversation_info.Set(
          conversation_info_fragment.is_null() ? nullptr : conversation_info_fragment.data());

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

      
      mojo::internal::Serialize<::glic::mojom::FreOverride>(
        Traits::fre_override(input),
        &fragment->fre_override);
  }
};

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

      
      mojo::internal::Serialize<::glic::mojom::PanelStateKind>(
        Traits::kind(input),
        &fragment->kind);
      fragment->window_id_$flag = Traits::window_id(input).has_value();
      if (Traits::window_id(input).has_value()) {
        fragment->window_id_$value = Traits::window_id(input).value();
      }
  }
};

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

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

      fragment->skill_id.Set(
          skill_id_fragment.is_null() ? nullptr : skill_id_fragment.data());

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

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

      fragment->skill_name.Set(
          skill_name_fragment.is_null() ? nullptr : skill_name_fragment.data());

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

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

      fragment->skill_icon.Set(
          skill_icon_fragment.is_null() ? nullptr : skill_icon_fragment.data());

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

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

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

      fragment->serialized_metadata.Set(
          serialized_metadata_fragment.is_null() ? nullptr : serialized_metadata_fragment.data());

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

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

      
      mojo::internal::Serialize<::glic::mojom::InvocationSource>(
        Traits::invocation_source(input),
        &fragment->invocation_source);

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

      fragment->prompts.Set(
          prompts_fragment.is_null() ? nullptr : prompts_fragment.data());

      decltype(Traits::context(input)) in_context = Traits::context(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->context)::BaseType> context_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::glic::mojom::AdditionalContextDataView, send_validation>(
        in_context,
        context_fragment);

      fragment->context.Set(
          context_fragment.is_null() ? nullptr : context_fragment.data());

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

      
      mojo::internal::Serialize<::glic::mojom::FeatureMode>(
        Traits::feature_mode(input),
        &fragment->feature_mode);

      
      mojo::internal::Serialize<::glic::mojom::ActuationTarget>(
        Traits::actuation_target(input),
        &fragment->actuation_target);

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

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

      fragment->skill_id.Set(
          skill_id_fragment.is_null() ? nullptr : skill_id_fragment.data());

      decltype(Traits::zss_config(input)) in_zss_config = Traits::zss_config(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->zss_config)::BaseType> zss_config_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::glic::mojom::ZssConfigDataView, send_validation>(
        in_zss_config,
        zss_config_fragment);

      fragment->zss_config.Set(
          zss_config_fragment.is_null() ? nullptr : zss_config_fragment.data());

      decltype(Traits::payload(input)) in_payload = Traits::payload(input);
      mojo::internal::MessageFragment<decltype(fragment->payload)>
          payload_fragment(fragment.message());
      payload_fragment.Claim(&fragment->payload);
      
      mojo::internal::Serialize<::glic::mojom::InvocationPayloadDataView, send_validation>(
        in_payload,
        payload_fragment,
        true);
      fragment->actuation_tab_id_$flag = Traits::actuation_tab_id(input).has_value();
      if (Traits::actuation_tab_id(input).has_value()) {
        fragment->actuation_tab_id_$value = Traits::actuation_tab_id(input).value();
      }
  }
};

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

      
      mojo::internal::Serialize<::glic::mojom::ResponseStopCause>(
        Traits::cause(input),
        &fragment->cause);
  }
};

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

      
      mojo::internal::Serialize<::glic::mojom::WebClientMode>(
        Traits::web_client_mode(input),
        &fragment->web_client_mode);

      decltype(Traits::panelSize(input)) in_panelSize = Traits::panelSize(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->panelSize)::BaseType> panelSize_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::gfx::mojom::SizeDataView, send_validation>(
        in_panelSize,
        panelSize_fragment);

      fragment->panelSize.Set(
          panelSize_fragment.is_null() ? nullptr : panelSize_fragment.data());

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

      fragment->resizeDuration.Set(
          resizeDuration_fragment.is_null() ? nullptr : resizeDuration_fragment.data());

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

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

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

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

      fragment->mime_type.Set(
          mime_type_fragment.is_null() ? nullptr : mime_type_fragment.data());

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

      decltype(Traits::data(input)) in_data = Traits::data(input);
      mojo::internal::MessageFragment<decltype(fragment->data)>
          data_fragment(fragment.message());
      data_fragment.Claim(&fragment->data);
      
      mojo::internal::Serialize<::mojo_base::mojom::BigBufferDataView, send_validation>(
        in_data,
        data_fragment,
        true);

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

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

      fragment->filename.Set(
          filename_fragment.is_null() ? nullptr : filename_fragment.data());
  }
};

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

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

      fragment->conversation_id.Set(
          conversation_id_fragment.is_null() ? nullptr : conversation_id_fragment.data());

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

      fragment->conversation_title.Set(
          conversation_title_fragment.is_null() ? nullptr : conversation_title_fragment.data());
  }
};

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

      
      mojo::internal::Serialize<::glic::mojom::AdditionalContextSource>(
        Traits::source(input),
        &fragment->source);

      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());
      fragment->tab_id_$flag = Traits::tab_id(input).has_value();
      if (Traits::tab_id(input).has_value()) {
        fragment->tab_id_$value = Traits::tab_id(input).value();
      }

      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());

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

      fragment->frameUrl.Set(
          frameUrl_fragment.is_null() ? nullptr : frameUrl_fragment.data());

      decltype(Traits::parts(input)) in_parts = Traits::parts(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->parts)::BaseType>
          parts_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& parts_validate_params =
          mojo::internal::GetArrayValidator<0, false, nullptr>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<::glic::mojom::AdditionalContextPartDataView>, send_validation>(
        in_parts,
        parts_fragment,
        &parts_validate_params);

      fragment->parts.Set(
          parts_fragment.is_null() ? nullptr : parts_fragment.data());

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

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

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

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

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

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

      decltype(Traits::metadata(input)) in_metadata = Traits::metadata(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->metadata)::BaseType>
          metadata_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& metadata_validate_params =
          mojo::internal::GetMapValidator<*&mojo::internal::GetArrayValidator<0, false, &mojo::internal::GetArrayValidator<0, false, nullptr>()>(), *&mojo::internal::GetArrayValidator<0, false, &mojo::internal::GetArrayValidator<0, false, nullptr>()>()>();
      
      mojo::internal::Serialize<mojo::MapDataView<mojo::StringDataView, mojo::StringDataView>, send_validation>(
        in_metadata,
        metadata_fragment,
        &metadata_validate_params);

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

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

      decltype(Traits::tab_data(input)) in_tab_data = Traits::tab_data(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->tab_data)::BaseType> tab_data_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::glic::mojom::TabDataDataView, send_validation>(
        in_tab_data,
        tab_data_fragment);

      fragment->tab_data.Set(
          tab_data_fragment.is_null() ? nullptr : tab_data_fragment.data());

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

      decltype(Traits::web_page_data(input)) in_web_page_data = Traits::web_page_data(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->web_page_data)::BaseType> web_page_data_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::glic::mojom::WebPageDataDataView, send_validation>(
        in_web_page_data,
        web_page_data_fragment);

      fragment->web_page_data.Set(
          web_page_data_fragment.is_null() ? nullptr : web_page_data_fragment.data());

      decltype(Traits::viewport_screenshot(input)) in_viewport_screenshot = Traits::viewport_screenshot(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->viewport_screenshot)::BaseType> viewport_screenshot_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::glic::mojom::ScreenshotDataView, send_validation>(
        in_viewport_screenshot,
        viewport_screenshot_fragment);

      fragment->viewport_screenshot.Set(
          viewport_screenshot_fragment.is_null() ? nullptr : viewport_screenshot_fragment.data());

      decltype(Traits::screenshot_info(input)) in_screenshot_info = Traits::screenshot_info(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->screenshot_info)::BaseType> screenshot_info_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::mojo_base::mojom::ProtoWrapperDataView, send_validation>(
        in_screenshot_info,
        screenshot_info_fragment);

      fragment->screenshot_info.Set(
          screenshot_info_fragment.is_null() ? nullptr : screenshot_info_fragment.data());

      decltype(Traits::pdf_document_data(input)) in_pdf_document_data = Traits::pdf_document_data(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->pdf_document_data)::BaseType> pdf_document_data_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::glic::mojom::PdfDocumentDataDataView, send_validation>(
        in_pdf_document_data,
        pdf_document_data_fragment);

      fragment->pdf_document_data.Set(
          pdf_document_data_fragment.is_null() ? nullptr : pdf_document_data_fragment.data());

      decltype(Traits::annotated_page_data(input)) in_annotated_page_data = Traits::annotated_page_data(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->annotated_page_data)::BaseType> annotated_page_data_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::glic::mojom::AnnotatedPageDataDataView, send_validation>(
        in_annotated_page_data,
        annotated_page_data_fragment);

      fragment->annotated_page_data.Set(
          annotated_page_data_fragment.is_null() ? nullptr : annotated_page_data_fragment.data());
  }
};

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

      decltype(Traits::main_document(input)) in_main_document = Traits::main_document(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->main_document)::BaseType> main_document_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::glic::mojom::DocumentDataDataView, send_validation>(
        in_main_document,
        main_document_fragment);

      fragment->main_document.Set(
          main_document_fragment.is_null() ? nullptr : main_document_fragment.data());

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

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

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

      fragment->inner_text.Set(
          inner_text_fragment.is_null() ? nullptr : inner_text_fragment.data());

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

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

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

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

      fragment->pdf_data.Set(
          pdf_data_fragment.is_null() ? nullptr : pdf_data_fragment.data());

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

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

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

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

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

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

      fragment->title.Set(
          title_fragment.is_null() ? nullptr : title_fragment.data());

      decltype(Traits::favicon(input)) in_favicon = Traits::favicon(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->favicon)::BaseType> favicon_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::skia::mojom::BitmapN32DataView, send_validation>(
        in_favicon,
        favicon_fragment);

      fragment->favicon.Set(
          favicon_fragment.is_null() ? nullptr : favicon_fragment.data());

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

      fragment->favicon_url.Set(
          favicon_url_fragment.is_null() ? nullptr : favicon_url_fragment.data());

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

      fragment->document_mime_type.Set(
          document_mime_type_fragment.is_null() ? nullptr : document_mime_type_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->document_mime_type.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null document_mime_type in TabData struct");
      fragment->is_observable_$flag = Traits::is_observable(input).has_value();
      if (Traits::is_observable(input).has_value()) {
        fragment->is_observable_$value = Traits::is_observable(input).value();
      }
      fragment->is_media_active_$flag = Traits::is_media_active(input).has_value();
      if (Traits::is_media_active(input).has_value()) {
        fragment->is_media_active_$value = Traits::is_media_active(input).value();
      }
      fragment->is_tab_content_captured_$flag = Traits::is_tab_content_captured(input).has_value();
      if (Traits::is_tab_content_captured(input).has_value()) {
        fragment->is_tab_content_captured_$value = Traits::is_tab_content_captured(input).value();
      }
      fragment->is_active_in_window_$flag = Traits::is_active_in_window(input).has_value();
      if (Traits::is_active_in_window(input).has_value()) {
        fragment->is_active_in_window_$value = Traits::is_active_in_window(input).value();
      }
      fragment->is_window_active_$flag = Traits::is_window_active(input).has_value();
      if (Traits::is_window_active(input).has_value()) {
        fragment->is_window_active_$value = Traits::is_window_active(input).value();
      }

      decltype(Traits::lightweight_page_features(input)) in_lightweight_page_features = Traits::lightweight_page_features(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->lightweight_page_features)::BaseType>
          lightweight_page_features_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& lightweight_page_features_validate_params =
          mojo::internal::GetArrayOfEnumsValidator<0, false, ::glic::mojom::internal::LightweightPageFeature_Data::Validate>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<::glic::mojom::LightweightPageFeature>, send_validation>(
        in_lightweight_page_features,
        lightweight_page_features_fragment,
        &lightweight_page_features_validate_params);

      fragment->lightweight_page_features.Set(
          lightweight_page_features_fragment.is_null() ? nullptr : lightweight_page_features_fragment.data());
  }
};

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

      decltype(Traits::active_tab_data(input)) in_active_tab_data = Traits::active_tab_data(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->active_tab_data)::BaseType> active_tab_data_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::glic::mojom::TabDataDataView, send_validation>(
        in_active_tab_data,
        active_tab_data_fragment);

      fragment->active_tab_data.Set(
          active_tab_data_fragment.is_null() ? nullptr : active_tab_data_fragment.data());

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

      fragment->no_focus_reason.Set(
          no_focus_reason_fragment.is_null() ? nullptr : no_focus_reason_fragment.data());

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

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

      decltype(Traits::annotated_page_content(input)) in_annotated_page_content = Traits::annotated_page_content(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->annotated_page_content)::BaseType> annotated_page_content_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::mojo_base::mojom::ProtoWrapperDataView, send_validation>(
        in_annotated_page_content,
        annotated_page_content_fragment);

      fragment->annotated_page_content.Set(
          annotated_page_content_fragment.is_null() ? nullptr : annotated_page_content_fragment.data());

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

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

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

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

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

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

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

template <typename MaybeConstUserType, mojo::internal::SendValidation send_validation>
struct SendValidationSerializer<::glic::mojom::PendingCapturedRegionDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::glic::mojom::PendingCapturedRegionDataView, UserType>;
  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::glic::mojom::internal::PendingCapturedRegion_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_base::mojom::UnguessableTokenDataView, 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 PendingCapturedRegion struct");

      decltype(Traits::region(input)) in_region = Traits::region(input);
      mojo::internal::MessageFragment<decltype(fragment->region)>
          region_fragment(fragment.message());
      region_fragment.Claim(&fragment->region);
      
      mojo::internal::Serialize<::glic::mojom::CapturedRegionDataView, send_validation>(
        in_region,
        region_fragment,
        true);

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

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

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

      decltype(Traits::region(input)) in_region = Traits::region(input);
      mojo::internal::MessageFragment<decltype(fragment->region)>
          region_fragment(fragment.message());
      region_fragment.Claim(&fragment->region);
      
      mojo::internal::Serialize<::glic::mojom::CapturedRegionDataView, send_validation>(
        in_region,
        region_fragment,
        true);

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

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

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

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

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

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

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

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

      fragment->mime_type.Set(
          mime_type_fragment.is_null() ? nullptr : mime_type_fragment.data());

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

      decltype(Traits::origin_annotations(input)) in_origin_annotations = Traits::origin_annotations(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->origin_annotations)::BaseType> origin_annotations_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::glic::mojom::ImageOriginAnnotationsDataView, send_validation>(
        in_origin_annotations,
        origin_annotations_fragment);

      fragment->origin_annotations.Set(
          origin_annotations_fragment.is_null() ? nullptr : origin_annotations_fragment.data());

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

      
      mojo::internal::Serialize<::glic::mojom::ScreenshotEncryptionScheme>(
        Traits::encryption_scheme(input),
        &fragment->encryption_scheme);
  }
};

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

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

      fragment->caption.Set(
          caption_fragment.is_null() ? nullptr : caption_fragment.data());

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

      fragment->source_origin.Set(
          source_origin_fragment.is_null() ? nullptr : source_origin_fragment.data());

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

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

      fragment->mime_type.Set(
          mime_type_fragment.is_null() ? nullptr : mime_type_fragment.data());
  }
};

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

      decltype(Traits::bytes(input)) in_bytes = Traits::bytes(input);
      mojo::internal::MessageFragment<decltype(fragment->bytes)>
          bytes_fragment(fragment.message());
      bytes_fragment.Claim(&fragment->bytes);
      
      mojo::internal::Serialize<::mojo_base::mojom::BigBufferDataView, send_validation>(
        in_bytes,
        bytes_fragment,
        true);

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

      decltype(Traits::image_info(input)) in_image_info = Traits::image_info(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->image_info)::BaseType> image_info_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::glic::mojom::ImageInfoDataView, send_validation>(
        in_image_info,
        image_info_fragment);

      fragment->image_info.Set(
          image_info_fragment.is_null() ? nullptr : image_info_fragment.data());

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

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

      
      mojo::internal::Serialize<::glic::mojom::SettingsPageField>(
        Traits::highlightField(input),
        &fragment->highlightField);
  }
};
template <typename MaybeConstUserType, SendValidation send_validation>
struct SendValidationSerializer<::glic::mojom::InvokeConversationSelectionDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = UnionTraits<::glic::mojom::InvokeConversationSelectionDataView, UserType>;
  static void Serialize(MaybeConstUserType& input,
                        MessageFragment<::glic::mojom::internal::InvokeConversationSelection_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 ::glic::mojom::InvokeConversationSelectionDataView::Tag::kDefaultConversation: {
    decltype(Traits::default_conversation(input))
    in_default_conversation = Traits::default_conversation(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_default_conversation)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<::glic::mojom::DefaultConversationDataView, send_validation>(
  in_default_conversation,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  send_validation,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null default_conversation in InvokeConversationSelection union");
    fragment->data.f_default_conversation.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
  case ::glic::mojom::InvokeConversationSelectionDataView::Tag::kNewConversation: {
    decltype(Traits::new_conversation(input))
    in_new_conversation = Traits::new_conversation(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_new_conversation)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<::glic::mojom::NewConversationDataView, send_validation>(
  in_new_conversation,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  send_validation,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null new_conversation in InvokeConversationSelection union");
    fragment->data.f_new_conversation.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
  case ::glic::mojom::InvokeConversationSelectionDataView::Tag::kConversationId: {
    decltype(Traits::conversation_id(input))
    in_conversation_id = Traits::conversation_id(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_conversation_id)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<mojo::StringDataView, send_validation>(
  in_conversation_id,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  send_validation,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null conversation_id in InvokeConversationSelection union");
    fragment->data.f_conversation_id.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
}
  }
};
template <typename MaybeConstUserType, SendValidation send_validation>
struct SendValidationSerializer<::glic::mojom::InvokeTargetSurfaceDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = UnionTraits<::glic::mojom::InvokeTargetSurfaceDataView, UserType>;
  static void Serialize(MaybeConstUserType& input,
                        MessageFragment<::glic::mojom::internal::InvokeTargetSurface_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 ::glic::mojom::InvokeTargetSurfaceDataView::Tag::kDefaultSurface: {
    decltype(Traits::default_surface(input))
    in_default_surface = Traits::default_surface(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_default_surface)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<::glic::mojom::DefaultSurfaceMojoDataView, send_validation>(
  in_default_surface,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  send_validation,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null default_surface in InvokeTargetSurface union");
    fragment->data.f_default_surface.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
  case ::glic::mojom::InvokeTargetSurfaceDataView::Tag::kNewTab: {
    decltype(Traits::new_tab(input))
    in_new_tab = Traits::new_tab(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_new_tab)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<::glic::mojom::NewTabMojoDataView, send_validation>(
  in_new_tab,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  send_validation,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null new_tab in InvokeTargetSurface union");
    fragment->data.f_new_tab.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
}
  }
};
template <typename MaybeConstUserType, SendValidation send_validation>
struct SendValidationSerializer<::glic::mojom::GetContextResultDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = UnionTraits<::glic::mojom::GetContextResultDataView, UserType>;
  static void Serialize(MaybeConstUserType& input,
                        MessageFragment<::glic::mojom::internal::GetContextResult_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 ::glic::mojom::GetContextResultDataView::Tag::kErrorReason: {
    decltype(Traits::error_reason(input))
    in_error_reason = Traits::error_reason(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_error_reason)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<mojo::StringDataView, send_validation>(
  in_error_reason,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  send_validation,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null error_reason in GetContextResult union");
    fragment->data.f_error_reason.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
  case ::glic::mojom::GetContextResultDataView::Tag::kTabContext: {
    decltype(Traits::tab_context(input))
    in_tab_context = Traits::tab_context(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_tab_context)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<::glic::mojom::TabContextResultDataView, send_validation>(
  in_tab_context,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  send_validation,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null tab_context in GetContextResult union");
    fragment->data.f_tab_context.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
}
  }
};
template <typename MaybeConstUserType, SendValidation send_validation>
struct SendValidationSerializer<::glic::mojom::CaptureScreenshotResultDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = UnionTraits<::glic::mojom::CaptureScreenshotResultDataView, UserType>;
  static void Serialize(MaybeConstUserType& input,
                        MessageFragment<::glic::mojom::internal::CaptureScreenshotResult_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 ::glic::mojom::CaptureScreenshotResultDataView::Tag::kErrorReason: {
    decltype(Traits::error_reason(input))
    in_error_reason = Traits::error_reason(input);
        
mojo::internal::Serialize<::glic::mojom::CaptureScreenshotErrorReason, send_validation>(
  in_error_reason,
  &fragment->data.f_error_reason);
    break;
  }
  case ::glic::mojom::CaptureScreenshotResultDataView::Tag::kScreenshot: {
    decltype(Traits::screenshot(input))
    in_screenshot = Traits::screenshot(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_screenshot)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<::glic::mojom::ScreenshotDataView, send_validation>(
  in_screenshot,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  send_validation,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null screenshot in CaptureScreenshotResult union");
    fragment->data.f_screenshot.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
}
  }
};
template <typename MaybeConstUserType, SendValidation send_validation>
struct SendValidationSerializer<::glic::mojom::ScrollToSelectorDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = UnionTraits<::glic::mojom::ScrollToSelectorDataView, UserType>;
  static void Serialize(MaybeConstUserType& input,
                        MessageFragment<::glic::mojom::internal::ScrollToSelector_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 ::glic::mojom::ScrollToSelectorDataView::Tag::kExactText: {
    decltype(Traits::exact_text(input))
    in_exact_text = Traits::exact_text(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_exact_text)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<::glic::mojom::ScrollToTextSelectorDataView, send_validation>(
  in_exact_text,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  send_validation,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null exact_text in ScrollToSelector union");
    fragment->data.f_exact_text.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
  case ::glic::mojom::ScrollToSelectorDataView::Tag::kTextFragment: {
    decltype(Traits::text_fragment(input))
    in_text_fragment = Traits::text_fragment(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_text_fragment)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<::glic::mojom::ScrollToTextFragmentSelectorDataView, send_validation>(
  in_text_fragment,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  send_validation,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null text_fragment in ScrollToSelector union");
    fragment->data.f_text_fragment.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
  case ::glic::mojom::ScrollToSelectorDataView::Tag::kNode: {
    decltype(Traits::node(input))
    in_node = Traits::node(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_node)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<::glic::mojom::ScrollToNodeSelectorDataView, send_validation>(
  in_node,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  send_validation,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null node in ScrollToSelector union");
    fragment->data.f_node.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
}
  }
};
template <typename MaybeConstUserType, SendValidation send_validation>
struct SendValidationSerializer<::glic::mojom::InvocationPayloadDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = UnionTraits<::glic::mojom::InvocationPayloadDataView, UserType>;
  static void Serialize(MaybeConstUserType& input,
                        MessageFragment<::glic::mojom::internal::InvocationPayload_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 ::glic::mojom::InvocationPayloadDataView::Tag::kUniversalCart: {
    decltype(Traits::universal_cart(input))
    in_universal_cart = Traits::universal_cart(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_universal_cart)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<::glic::mojom::UniversalCartPayloadDataView, send_validation>(
  in_universal_cart,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  send_validation,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null universal_cart in InvocationPayload union");
    fragment->data.f_universal_cart.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
  case ::glic::mojom::InvocationPayloadDataView::Tag::kSkillsPayload: {
    decltype(Traits::skills_payload(input))
    in_skills_payload = Traits::skills_payload(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_skills_payload)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<::glic::mojom::SkillsPayloadDataView, send_validation>(
  in_skills_payload,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  send_validation,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null skills_payload in InvocationPayload union");
    fragment->data.f_skills_payload.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
}
  }
};
template <typename MaybeConstUserType, SendValidation send_validation>
struct SendValidationSerializer<::glic::mojom::AdditionalContextPartDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = UnionTraits<::glic::mojom::AdditionalContextPartDataView, UserType>;
  static void Serialize(MaybeConstUserType& input,
                        MessageFragment<::glic::mojom::internal::AdditionalContextPart_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 ::glic::mojom::AdditionalContextPartDataView::Tag::kData: {
    decltype(Traits::data(input))
    in_data = Traits::data(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_data)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<::glic::mojom::ContextDataDataView, send_validation>(
  in_data,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  send_validation,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null data in AdditionalContextPart union");
    fragment->data.f_data.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
  case ::glic::mojom::AdditionalContextPartDataView::Tag::kScreenshot: {
    decltype(Traits::screenshot(input))
    in_screenshot = Traits::screenshot(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_screenshot)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<::glic::mojom::ScreenshotDataView, send_validation>(
  in_screenshot,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  send_validation,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null screenshot in AdditionalContextPart union");
    fragment->data.f_screenshot.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
  case ::glic::mojom::AdditionalContextPartDataView::Tag::kWebPageData: {
    decltype(Traits::web_page_data(input))
    in_web_page_data = Traits::web_page_data(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_web_page_data)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<::glic::mojom::WebPageDataDataView, send_validation>(
  in_web_page_data,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  send_validation,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null web_page_data in AdditionalContextPart union");
    fragment->data.f_web_page_data.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
  case ::glic::mojom::AdditionalContextPartDataView::Tag::kAnnotatedPageData: {
    decltype(Traits::annotated_page_data(input))
    in_annotated_page_data = Traits::annotated_page_data(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_annotated_page_data)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<::glic::mojom::AnnotatedPageDataDataView, send_validation>(
  in_annotated_page_data,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  send_validation,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null annotated_page_data in AdditionalContextPart union");
    fragment->data.f_annotated_page_data.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
  case ::glic::mojom::AdditionalContextPartDataView::Tag::kPdfDocumentData: {
    decltype(Traits::pdf_document_data(input))
    in_pdf_document_data = Traits::pdf_document_data(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_pdf_document_data)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<::glic::mojom::PdfDocumentDataDataView, send_validation>(
  in_pdf_document_data,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  send_validation,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null pdf_document_data in AdditionalContextPart union");
    fragment->data.f_pdf_document_data.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
  case ::glic::mojom::AdditionalContextPartDataView::Tag::kTabContext: {
    decltype(Traits::tab_context(input))
    in_tab_context = Traits::tab_context(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_tab_context)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<::glic::mojom::TabContextResultDataView, send_validation>(
  in_tab_context,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  send_validation,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null tab_context in AdditionalContextPart union");
    fragment->data.f_tab_context.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
  case ::glic::mojom::AdditionalContextPartDataView::Tag::kRegion: {
    decltype(Traits::region(input))
    in_region = Traits::region(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_region)::BaseType>
    value_fragment(fragment.message());
  
mojo::internal::Serialize<::glic::mojom::CapturedRegionDataView, send_validation>(
  in_region,
  value_fragment,
  false);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  send_validation,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null region in AdditionalContextPart union");
    fragment->data.f_region.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
  case ::glic::mojom::AdditionalContextPartDataView::Tag::kPendingRegion: {
    decltype(Traits::pending_region(input))
    in_pending_region = Traits::pending_region(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_pending_region)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<::glic::mojom::PendingCapturedRegionDataView, send_validation>(
  in_pending_region,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  send_validation,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null pending_region in AdditionalContextPart union");
    fragment->data.f_pending_region.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
  case ::glic::mojom::AdditionalContextPartDataView::Tag::kParentConversationMetadata: {
    decltype(Traits::parent_conversation_metadata(input))
    in_parent_conversation_metadata = Traits::parent_conversation_metadata(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_parent_conversation_metadata)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<::glic::mojom::ParentConversationMetadataDataView, send_validation>(
  in_parent_conversation_metadata,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  send_validation,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null parent_conversation_metadata in AdditionalContextPart union");
    fragment->data.f_parent_conversation_metadata.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
}
  }
};
template <typename MaybeConstUserType, SendValidation send_validation>
struct SendValidationSerializer<::glic::mojom::FocusedTabDataDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = UnionTraits<::glic::mojom::FocusedTabDataDataView, UserType>;
  static void Serialize(MaybeConstUserType& input,
                        MessageFragment<::glic::mojom::internal::FocusedTabData_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 ::glic::mojom::FocusedTabDataDataView::Tag::kFocusedTab: {
    decltype(Traits::focused_tab(input))
    in_focused_tab = Traits::focused_tab(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_focused_tab)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<::glic::mojom::TabDataDataView, send_validation>(
  in_focused_tab,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  send_validation,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null focused_tab in FocusedTabData union");
    fragment->data.f_focused_tab.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
  case ::glic::mojom::FocusedTabDataDataView::Tag::kNoFocusedTabData: {
    decltype(Traits::no_focused_tab_data(input))
    in_no_focused_tab_data = Traits::no_focused_tab_data(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_no_focused_tab_data)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<::glic::mojom::NoFocusedTabDataDataView, send_validation>(
  in_no_focused_tab_data,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  send_validation,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null no_focused_tab_data in FocusedTabData union");
    fragment->data.f_no_focused_tab_data.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
}
  }
};
template <typename MaybeConstUserType, SendValidation send_validation>
struct SendValidationSerializer<::glic::mojom::CapturedRegionDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = UnionTraits<::glic::mojom::CapturedRegionDataView, UserType>;
  static void Serialize(MaybeConstUserType& input,
                        MessageFragment<::glic::mojom::internal::CapturedRegion_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 ::glic::mojom::CapturedRegionDataView::Tag::kRect: {
    decltype(Traits::rect(input))
    in_rect = Traits::rect(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_rect)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<::gfx::mojom::RectDataView, send_validation>(
  in_rect,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  send_validation,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null rect in CapturedRegion union");
    fragment->data.f_rect.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
  case ::glic::mojom::CapturedRegionDataView::Tag::kPolyline: {
    decltype(Traits::polyline(input))
    in_polyline = Traits::polyline(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_polyline)::BaseType>
    value_fragment(fragment.message());
        constexpr const mojo::internal::ContainerValidateParams& polyline_validate_params =
            mojo::internal::GetArrayValidator<0, false, nullptr>();
        
mojo::internal::Serialize<mojo::ArrayDataView<::gfx::mojom::PointDataView>, send_validation>(
  in_polyline,
  value_fragment,
  &polyline_validate_params);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  send_validation,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null polyline in CapturedRegion union");
    fragment->data.f_polyline.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
}
  }
};
template <typename MaybeConstUserType, SendValidation send_validation>
struct SendValidationSerializer<::glic::mojom::GetImageBytesResultDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = UnionTraits<::glic::mojom::GetImageBytesResultDataView, UserType>;
  static void Serialize(MaybeConstUserType& input,
                        MessageFragment<::glic::mojom::internal::GetImageBytesResult_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 ::glic::mojom::GetImageBytesResultDataView::Tag::kImageBytes: {
    decltype(Traits::image_bytes(input))
    in_image_bytes = Traits::image_bytes(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_image_bytes)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<::glic::mojom::ImageBytesResultDataView, send_validation>(
  in_image_bytes,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  send_validation,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null image_bytes in GetImageBytesResult union");
    fragment->data.f_image_bytes.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
  case ::glic::mojom::GetImageBytesResultDataView::Tag::kErrorReason: {
    decltype(Traits::error_reason(input))
    in_error_reason = Traits::error_reason(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_error_reason)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<mojo::StringDataView, send_validation>(
  in_error_reason,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  send_validation,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null error_reason in GetImageBytesResult union");
    fragment->data.f_error_reason.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
}
  }
};
template <typename MaybeConstUserType, SendValidation send_validation>
struct SendValidationSerializer<::glic::mojom::ActorHandler_CreateTask_ResponseParam_ResultDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = UnionTraits<::glic::mojom::ActorHandler_CreateTask_ResponseParam_ResultDataView, UserType>;
  static void Serialize(MaybeConstUserType& input,
                        MessageFragment<::glic::mojom::internal::ActorHandler_CreateTask_ResponseParam_Result_Data>& fragment,
                        bool inlined) {
    
    if (CallIsNullIfExists<Traits>(input)) {
       if (inlined)
        fragment->set_null();
      return;
    }

if (!inlined)
  fragment.Allocate();

    // TODO(azani): Handle unknown and objects.
    // Set the not-null flag.
fragment->size = kUnionDataSize;
fragment->tag = Traits::GetTag(input);
switch (fragment->tag) {
  case ::glic::mojom::ActorHandler_CreateTask_ResponseParam_ResultDataView::Tag::kSuccess: {
    decltype(Traits::success(input))
    in_success = Traits::success(input);
    fragment->data.f_success = in_success;
    break;
  }
  case ::glic::mojom::ActorHandler_CreateTask_ResponseParam_ResultDataView::Tag::kFailure: {
    decltype(Traits::failure(input))
    in_failure = Traits::failure(input);
        
mojo::internal::Serialize<::glic::mojom::CreateTaskErrorReason, send_validation>(
  in_failure,
  &fragment->data.f_failure);
    break;
  }
}
  }
};
template <typename MaybeConstUserType, SendValidation send_validation>
struct SendValidationSerializer<::glic::mojom::ActorHandler_PerformActions_ResponseParam_ResultDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = UnionTraits<::glic::mojom::ActorHandler_PerformActions_ResponseParam_ResultDataView, UserType>;
  static void Serialize(MaybeConstUserType& input,
                        MessageFragment<::glic::mojom::internal::ActorHandler_PerformActions_ResponseParam_Result_Data>& fragment,
                        bool inlined) {
    
    if (CallIsNullIfExists<Traits>(input)) {
       if (inlined)
        fragment->set_null();
      return;
    }

if (!inlined)
  fragment.Allocate();

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

}  // namespace mojo::internal

#endif  // CHROME_BROWSER_GLIC_HOST_GLIC_MOJOM_SEND_VALIDATION_H_