// chrome/browser/glic/host/glic.mojom-shared.h is auto generated by mojom_bindings_generator.py, do not edit

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

#ifndef CHROME_BROWSER_GLIC_HOST_GLIC_MOJOM_SHARED_H_
#define CHROME_BROWSER_GLIC_HOST_GLIC_MOJOM_SHARED_H_

#include <stdint.h>

#include <functional>
#include <iosfwd>
#include <type_traits>
#include <utility>
#include "mojo/public/cpp/bindings/array_data_view.h"
#include "mojo/public/cpp/bindings/map_data_view.h"
#include "mojo/public/cpp/bindings/string_data_view.h"
#include "mojo/public/cpp/system/message_pipe.h"

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

#include "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 "mojo/public/cpp/bindings/lib/interface_serialization.h"
#include "mojo/public/cpp/system/data_pipe.h"



#include "chrome/browser/glic/host/glic.mojom-data-view.h"  // IWYU pragma: export




namespace std {

template <>
struct hash<::glic::mojom::GlicExperimentalTriggeringState>
    : public mojo::internal::EnumHashImpl<::glic::mojom::GlicExperimentalTriggeringState> {};

template <>
struct hash<::glic::mojom::FileUploadPolicyState>
    : public mojo::internal::EnumHashImpl<::glic::mojom::FileUploadPolicyState> {};

template <>
struct hash<::glic::mojom::ActuationEligibility>
    : public mojo::internal::EnumHashImpl<::glic::mojom::ActuationEligibility> {};

template <>
struct hash<::glic::mojom::MetricUserInputReactionType>
    : public mojo::internal::EnumHashImpl<::glic::mojom::MetricUserInputReactionType> {};

template <>
struct hash<::glic::mojom::PerformActionsErrorReason>
    : public mojo::internal::EnumHashImpl<::glic::mojom::PerformActionsErrorReason> {};

template <>
struct hash<::glic::mojom::CreateTaskErrorReason>
    : public mojo::internal::EnumHashImpl<::glic::mojom::CreateTaskErrorReason> {};

template <>
struct hash<::glic::mojom::ActorTaskState>
    : public mojo::internal::EnumHashImpl<::glic::mojom::ActorTaskState> {};

template <>
struct hash<::glic::mojom::ActorTaskPauseReason>
    : public mojo::internal::EnumHashImpl<::glic::mojom::ActorTaskPauseReason> {};

template <>
struct hash<::glic::mojom::ActorTaskStopReason>
    : public mojo::internal::EnumHashImpl<::glic::mojom::ActorTaskStopReason> {};

template <>
struct hash<::glic::mojom::ActorTaskInterruptReason>
    : public mojo::internal::EnumHashImpl<::glic::mojom::ActorTaskInterruptReason> {};

template <>
struct hash<::glic::mojom::CaptureScreenshotErrorReason>
    : public mojo::internal::EnumHashImpl<::glic::mojom::CaptureScreenshotErrorReason> {};

template <>
struct hash<::glic::mojom::SbThreatType>
    : public mojo::internal::EnumHashImpl<::glic::mojom::SbThreatType> {};

template <>
struct hash<::glic::mojom::Platform>
    : public mojo::internal::EnumHashImpl<::glic::mojom::Platform> {};

template <>
struct hash<::glic::mojom::FormFactor>
    : public mojo::internal::EnumHashImpl<::glic::mojom::FormFactor> {};

template <>
struct hash<::glic::mojom::ScreenshotImageFormat>
    : public mojo::internal::EnumHashImpl<::glic::mojom::ScreenshotImageFormat> {};

template <>
struct hash<::glic::mojom::ScreenshotCompressionQuality>
    : public mojo::internal::EnumHashImpl<::glic::mojom::ScreenshotCompressionQuality> {};

template <>
struct hash<::glic::mojom::ScrollToErrorReason>
    : public mojo::internal::EnumHashImpl<::glic::mojom::ScrollToErrorReason> {};

template <>
struct hash<::glic::mojom::SkillSource>
    : public mojo::internal::EnumHashImpl<::glic::mojom::SkillSource> {};

template <>
struct hash<::glic::mojom::SkillsWebClientEvent>
    : public mojo::internal::EnumHashImpl<::glic::mojom::SkillsWebClientEvent> {};

template <>
struct hash<::glic::mojom::PinTrigger>
    : public mojo::internal::EnumHashImpl<::glic::mojom::PinTrigger> {};

template <>
struct hash<::glic::mojom::UnpinTrigger>
    : public mojo::internal::EnumHashImpl<::glic::mojom::UnpinTrigger> {};

template <>
struct hash<::glic::mojom::CancelActionsResult>
    : public mojo::internal::EnumHashImpl<::glic::mojom::CancelActionsResult> {};

template <>
struct hash<::glic::mojom::SwitchConversationErrorReason>
    : public mojo::internal::EnumHashImpl<::glic::mojom::SwitchConversationErrorReason> {};

template <>
struct hash<::glic::mojom::RegisterConversationErrorReason>
    : public mojo::internal::EnumHashImpl<::glic::mojom::RegisterConversationErrorReason> {};

template <>
struct hash<::glic::mojom::PanelStateKind>
    : public mojo::internal::EnumHashImpl<::glic::mojom::PanelStateKind> {};

template <>
struct hash<::glic::mojom::FreOverride>
    : public mojo::internal::EnumHashImpl<::glic::mojom::FreOverride> {};

template <>
struct hash<::glic::mojom::InvocationSource>
    : public mojo::internal::EnumHashImpl<::glic::mojom::InvocationSource> {};

template <>
struct hash<::glic::mojom::ActuationTarget>
    : public mojo::internal::EnumHashImpl<::glic::mojom::ActuationTarget> {};

template <>
struct hash<::glic::mojom::WebClientMode>
    : public mojo::internal::EnumHashImpl<::glic::mojom::WebClientMode> {};

template <>
struct hash<::glic::mojom::PromptType>
    : public mojo::internal::EnumHashImpl<::glic::mojom::PromptType> {};

template <>
struct hash<::glic::mojom::MicrophoneStatus>
    : public mojo::internal::EnumHashImpl<::glic::mojom::MicrophoneStatus> {};

template <>
struct hash<::glic::mojom::WebClientModel>
    : public mojo::internal::EnumHashImpl<::glic::mojom::WebClientModel> {};

template <>
struct hash<::glic::mojom::WebUseCounter>
    : public mojo::internal::EnumHashImpl<::glic::mojom::WebUseCounter> {};

template <>
struct hash<::glic::mojom::ClientErrorDialogType>
    : public mojo::internal::EnumHashImpl<::glic::mojom::ClientErrorDialogType> {};

template <>
struct hash<::glic::mojom::ResponseStopCause>
    : public mojo::internal::EnumHashImpl<::glic::mojom::ResponseStopCause> {};

template <>
struct hash<::glic::mojom::AdditionalContextSource>
    : public mojo::internal::EnumHashImpl<::glic::mojom::AdditionalContextSource> {};

template <>
struct hash<::glic::mojom::ExperimentalTriggeringUpdateType>
    : public mojo::internal::EnumHashImpl<::glic::mojom::ExperimentalTriggeringUpdateType> {};

template <>
struct hash<::glic::mojom::SubscriberObservationType>
    : public mojo::internal::EnumHashImpl<::glic::mojom::SubscriberObservationType> {};

template <>
struct hash<::glic::mojom::LightweightPageFeature>
    : public mojo::internal::EnumHashImpl<::glic::mojom::LightweightPageFeature> {};

template <>
struct hash<::glic::mojom::CaptureRegionErrorReason>
    : public mojo::internal::EnumHashImpl<::glic::mojom::CaptureRegionErrorReason> {};

template <>
struct hash<::glic::mojom::ScreenshotEncryptionScheme>
    : public mojo::internal::EnumHashImpl<::glic::mojom::ScreenshotEncryptionScheme> {};

template <>
struct hash<::glic::mojom::SettingsPageField>
    : public mojo::internal::EnumHashImpl<::glic::mojom::SettingsPageField> {};

template <>
struct hash<::glic::mojom::HostCapability>
    : public mojo::internal::EnumHashImpl<::glic::mojom::HostCapability> {};

template <>
struct hash<::glic::mojom::ClientCapabilities>
    : public mojo::internal::EnumHashImpl<::glic::mojom::ClientCapabilities> {};

}  // namespace std

namespace mojo {


namespace internal {

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

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

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

}  // namespace internal


namespace internal {

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

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

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

}  // namespace internal


namespace internal {

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

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

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

}  // namespace internal


namespace internal {

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

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

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

}  // namespace internal


namespace internal {

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

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

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

}  // namespace internal


namespace internal {

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

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

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

}  // namespace internal


namespace internal {

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

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

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

}  // namespace internal


namespace internal {

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

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

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

}  // namespace internal


namespace internal {

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

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

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

}  // namespace internal


namespace internal {

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

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

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

}  // namespace internal


namespace internal {

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

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

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

}  // namespace internal


namespace internal {

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

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

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

}  // namespace internal


namespace internal {

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

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

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

}  // namespace internal


namespace internal {

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

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

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

}  // namespace internal


namespace internal {

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

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

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

}  // namespace internal


namespace internal {

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

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

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

}  // namespace internal


namespace internal {

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

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

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

}  // namespace internal


namespace internal {

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

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

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

}  // namespace internal


namespace internal {

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

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

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

}  // namespace internal


namespace internal {

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

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

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

}  // namespace internal


namespace internal {

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

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

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

}  // namespace internal


namespace internal {

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

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

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

}  // namespace internal


namespace internal {

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

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

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

}  // namespace internal


namespace internal {

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

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

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

}  // namespace internal


namespace internal {

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

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

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

}  // namespace internal


namespace internal {

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

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

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

}  // namespace internal


namespace internal {

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

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

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

}  // namespace internal


namespace internal {

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

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

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

}  // namespace internal


namespace internal {

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

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

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

}  // namespace internal


namespace internal {

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

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

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

}  // namespace internal


namespace internal {

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

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

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

}  // namespace internal


namespace internal {

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

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

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

}  // namespace internal


namespace internal {

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

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

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

}  // namespace internal


namespace internal {

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

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

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

}  // namespace internal


namespace internal {

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

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

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

}  // namespace internal


namespace internal {

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

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

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

}  // namespace internal


namespace internal {

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

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

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

}  // namespace internal


namespace internal {

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

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

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

}  // namespace internal


namespace internal {

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

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

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

}  // namespace internal


namespace internal {

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

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

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

}  // namespace internal


namespace internal {

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

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

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

}  // namespace internal


namespace internal {

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

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

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

}  // namespace internal


namespace internal {

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

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

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

}  // namespace internal


namespace internal {

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

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::GeminiEnterpriseSettingsDataView, MaybeConstUserType> {
  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>(
      in_project_id,
      project_id_fragment);

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

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(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>(
      in_app_id,
      app_id_fragment);

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

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(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>(
      in_location,
      location_fragment);

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

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

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::ProfileEnablementDataView, MaybeConstUserType> {
  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>(
      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);
  }

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::ConfigInfoDataView, MaybeConstUserType> {
  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>(
      in_guest_url,
      guest_url_fragment);

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

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(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>(
      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(
      mojo::internal::SendValidation::kDefault,
      !(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>(
      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(
      mojo::internal::SendValidation::kDefault,
      !(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>(
      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(
      mojo::internal::SendValidation::kDefault,
      !(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>(
      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(
      mojo::internal::SendValidation::kDefault,
      !(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>(
      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(
      mojo::internal::SendValidation::kDefault,
      !(fragment->web_continuity_originating_host_url.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null web_continuity_originating_host_url in ConfigInfo struct");
  }

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::DefaultConversationDataView, MaybeConstUserType> {
  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();
  }

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::NewConversationDataView, MaybeConstUserType> {
  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();
  }

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::DefaultSurfaceMojoDataView, MaybeConstUserType> {
  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();
  }

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::NewTabMojoDataView, MaybeConstUserType> {
  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);
  }

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::ZssConfigDataView, MaybeConstUserType> {
  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>(
      in_additional_content,
      additional_content_fragment);

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

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::GetContextResultWithActionResultCodeDataView, MaybeConstUserType> {
  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>(
      in_get_context_result,
      get_context_result_fragment,
      true);

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(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();
    }
  }

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::UserProfileInfoDataView, MaybeConstUserType> {
  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>(
      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>(
      in_display_name,
      display_name_fragment);

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

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(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>(
      in_given_name,
      given_name_fragment);

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

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(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>(
      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(
      mojo::internal::SendValidation::kDefault,
      !(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>(
      in_email,
      email_fragment);

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

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

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

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::SafeBrowsingVerdictDataView, MaybeConstUserType> {
  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>(
      in_url,
      url_fragment);

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

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(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);
  }

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::CounterAbuseVerdictDataView, MaybeConstUserType> {
  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>(
      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(
      mojo::internal::SendValidation::kDefault,
      !(fragment->sb_verdict_result.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null sb_verdict_result in CounterAbuseVerdict struct");
  }

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::WebClientInitialStateDataView, MaybeConstUserType> {
  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>(
      in_panel_state,
      panel_state_fragment);

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

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(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>(
      in_focused_tab_data,
      focused_tab_data_fragment,
      true);

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(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>(
      in_hotkey,
      hotkey_fragment);

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

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(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>(
      in_chrome_version,
      chrome_version_fragment);

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

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(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>>(
      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(
      mojo::internal::SendValidation::kDefault,
      !(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>(
      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);
  }

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::ScreenshotCollectionOptionsDataView, MaybeConstUserType> {
  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);
  }

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::TabContextOptionsDataView, MaybeConstUserType> {
  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>(
      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(
      mojo::internal::SendValidation::kDefault,
      !(fragment->screenshot_collection_options.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null screenshot_collection_options in TabContextOptions struct");
  }

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::GetPinCandidatesOptionsDataView, MaybeConstUserType> {
  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>(
      in_query,
      query_fragment);

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

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::ScrollToParamsDataView, MaybeConstUserType> {
  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>(
      in_selector,
      selector_fragment,
      true);

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(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>(
      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>(
      in_url,
      url_fragment);

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

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::ScrollToTextSelectorDataView, MaybeConstUserType> {
  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>(
      in_text,
      text_fragment);

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

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(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();
    }
  }

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::ScrollToTextFragmentSelectorDataView, MaybeConstUserType> {
  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>(
      in_text_start,
      text_start_fragment);

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

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(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>(
      in_text_end,
      text_end_fragment);

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

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(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();
    }
  }

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::ScrollToNodeSelectorDataView, MaybeConstUserType> {
  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);
  }

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::SuggestionContentDataView, MaybeConstUserType> {
  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>(
      in_suggestion,
      suggestion_fragment);

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

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

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::SkillPreviewDataView, MaybeConstUserType> {
  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>(
      in_id,
      id_fragment);

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

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(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>(
      in_name,
      name_fragment);

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

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(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>(
      in_icon,
      icon_fragment);

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

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(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>(
      in_description,
      description_fragment);

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

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(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>(
      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>(
      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>(
      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>(
      in_creation_time,
      creation_time_fragment);

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

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::SkillDataView, MaybeConstUserType> {
  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>(
      in_preview,
      preview_fragment);

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

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(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>(
      in_prompt,
      prompt_fragment);

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

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(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>(
      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());
  }

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::CreateSkillRequestDataView, MaybeConstUserType> {
  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>(
      in_id,
      id_fragment);

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

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(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>(
      in_name,
      name_fragment);

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

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(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>(
      in_icon,
      icon_fragment);

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

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(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>(
      in_prompt,
      prompt_fragment);

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

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(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>(
      in_description,
      description_fragment);

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

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

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::UpdateSkillRequestDataView, MaybeConstUserType> {
  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>(
      in_id,
      id_fragment);

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

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

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::ZeroStateSuggestionsDataView, MaybeConstUserType> {
  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>>(
      in_suggestions,
      suggestions_fragment,
      &suggestions_validate_params);

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

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(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>(
      in_url,
      url_fragment);

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

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

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::ZeroStateSuggestionsV2DataView, MaybeConstUserType> {
  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>>(
      in_suggestions,
      suggestions_fragment,
      &suggestions_validate_params);

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

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(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);
  }

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::ZeroStateSuggestionsOptionsDataView, MaybeConstUserType> {
  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>>(
      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(
      mojo::internal::SendValidation::kDefault,
      !(fragment->supported_tools.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null supported_tools in ZeroStateSuggestionsOptions struct");
  }

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::PinCandidateDataView, MaybeConstUserType> {
  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>(
      in_tab_data,
      tab_data_fragment);

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

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

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::PinTabsOptionsDataView, MaybeConstUserType> {
  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);
  }

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::UnpinTabsOptionsDataView, MaybeConstUserType> {
  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);
  }

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::OpenPinnedTabPickerOptionsDataView, MaybeConstUserType> {
  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();
  }

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::CreateActorTabOptionsDataView, MaybeConstUserType> {
  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);
  }

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::CaptureRegionParamsDataView, MaybeConstUserType> {
  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>(
      in_options,
      options_fragment);

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

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

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::ActivateTabOptionsDataView, MaybeConstUserType> {
  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>(
      in_pattern,
      pattern_fragment);

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

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(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();
    }
  }

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::CreateTabOptionsDataView, MaybeConstUserType> {
  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();
    }
  }

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::ConversationInfoDataView, MaybeConstUserType> {
  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>(
      in_conversation_id,
      conversation_id_fragment);

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

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(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>(
      in_conversation_title,
      conversation_title_fragment);

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

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(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>(
      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>(
      in_turn_id,
      turn_id_fragment);

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

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::PanelOpeningDataDataView, MaybeConstUserType> {
  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>(
      in_panel_state,
      panel_state_fragment);

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

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(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>(
      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>(
      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>>(
      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>(
      in_conversation_info,
      conversation_info_fragment);

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

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(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);
  }

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::PanelStateDataView, MaybeConstUserType> {
  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();
    }
  }

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::SkillsPayloadDataView, MaybeConstUserType> {
  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>(
      in_skill_id,
      skill_id_fragment);

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

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(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>(
      in_skill_name,
      skill_name_fragment);

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

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(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>(
      in_skill_icon,
      skill_icon_fragment);

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

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

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::UniversalCartPayloadDataView, MaybeConstUserType> {
  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>>(
      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(
      mojo::internal::SendValidation::kDefault,
      !(fragment->serialized_metadata.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null serialized_metadata in UniversalCartPayload struct");
  }

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::InvokeOptionsDataView, MaybeConstUserType> {
  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>>(
      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>(
      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>(
      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>(
      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>(
      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();
    }
  }

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::OnResponseStoppedDetailsDataView, MaybeConstUserType> {
  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);
  }

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::OpenPanelInfoDataView, MaybeConstUserType> {
  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>(
      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>(
      in_resizeDuration,
      resizeDuration_fragment);

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

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(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);
  }

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::ContextDataDataView, MaybeConstUserType> {
  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>(
      in_mime_type,
      mime_type_fragment);

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

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(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>(
      in_data,
      data_fragment,
      true);

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(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>(
      in_filename,
      filename_fragment);

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

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::ParentConversationMetadataDataView, MaybeConstUserType> {
  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>(
      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>(
      in_conversation_title,
      conversation_title_fragment);

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

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::AdditionalContextDataView, MaybeConstUserType> {
  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>(
      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>(
      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>(
      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>>(
      in_parts,
      parts_fragment,
      &parts_validate_params);

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

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

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::ExperimentalTriggeringUpdateDataView, MaybeConstUserType> {
  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>(
      in_data,
      data_fragment);

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

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(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>>(
      in_metadata,
      metadata_fragment,
      &metadata_validate_params);

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

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::TabContextResultDataView, MaybeConstUserType> {
  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>(
      in_tab_data,
      tab_data_fragment);

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

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(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>(
      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>(
      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>(
      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>(
      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>(
      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());
  }

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::WebPageDataDataView, MaybeConstUserType> {
  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>(
      in_main_document,
      main_document_fragment);

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

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

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::DocumentDataDataView, MaybeConstUserType> {
  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>(
      in_origin,
      origin_fragment);

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

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(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>(
      in_inner_text,
      inner_text_fragment);

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

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(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);
  }

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::PdfDocumentDataDataView, MaybeConstUserType> {
  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>(
      in_origin,
      origin_fragment);

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

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(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>>(
      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);
  }

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::TabDataDataView, MaybeConstUserType> {
  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>(
      in_url,
      url_fragment);

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

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(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>(
      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>(
      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>(
      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>(
      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(
      mojo::internal::SendValidation::kDefault,
      !(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>>(
      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());
  }

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::NoFocusedTabDataDataView, MaybeConstUserType> {
  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>(
      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>(
      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(
      mojo::internal::SendValidation::kDefault,
      !(fragment->no_focus_reason.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null no_focus_reason in NoFocusedTabData struct");
  }

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::AnnotatedPageDataDataView, MaybeConstUserType> {
  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>(
      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>(
      in_metadata,
      metadata_fragment);

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

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::ImageOriginAnnotationsDataView, MaybeConstUserType> {
  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();
  }

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::JournalDataView, MaybeConstUserType> {
  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>>(
      in_data,
      data_fragment,
      &data_validate_params);

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

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

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::PendingCapturedRegionDataView, MaybeConstUserType> {
  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>(
      in_id,
      id_fragment);

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

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(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>(
      in_region,
      region_fragment,
      true);

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

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::CaptureRegionResultDataView, MaybeConstUserType> {
  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>(
      in_region,
      region_fragment,
      true);

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

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::ScreenshotDataView, MaybeConstUserType> {
  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>>(
      in_data,
      data_fragment,
      &data_validate_params);

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

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(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>(
      in_mime_type,
      mime_type_fragment);

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

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(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>(
      in_origin_annotations,
      origin_annotations_fragment);

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

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(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);
  }

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::ImageInfoDataView, MaybeConstUserType> {
  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>(
      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>(
      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>(
      in_url,
      url_fragment);

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

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(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>(
      in_mime_type,
      mime_type_fragment);

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

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::ImageBytesResultDataView, MaybeConstUserType> {
  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>(
      in_bytes,
      bytes_fragment,
      true);

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(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>(
      in_image_info,
      image_info_fragment);

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

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

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::OpenSettingsOptionsDataView, MaybeConstUserType> {
  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);
  }

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::InvokeConversationSelectionDataView, MaybeConstUserType> {
  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>(
  in_default_conversation,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  mojo::internal::SendValidation::kDefault,
  !(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>(
  in_new_conversation,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  mojo::internal::SendValidation::kDefault,
  !(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>(
  in_conversation_id,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  mojo::internal::SendValidation::kDefault,
  !(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;
  }
}
  }

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::InvokeTargetSurfaceDataView, MaybeConstUserType> {
  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>(
  in_default_surface,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  mojo::internal::SendValidation::kDefault,
  !(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>(
  in_new_tab,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  mojo::internal::SendValidation::kDefault,
  !(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;
  }
}
  }

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::GetContextResultDataView, MaybeConstUserType> {
  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>(
  in_error_reason,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  mojo::internal::SendValidation::kDefault,
  !(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>(
  in_tab_context,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  mojo::internal::SendValidation::kDefault,
  !(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;
  }
}
  }

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::CaptureScreenshotResultDataView, MaybeConstUserType> {
  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>(
  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>(
  in_screenshot,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  mojo::internal::SendValidation::kDefault,
  !(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;
  }
}
  }

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::ScrollToSelectorDataView, MaybeConstUserType> {
  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>(
  in_exact_text,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  mojo::internal::SendValidation::kDefault,
  !(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>(
  in_text_fragment,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  mojo::internal::SendValidation::kDefault,
  !(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>(
  in_node,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  mojo::internal::SendValidation::kDefault,
  !(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;
  }
}
  }

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::InvocationPayloadDataView, MaybeConstUserType> {
  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>(
  in_universal_cart,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  mojo::internal::SendValidation::kDefault,
  !(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>(
  in_skills_payload,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  mojo::internal::SendValidation::kDefault,
  !(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;
  }
}
  }

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::AdditionalContextPartDataView, MaybeConstUserType> {
  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>(
  in_data,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  mojo::internal::SendValidation::kDefault,
  !(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>(
  in_screenshot,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  mojo::internal::SendValidation::kDefault,
  !(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>(
  in_web_page_data,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  mojo::internal::SendValidation::kDefault,
  !(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>(
  in_annotated_page_data,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  mojo::internal::SendValidation::kDefault,
  !(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>(
  in_pdf_document_data,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  mojo::internal::SendValidation::kDefault,
  !(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>(
  in_tab_context,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  mojo::internal::SendValidation::kDefault,
  !(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>(
  in_region,
  value_fragment,
  false);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  mojo::internal::SendValidation::kDefault,
  !(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>(
  in_pending_region,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  mojo::internal::SendValidation::kDefault,
  !(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>(
  in_parent_conversation_metadata,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  mojo::internal::SendValidation::kDefault,
  !(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;
  }
}
  }

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::FocusedTabDataDataView, MaybeConstUserType> {
  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>(
  in_focused_tab,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  mojo::internal::SendValidation::kDefault,
  !(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>(
  in_no_focused_tab_data,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  mojo::internal::SendValidation::kDefault,
  !(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;
  }
}
  }

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::CapturedRegionDataView, MaybeConstUserType> {
  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>(
  in_rect,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  mojo::internal::SendValidation::kDefault,
  !(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>>(
  in_polyline,
  value_fragment,
  &polyline_validate_params);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  mojo::internal::SendValidation::kDefault,
  !(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;
  }
}
  }

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::GetImageBytesResultDataView, MaybeConstUserType> {
  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>(
  in_image_bytes,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  mojo::internal::SendValidation::kDefault,
  !(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>(
  in_error_reason,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  mojo::internal::SendValidation::kDefault,
  !(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;
  }
}
  }

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::ActorHandler_CreateTask_ResponseParam_ResultDataView, MaybeConstUserType> {
  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>(
  in_failure,
  &fragment->data.f_failure);
    break;
  }
}
  }

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::glic::mojom::ActorHandler_PerformActions_ResponseParam_ResultDataView, MaybeConstUserType> {
  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>(
  in_success,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  mojo::internal::SendValidation::kDefault,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null success in 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>(
  in_failure,
  &fragment->data.f_failure);
    break;
  }
}
  }

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

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

}  // namespace internal

}  // namespace mojo


namespace glic::mojom {

inline void GeminiEnterpriseSettingsDataView::GetProjectIdDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->project_id.Get();
  *output = mojo::StringDataView(pointer, message_);
}
inline void GeminiEnterpriseSettingsDataView::GetAppIdDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->app_id.Get();
  *output = mojo::StringDataView(pointer, message_);
}
inline void GeminiEnterpriseSettingsDataView::GetLocationDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->location.Get();
  *output = mojo::StringDataView(pointer, message_);
}


inline void ProfileEnablementDataView::GetGeminiEnterpriseSettingsDataView(
    GeminiEnterpriseSettingsDataView* output) {
  auto pointer = data_->gemini_enterprise_settings.Get();
  *output = GeminiEnterpriseSettingsDataView(pointer, message_);
}


inline void ConfigInfoDataView::GetGuestUrlDataView(
    ::url::mojom::UrlDataView* output) {
  auto pointer = data_->guest_url.Get();
  *output = ::url::mojom::UrlDataView(pointer, message_);
}
inline void ConfigInfoDataView::GetAutopushGuestUrlDataView(
    ::url::mojom::UrlDataView* output) {
  auto pointer = data_->autopush_guest_url.Get();
  *output = ::url::mojom::UrlDataView(pointer, message_);
}
inline void ConfigInfoDataView::GetStagingGuestUrlDataView(
    ::url::mojom::UrlDataView* output) {
  auto pointer = data_->staging_guest_url.Get();
  *output = ::url::mojom::UrlDataView(pointer, message_);
}
inline void ConfigInfoDataView::GetPreprodGuestUrlDataView(
    ::url::mojom::UrlDataView* output) {
  auto pointer = data_->preprod_guest_url.Get();
  *output = ::url::mojom::UrlDataView(pointer, message_);
}
inline void ConfigInfoDataView::GetProdGuestUrlDataView(
    ::url::mojom::UrlDataView* output) {
  auto pointer = data_->prod_guest_url.Get();
  *output = ::url::mojom::UrlDataView(pointer, message_);
}
inline void ConfigInfoDataView::GetWebContinuityOriginatingHostUrlDataView(
    ::url::mojom::UrlDataView* output) {
  auto pointer = data_->web_continuity_originating_host_url.Get();
  *output = ::url::mojom::UrlDataView(pointer, message_);
}










inline void ZssConfigDataView::GetAdditionalContentDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->additional_content.Get();
  *output = mojo::StringDataView(pointer, message_);
}


inline void GetContextResultWithActionResultCodeDataView::GetGetContextResultDataView(
    GetContextResultDataView* output) {
  auto pointer = &data_->get_context_result;
  *output = GetContextResultDataView(pointer, message_);
}


inline void UserProfileInfoDataView::GetAvatarIconDataView(
    ::skia::mojom::BitmapN32DataView* output) {
  auto pointer = data_->avatar_icon.Get();
  *output = ::skia::mojom::BitmapN32DataView(pointer, message_);
}
inline void UserProfileInfoDataView::GetDisplayNameDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->display_name.Get();
  *output = mojo::StringDataView(pointer, message_);
}
inline void UserProfileInfoDataView::GetGivenNameDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->given_name.Get();
  *output = mojo::StringDataView(pointer, message_);
}
inline void UserProfileInfoDataView::GetLocalProfileNameDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->local_profile_name.Get();
  *output = mojo::StringDataView(pointer, message_);
}
inline void UserProfileInfoDataView::GetEmailDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->email.Get();
  *output = mojo::StringDataView(pointer, message_);
}


inline void SafeBrowsingVerdictDataView::GetUrlDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->url.Get();
  *output = mojo::StringDataView(pointer, message_);
}


inline void CounterAbuseVerdictDataView::GetSbVerdictResultDataView(
    SafeBrowsingVerdictDataView* output) {
  auto pointer = data_->sb_verdict_result.Get();
  *output = SafeBrowsingVerdictDataView(pointer, message_);
}


inline void WebClientInitialStateDataView::GetPanelStateDataView(
    PanelStateDataView* output) {
  auto pointer = data_->panel_state.Get();
  *output = PanelStateDataView(pointer, message_);
}
inline void WebClientInitialStateDataView::GetFocusedTabDataDataView(
    FocusedTabDataDataView* output) {
  auto pointer = &data_->focused_tab_data;
  *output = FocusedTabDataDataView(pointer, message_);
}
inline void WebClientInitialStateDataView::GetHotkeyDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->hotkey.Get();
  *output = mojo::StringDataView(pointer, message_);
}
inline void WebClientInitialStateDataView::GetChromeVersionDataView(
    ::mojo_base::mojom::VersionDataView* output) {
  auto pointer = data_->chrome_version.Get();
  *output = ::mojo_base::mojom::VersionDataView(pointer, message_);
}
inline void WebClientInitialStateDataView::GetHostCapabilitiesDataView(
    mojo::ArrayDataView<HostCapability>* output) {
  auto pointer = data_->host_capabilities.Get();
  *output = mojo::ArrayDataView<HostCapability>(pointer, message_);
}
inline void WebClientInitialStateDataView::GetGeminiEnterpriseSettingsDataView(
    GeminiEnterpriseSettingsDataView* output) {
  auto pointer = data_->gemini_enterprise_settings.Get();
  *output = GeminiEnterpriseSettingsDataView(pointer, message_);
}




inline void TabContextOptionsDataView::GetScreenshotCollectionOptionsDataView(
    ScreenshotCollectionOptionsDataView* output) {
  auto pointer = data_->screenshot_collection_options.Get();
  *output = ScreenshotCollectionOptionsDataView(pointer, message_);
}


inline void GetPinCandidatesOptionsDataView::GetQueryDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->query.Get();
  *output = mojo::StringDataView(pointer, message_);
}


inline void ScrollToParamsDataView::GetSelectorDataView(
    ScrollToSelectorDataView* output) {
  auto pointer = &data_->selector;
  *output = ScrollToSelectorDataView(pointer, message_);
}
inline void ScrollToParamsDataView::GetDocumentIdDataView(
    ::mojo_base::mojom::UnguessableTokenDataView* output) {
  auto pointer = data_->document_id.Get();
  *output = ::mojo_base::mojom::UnguessableTokenDataView(pointer, message_);
}
inline void ScrollToParamsDataView::GetUrlDataView(
    ::url::mojom::UrlDataView* output) {
  auto pointer = data_->url.Get();
  *output = ::url::mojom::UrlDataView(pointer, message_);
}


inline void ScrollToTextSelectorDataView::GetTextDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->text.Get();
  *output = mojo::StringDataView(pointer, message_);
}


inline void ScrollToTextFragmentSelectorDataView::GetTextStartDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->text_start.Get();
  *output = mojo::StringDataView(pointer, message_);
}
inline void ScrollToTextFragmentSelectorDataView::GetTextEndDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->text_end.Get();
  *output = mojo::StringDataView(pointer, message_);
}




inline void SuggestionContentDataView::GetSuggestionDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->suggestion.Get();
  *output = mojo::StringDataView(pointer, message_);
}


inline void SkillPreviewDataView::GetIdDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->id.Get();
  *output = mojo::StringDataView(pointer, message_);
}
inline void SkillPreviewDataView::GetNameDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->name.Get();
  *output = mojo::StringDataView(pointer, message_);
}
inline void SkillPreviewDataView::GetIconDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->icon.Get();
  *output = mojo::StringDataView(pointer, message_);
}
inline void SkillPreviewDataView::GetDescriptionDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->description.Get();
  *output = mojo::StringDataView(pointer, message_);
}
inline void SkillPreviewDataView::GetCuratedByDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->curated_by.Get();
  *output = mojo::StringDataView(pointer, message_);
}
inline void SkillPreviewDataView::GetImageUrlDataView(
    ::url::mojom::UrlDataView* output) {
  auto pointer = data_->image_url.Get();
  *output = ::url::mojom::UrlDataView(pointer, message_);
}
inline void SkillPreviewDataView::GetCategoryDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->category.Get();
  *output = mojo::StringDataView(pointer, message_);
}
inline void SkillPreviewDataView::GetCreationTimeDataView(
    ::mojo_base::mojom::TimeDataView* output) {
  auto pointer = data_->creation_time.Get();
  *output = ::mojo_base::mojom::TimeDataView(pointer, message_);
}


inline void SkillDataView::GetPreviewDataView(
    SkillPreviewDataView* output) {
  auto pointer = data_->preview.Get();
  *output = SkillPreviewDataView(pointer, message_);
}
inline void SkillDataView::GetPromptDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->prompt.Get();
  *output = mojo::StringDataView(pointer, message_);
}
inline void SkillDataView::GetSourceSkillIdDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->source_skill_id.Get();
  *output = mojo::StringDataView(pointer, message_);
}


inline void CreateSkillRequestDataView::GetIdDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->id.Get();
  *output = mojo::StringDataView(pointer, message_);
}
inline void CreateSkillRequestDataView::GetNameDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->name.Get();
  *output = mojo::StringDataView(pointer, message_);
}
inline void CreateSkillRequestDataView::GetIconDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->icon.Get();
  *output = mojo::StringDataView(pointer, message_);
}
inline void CreateSkillRequestDataView::GetPromptDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->prompt.Get();
  *output = mojo::StringDataView(pointer, message_);
}
inline void CreateSkillRequestDataView::GetDescriptionDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->description.Get();
  *output = mojo::StringDataView(pointer, message_);
}


inline void UpdateSkillRequestDataView::GetIdDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->id.Get();
  *output = mojo::StringDataView(pointer, message_);
}


inline void ZeroStateSuggestionsDataView::GetSuggestionsDataView(
    mojo::ArrayDataView<SuggestionContentDataView>* output) {
  auto pointer = data_->suggestions.Get();
  *output = mojo::ArrayDataView<SuggestionContentDataView>(pointer, message_);
}
inline void ZeroStateSuggestionsDataView::GetUrlDataView(
    ::url::mojom::UrlDataView* output) {
  auto pointer = data_->url.Get();
  *output = ::url::mojom::UrlDataView(pointer, message_);
}


inline void ZeroStateSuggestionsV2DataView::GetSuggestionsDataView(
    mojo::ArrayDataView<SuggestionContentDataView>* output) {
  auto pointer = data_->suggestions.Get();
  *output = mojo::ArrayDataView<SuggestionContentDataView>(pointer, message_);
}


inline void ZeroStateSuggestionsOptionsDataView::GetSupportedToolsDataView(
    mojo::ArrayDataView<mojo::StringDataView>* output) {
  auto pointer = data_->supported_tools.Get();
  *output = mojo::ArrayDataView<mojo::StringDataView>(pointer, message_);
}


inline void PinCandidateDataView::GetTabDataDataView(
    TabDataDataView* output) {
  auto pointer = data_->tab_data.Get();
  *output = TabDataDataView(pointer, message_);
}










inline void CaptureRegionParamsDataView::GetOptionsDataView(
    TabContextOptionsDataView* output) {
  auto pointer = data_->options.Get();
  *output = TabContextOptionsDataView(pointer, message_);
}


inline void ActivateTabOptionsDataView::GetPatternDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->pattern.Get();
  *output = mojo::StringDataView(pointer, message_);
}




inline void ConversationInfoDataView::GetConversationIdDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->conversation_id.Get();
  *output = mojo::StringDataView(pointer, message_);
}
inline void ConversationInfoDataView::GetConversationTitleDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->conversation_title.Get();
  *output = mojo::StringDataView(pointer, message_);
}
inline void ConversationInfoDataView::GetClientDataDataView(
    ::mojo_base::mojom::ByteStringDataView* output) {
  auto pointer = data_->client_data.Get();
  *output = ::mojo_base::mojom::ByteStringDataView(pointer, message_);
}
inline void ConversationInfoDataView::GetTurnIdDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->turn_id.Get();
  *output = mojo::StringDataView(pointer, message_);
}


inline void PanelOpeningDataDataView::GetPanelStateDataView(
    PanelStateDataView* output) {
  auto pointer = data_->panel_state.Get();
  *output = PanelStateDataView(pointer, message_);
}
inline void PanelOpeningDataDataView::GetPromptSuggestionDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->prompt_suggestion.Get();
  *output = mojo::StringDataView(pointer, message_);
}
inline void PanelOpeningDataDataView::GetSkillToInvokeDataView(
    SkillDataView* output) {
  auto pointer = data_->skill_to_invoke.Get();
  *output = SkillDataView(pointer, message_);
}
inline void PanelOpeningDataDataView::GetRecentlyActiveConversationsDataView(
    mojo::ArrayDataView<ConversationInfoDataView>* output) {
  auto pointer = data_->recently_active_conversations.Get();
  *output = mojo::ArrayDataView<ConversationInfoDataView>(pointer, message_);
}
inline void PanelOpeningDataDataView::GetConversationInfoDataView(
    ConversationInfoDataView* output) {
  auto pointer = data_->conversation_info.Get();
  *output = ConversationInfoDataView(pointer, message_);
}




inline void SkillsPayloadDataView::GetSkillIdDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->skill_id.Get();
  *output = mojo::StringDataView(pointer, message_);
}
inline void SkillsPayloadDataView::GetSkillNameDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->skill_name.Get();
  *output = mojo::StringDataView(pointer, message_);
}
inline void SkillsPayloadDataView::GetSkillIconDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->skill_icon.Get();
  *output = mojo::StringDataView(pointer, message_);
}


inline void UniversalCartPayloadDataView::GetSerializedMetadataDataView(
    mojo::ArrayDataView<uint8_t>* output) {
  auto pointer = data_->serialized_metadata.Get();
  *output = mojo::ArrayDataView<uint8_t>(pointer, message_);
}


inline void InvokeOptionsDataView::GetPromptsDataView(
    mojo::ArrayDataView<mojo::StringDataView>* output) {
  auto pointer = data_->prompts.Get();
  *output = mojo::ArrayDataView<mojo::StringDataView>(pointer, message_);
}
inline void InvokeOptionsDataView::GetContextDataView(
    AdditionalContextDataView* output) {
  auto pointer = data_->context.Get();
  *output = AdditionalContextDataView(pointer, message_);
}
inline void InvokeOptionsDataView::GetSkillIdDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->skill_id.Get();
  *output = mojo::StringDataView(pointer, message_);
}
inline void InvokeOptionsDataView::GetZssConfigDataView(
    ZssConfigDataView* output) {
  auto pointer = data_->zss_config.Get();
  *output = ZssConfigDataView(pointer, message_);
}
inline void InvokeOptionsDataView::GetPayloadDataView(
    InvocationPayloadDataView* output) {
  auto pointer = &data_->payload;
  *output = InvocationPayloadDataView(pointer, message_);
}




inline void OpenPanelInfoDataView::GetPanelSizeDataView(
    ::gfx::mojom::SizeDataView* output) {
  auto pointer = data_->panelSize.Get();
  *output = ::gfx::mojom::SizeDataView(pointer, message_);
}
inline void OpenPanelInfoDataView::GetResizeDurationDataView(
    ::mojo_base::mojom::TimeDeltaDataView* output) {
  auto pointer = data_->resizeDuration.Get();
  *output = ::mojo_base::mojom::TimeDeltaDataView(pointer, message_);
}


inline void ContextDataDataView::GetMimeTypeDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->mime_type.Get();
  *output = mojo::StringDataView(pointer, message_);
}
inline void ContextDataDataView::GetDataDataView(
    ::mojo_base::mojom::BigBufferDataView* output) {
  auto pointer = &data_->data;
  *output = ::mojo_base::mojom::BigBufferDataView(pointer, message_);
}
inline void ContextDataDataView::GetFilenameDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->filename.Get();
  *output = mojo::StringDataView(pointer, message_);
}


inline void ParentConversationMetadataDataView::GetConversationIdDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->conversation_id.Get();
  *output = mojo::StringDataView(pointer, message_);
}
inline void ParentConversationMetadataDataView::GetConversationTitleDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->conversation_title.Get();
  *output = mojo::StringDataView(pointer, message_);
}


inline void AdditionalContextDataView::GetNameDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->name.Get();
  *output = mojo::StringDataView(pointer, message_);
}
inline void AdditionalContextDataView::GetOriginDataView(
    ::url::mojom::OriginDataView* output) {
  auto pointer = data_->origin.Get();
  *output = ::url::mojom::OriginDataView(pointer, message_);
}
inline void AdditionalContextDataView::GetFrameUrlDataView(
    ::url::mojom::UrlDataView* output) {
  auto pointer = data_->frameUrl.Get();
  *output = ::url::mojom::UrlDataView(pointer, message_);
}
inline void AdditionalContextDataView::GetPartsDataView(
    mojo::ArrayDataView<AdditionalContextPartDataView>* output) {
  auto pointer = data_->parts.Get();
  *output = mojo::ArrayDataView<AdditionalContextPartDataView>(pointer, message_);
}


inline void ExperimentalTriggeringUpdateDataView::GetDataDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->data.Get();
  *output = mojo::StringDataView(pointer, message_);
}
inline void ExperimentalTriggeringUpdateDataView::GetMetadataDataView(
    mojo::MapDataView<mojo::StringDataView, mojo::StringDataView>* output) {
  auto pointer = data_->metadata.Get();
  *output = mojo::MapDataView<mojo::StringDataView, mojo::StringDataView>(pointer, message_);
}


inline void TabContextResultDataView::GetTabDataDataView(
    TabDataDataView* output) {
  auto pointer = data_->tab_data.Get();
  *output = TabDataDataView(pointer, message_);
}
inline void TabContextResultDataView::GetWebPageDataDataView(
    WebPageDataDataView* output) {
  auto pointer = data_->web_page_data.Get();
  *output = WebPageDataDataView(pointer, message_);
}
inline void TabContextResultDataView::GetViewportScreenshotDataView(
    ScreenshotDataView* output) {
  auto pointer = data_->viewport_screenshot.Get();
  *output = ScreenshotDataView(pointer, message_);
}
inline void TabContextResultDataView::GetScreenshotInfoDataView(
    ::mojo_base::mojom::ProtoWrapperDataView* output) {
  auto pointer = data_->screenshot_info.Get();
  *output = ::mojo_base::mojom::ProtoWrapperDataView(pointer, message_);
}
inline void TabContextResultDataView::GetPdfDocumentDataDataView(
    PdfDocumentDataDataView* output) {
  auto pointer = data_->pdf_document_data.Get();
  *output = PdfDocumentDataDataView(pointer, message_);
}
inline void TabContextResultDataView::GetAnnotatedPageDataDataView(
    AnnotatedPageDataDataView* output) {
  auto pointer = data_->annotated_page_data.Get();
  *output = AnnotatedPageDataDataView(pointer, message_);
}


inline void WebPageDataDataView::GetMainDocumentDataView(
    DocumentDataDataView* output) {
  auto pointer = data_->main_document.Get();
  *output = DocumentDataDataView(pointer, message_);
}


inline void DocumentDataDataView::GetOriginDataView(
    ::url::mojom::OriginDataView* output) {
  auto pointer = data_->origin.Get();
  *output = ::url::mojom::OriginDataView(pointer, message_);
}
inline void DocumentDataDataView::GetInnerTextDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->inner_text.Get();
  *output = mojo::StringDataView(pointer, message_);
}


inline void PdfDocumentDataDataView::GetOriginDataView(
    ::url::mojom::OriginDataView* output) {
  auto pointer = data_->origin.Get();
  *output = ::url::mojom::OriginDataView(pointer, message_);
}
inline void PdfDocumentDataDataView::GetPdfDataDataView(
    mojo::ArrayDataView<uint8_t>* output) {
  auto pointer = data_->pdf_data.Get();
  *output = mojo::ArrayDataView<uint8_t>(pointer, message_);
}


inline void TabDataDataView::GetUrlDataView(
    ::url::mojom::UrlDataView* output) {
  auto pointer = data_->url.Get();
  *output = ::url::mojom::UrlDataView(pointer, message_);
}
inline void TabDataDataView::GetTitleDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->title.Get();
  *output = mojo::StringDataView(pointer, message_);
}
inline void TabDataDataView::GetFaviconDataView(
    ::skia::mojom::BitmapN32DataView* output) {
  auto pointer = data_->favicon.Get();
  *output = ::skia::mojom::BitmapN32DataView(pointer, message_);
}
inline void TabDataDataView::GetFaviconUrlDataView(
    ::url::mojom::UrlDataView* output) {
  auto pointer = data_->favicon_url.Get();
  *output = ::url::mojom::UrlDataView(pointer, message_);
}
inline void TabDataDataView::GetDocumentMimeTypeDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->document_mime_type.Get();
  *output = mojo::StringDataView(pointer, message_);
}
inline void TabDataDataView::GetLightweightPageFeaturesDataView(
    mojo::ArrayDataView<LightweightPageFeature>* output) {
  auto pointer = data_->lightweight_page_features.Get();
  *output = mojo::ArrayDataView<LightweightPageFeature>(pointer, message_);
}


inline void NoFocusedTabDataDataView::GetActiveTabDataDataView(
    TabDataDataView* output) {
  auto pointer = data_->active_tab_data.Get();
  *output = TabDataDataView(pointer, message_);
}
inline void NoFocusedTabDataDataView::GetNoFocusReasonDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->no_focus_reason.Get();
  *output = mojo::StringDataView(pointer, message_);
}


inline void AnnotatedPageDataDataView::GetAnnotatedPageContentDataView(
    ::mojo_base::mojom::ProtoWrapperDataView* output) {
  auto pointer = data_->annotated_page_content.Get();
  *output = ::mojo_base::mojom::ProtoWrapperDataView(pointer, message_);
}
inline void AnnotatedPageDataDataView::GetMetadataDataView(
    ::blink::mojom::PageMetadataDataView* output) {
  auto pointer = data_->metadata.Get();
  *output = ::blink::mojom::PageMetadataDataView(pointer, message_);
}




inline void JournalDataView::GetDataDataView(
    mojo::ArrayDataView<uint8_t>* output) {
  auto pointer = data_->data.Get();
  *output = mojo::ArrayDataView<uint8_t>(pointer, message_);
}


inline void PendingCapturedRegionDataView::GetIdDataView(
    ::mojo_base::mojom::UnguessableTokenDataView* output) {
  auto pointer = data_->id.Get();
  *output = ::mojo_base::mojom::UnguessableTokenDataView(pointer, message_);
}
inline void PendingCapturedRegionDataView::GetRegionDataView(
    CapturedRegionDataView* output) {
  auto pointer = &data_->region;
  *output = CapturedRegionDataView(pointer, message_);
}


inline void CaptureRegionResultDataView::GetRegionDataView(
    CapturedRegionDataView* output) {
  auto pointer = &data_->region;
  *output = CapturedRegionDataView(pointer, message_);
}


inline void ScreenshotDataView::GetDataDataView(
    mojo::ArrayDataView<uint8_t>* output) {
  auto pointer = data_->data.Get();
  *output = mojo::ArrayDataView<uint8_t>(pointer, message_);
}
inline void ScreenshotDataView::GetMimeTypeDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->mime_type.Get();
  *output = mojo::StringDataView(pointer, message_);
}
inline void ScreenshotDataView::GetOriginAnnotationsDataView(
    ImageOriginAnnotationsDataView* output) {
  auto pointer = data_->origin_annotations.Get();
  *output = ImageOriginAnnotationsDataView(pointer, message_);
}


inline void ImageInfoDataView::GetCaptionDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->caption.Get();
  *output = mojo::StringDataView(pointer, message_);
}
inline void ImageInfoDataView::GetSourceOriginDataView(
    ::url::mojom::OriginDataView* output) {
  auto pointer = data_->source_origin.Get();
  *output = ::url::mojom::OriginDataView(pointer, message_);
}
inline void ImageInfoDataView::GetUrlDataView(
    ::url::mojom::UrlDataView* output) {
  auto pointer = data_->url.Get();
  *output = ::url::mojom::UrlDataView(pointer, message_);
}
inline void ImageInfoDataView::GetMimeTypeDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->mime_type.Get();
  *output = mojo::StringDataView(pointer, message_);
}


inline void ImageBytesResultDataView::GetBytesDataView(
    ::mojo_base::mojom::BigBufferDataView* output) {
  auto pointer = &data_->bytes;
  *output = ::mojo_base::mojom::BigBufferDataView(pointer, message_);
}
inline void ImageBytesResultDataView::GetImageInfoDataView(
    ImageInfoDataView* output) {
  auto pointer = data_->image_info.Get();
  *output = ImageInfoDataView(pointer, message_);
}




inline void InvokeConversationSelectionDataView::GetDefaultConversationDataView(
    DefaultConversationDataView* output) const {
  CHECK(is_default_conversation());
  *output = DefaultConversationDataView(data_->data.f_default_conversation.Get(), message_);
}
inline void InvokeConversationSelectionDataView::GetNewConversationDataView(
    NewConversationDataView* output) const {
  CHECK(is_new_conversation());
  *output = NewConversationDataView(data_->data.f_new_conversation.Get(), message_);
}
inline void InvokeConversationSelectionDataView::GetConversationIdDataView(
    mojo::StringDataView* output) const {
  CHECK(is_conversation_id());
  *output = mojo::StringDataView(data_->data.f_conversation_id.Get(), message_);
}

inline void InvokeTargetSurfaceDataView::GetDefaultSurfaceDataView(
    DefaultSurfaceMojoDataView* output) const {
  CHECK(is_default_surface());
  *output = DefaultSurfaceMojoDataView(data_->data.f_default_surface.Get(), message_);
}
inline void InvokeTargetSurfaceDataView::GetNewTabDataView(
    NewTabMojoDataView* output) const {
  CHECK(is_new_tab());
  *output = NewTabMojoDataView(data_->data.f_new_tab.Get(), message_);
}

inline void GetContextResultDataView::GetErrorReasonDataView(
    mojo::StringDataView* output) const {
  CHECK(is_error_reason());
  *output = mojo::StringDataView(data_->data.f_error_reason.Get(), message_);
}
inline void GetContextResultDataView::GetTabContextDataView(
    TabContextResultDataView* output) const {
  CHECK(is_tab_context());
  *output = TabContextResultDataView(data_->data.f_tab_context.Get(), message_);
}

inline void CaptureScreenshotResultDataView::GetScreenshotDataView(
    ScreenshotDataView* output) const {
  CHECK(is_screenshot());
  *output = ScreenshotDataView(data_->data.f_screenshot.Get(), message_);
}

inline void ScrollToSelectorDataView::GetExactTextDataView(
    ScrollToTextSelectorDataView* output) const {
  CHECK(is_exact_text());
  *output = ScrollToTextSelectorDataView(data_->data.f_exact_text.Get(), message_);
}
inline void ScrollToSelectorDataView::GetTextFragmentDataView(
    ScrollToTextFragmentSelectorDataView* output) const {
  CHECK(is_text_fragment());
  *output = ScrollToTextFragmentSelectorDataView(data_->data.f_text_fragment.Get(), message_);
}
inline void ScrollToSelectorDataView::GetNodeDataView(
    ScrollToNodeSelectorDataView* output) const {
  CHECK(is_node());
  *output = ScrollToNodeSelectorDataView(data_->data.f_node.Get(), message_);
}

inline void InvocationPayloadDataView::GetUniversalCartDataView(
    UniversalCartPayloadDataView* output) const {
  CHECK(is_universal_cart());
  *output = UniversalCartPayloadDataView(data_->data.f_universal_cart.Get(), message_);
}
inline void InvocationPayloadDataView::GetSkillsPayloadDataView(
    SkillsPayloadDataView* output) const {
  CHECK(is_skills_payload());
  *output = SkillsPayloadDataView(data_->data.f_skills_payload.Get(), message_);
}

inline void AdditionalContextPartDataView::GetDataDataView(
    ContextDataDataView* output) const {
  CHECK(is_data());
  *output = ContextDataDataView(data_->data.f_data.Get(), message_);
}
inline void AdditionalContextPartDataView::GetScreenshotDataView(
    ScreenshotDataView* output) const {
  CHECK(is_screenshot());
  *output = ScreenshotDataView(data_->data.f_screenshot.Get(), message_);
}
inline void AdditionalContextPartDataView::GetWebPageDataDataView(
    WebPageDataDataView* output) const {
  CHECK(is_web_page_data());
  *output = WebPageDataDataView(data_->data.f_web_page_data.Get(), message_);
}
inline void AdditionalContextPartDataView::GetAnnotatedPageDataDataView(
    AnnotatedPageDataDataView* output) const {
  CHECK(is_annotated_page_data());
  *output = AnnotatedPageDataDataView(data_->data.f_annotated_page_data.Get(), message_);
}
inline void AdditionalContextPartDataView::GetPdfDocumentDataDataView(
    PdfDocumentDataDataView* output) const {
  CHECK(is_pdf_document_data());
  *output = PdfDocumentDataDataView(data_->data.f_pdf_document_data.Get(), message_);
}
inline void AdditionalContextPartDataView::GetTabContextDataView(
    TabContextResultDataView* output) const {
  CHECK(is_tab_context());
  *output = TabContextResultDataView(data_->data.f_tab_context.Get(), message_);
}
inline void AdditionalContextPartDataView::GetRegionDataView(
    CapturedRegionDataView* output) const {
  CHECK(is_region());
  *output = CapturedRegionDataView(data_->data.f_region.Get(), message_);
}
inline void AdditionalContextPartDataView::GetPendingRegionDataView(
    PendingCapturedRegionDataView* output) const {
  CHECK(is_pending_region());
  *output = PendingCapturedRegionDataView(data_->data.f_pending_region.Get(), message_);
}
inline void AdditionalContextPartDataView::GetParentConversationMetadataDataView(
    ParentConversationMetadataDataView* output) const {
  CHECK(is_parent_conversation_metadata());
  *output = ParentConversationMetadataDataView(data_->data.f_parent_conversation_metadata.Get(), message_);
}

inline void FocusedTabDataDataView::GetFocusedTabDataView(
    TabDataDataView* output) const {
  CHECK(is_focused_tab());
  *output = TabDataDataView(data_->data.f_focused_tab.Get(), message_);
}
inline void FocusedTabDataDataView::GetNoFocusedTabDataDataView(
    NoFocusedTabDataDataView* output) const {
  CHECK(is_no_focused_tab_data());
  *output = NoFocusedTabDataDataView(data_->data.f_no_focused_tab_data.Get(), message_);
}

inline void CapturedRegionDataView::GetRectDataView(
    ::gfx::mojom::RectDataView* output) const {
  CHECK(is_rect());
  *output = ::gfx::mojom::RectDataView(data_->data.f_rect.Get(), message_);
}
inline void CapturedRegionDataView::GetPolylineDataView(
    mojo::ArrayDataView<::gfx::mojom::PointDataView>* output) const {
  CHECK(is_polyline());
  *output = mojo::ArrayDataView<::gfx::mojom::PointDataView>(data_->data.f_polyline.Get(), message_);
}

inline void GetImageBytesResultDataView::GetImageBytesDataView(
    ImageBytesResultDataView* output) const {
  CHECK(is_image_bytes());
  *output = ImageBytesResultDataView(data_->data.f_image_bytes.Get(), message_);
}
inline void GetImageBytesResultDataView::GetErrorReasonDataView(
    mojo::StringDataView* output) const {
  CHECK(is_error_reason());
  *output = mojo::StringDataView(data_->data.f_error_reason.Get(), message_);
}


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


}  // glic::mojom

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

namespace perfetto {

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

} // namespace perfetto

namespace perfetto {

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

} // namespace perfetto

namespace perfetto {

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

} // namespace perfetto

namespace perfetto {

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

} // namespace perfetto

namespace perfetto {

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

} // namespace perfetto

namespace perfetto {

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

} // namespace perfetto

namespace perfetto {

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

} // namespace perfetto

namespace perfetto {

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

} // namespace perfetto

namespace perfetto {

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

} // namespace perfetto

namespace perfetto {

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

} // namespace perfetto

namespace perfetto {

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

} // namespace perfetto

namespace perfetto {

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

} // namespace perfetto

namespace perfetto {

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

} // namespace perfetto

namespace perfetto {

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

} // namespace perfetto

namespace perfetto {

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

} // namespace perfetto

namespace perfetto {

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

} // namespace perfetto

namespace perfetto {

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

} // namespace perfetto

namespace perfetto {

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

} // namespace perfetto

namespace perfetto {

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

} // namespace perfetto

namespace perfetto {

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

} // namespace perfetto

namespace perfetto {

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

} // namespace perfetto

namespace perfetto {

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

} // namespace perfetto

namespace perfetto {

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

} // namespace perfetto

namespace perfetto {

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

} // namespace perfetto

namespace perfetto {

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

} // namespace perfetto

namespace perfetto {

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

} // namespace perfetto

namespace perfetto {

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

} // namespace perfetto

namespace perfetto {

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

} // namespace perfetto

namespace perfetto {

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

} // namespace perfetto

namespace perfetto {

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

} // namespace perfetto

namespace perfetto {

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

} // namespace perfetto

namespace perfetto {

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

} // namespace perfetto

namespace perfetto {

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

} // namespace perfetto

namespace perfetto {

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

} // namespace perfetto

namespace perfetto {

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

} // namespace perfetto

namespace perfetto {

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

} // namespace perfetto

namespace perfetto {

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

} // namespace perfetto

namespace perfetto {

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

} // namespace perfetto

namespace perfetto {

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

} // namespace perfetto

namespace perfetto {

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

} // namespace perfetto

namespace perfetto {

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

} // namespace perfetto

namespace perfetto {

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

} // namespace perfetto

namespace perfetto {

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

} // namespace perfetto

namespace perfetto {

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

} // namespace perfetto

#endif  // CHROME_BROWSER_GLIC_HOST_GLIC_MOJOM_SHARED_H_