// components/omnibox/composebox/composebox_query.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 COMPONENTS_OMNIBOX_COMPOSEBOX_COMPOSEBOX_QUERY_MOJOM_SHARED_H_
#define COMPONENTS_OMNIBOX_COMPOSEBOX_COMPOSEBOX_QUERY_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 "components/omnibox/composebox/composebox_query.mojom-shared-internal.h"




#include "components/omnibox/composebox/composebox_query.mojom-data-view.h"  // IWYU pragma: export




namespace std {

template <>
struct hash<::composebox_query::mojom::ContextUploadStatus>
    : public mojo::internal::EnumHashImpl<::composebox_query::mojom::ContextUploadStatus> {};

template <>
struct hash<::composebox_query::mojom::ContextUploadErrorType>
    : public mojo::internal::EnumHashImpl<::composebox_query::mojom::ContextUploadErrorType> {};

template <>
struct hash<::composebox_query::mojom::ModelMode>
    : public mojo::internal::EnumHashImpl<::composebox_query::mojom::ModelMode> {};

template <>
struct hash<::composebox_query::mojom::ToolMode>
    : public mojo::internal::EnumHashImpl<::composebox_query::mojom::ToolMode> {};

template <>
struct hash<::composebox_query::mojom::InputType>
    : public mojo::internal::EnumHashImpl<::composebox_query::mojom::InputType> {};

}  // namespace std

namespace mojo {


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::composebox_query::mojom::ContextUploadStatus, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = EnumTraits<::composebox_query::mojom::ContextUploadStatus, 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<::composebox_query::mojom::ContextUploadStatus>(input));
    if constexpr (requires {
                    {
                      Traits::FromMojom(known_value)
                    } -> std::same_as<UserType>;
                  }) {
      static_assert(std::same_as<::composebox_query::mojom::ContextUploadStatus, UserType> ||
                        HasInfallibleConversion(::composebox_query::mojom::ContextUploadStatus()),
                    "::composebox_query::mojom::ContextUploadStatus 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<::composebox_query::mojom::ContextUploadErrorType, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = EnumTraits<::composebox_query::mojom::ContextUploadErrorType, 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<::composebox_query::mojom::ContextUploadErrorType>(input));
    if constexpr (requires {
                    {
                      Traits::FromMojom(known_value)
                    } -> std::same_as<UserType>;
                  }) {
      static_assert(std::same_as<::composebox_query::mojom::ContextUploadErrorType, UserType> ||
                        HasInfallibleConversion(::composebox_query::mojom::ContextUploadErrorType()),
                    "::composebox_query::mojom::ContextUploadErrorType 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<::composebox_query::mojom::ModelMode, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = EnumTraits<::composebox_query::mojom::ModelMode, 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<::composebox_query::mojom::ModelMode>(input));
    if constexpr (requires {
                    {
                      Traits::FromMojom(known_value)
                    } -> std::same_as<UserType>;
                  }) {
      static_assert(std::same_as<::composebox_query::mojom::ModelMode, UserType> ||
                        HasInfallibleConversion(::composebox_query::mojom::ModelMode()),
                    "::composebox_query::mojom::ModelMode 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<::composebox_query::mojom::ToolMode, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = EnumTraits<::composebox_query::mojom::ToolMode, 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<::composebox_query::mojom::ToolMode>(input));
    if constexpr (requires {
                    {
                      Traits::FromMojom(known_value)
                    } -> std::same_as<UserType>;
                  }) {
      static_assert(std::same_as<::composebox_query::mojom::ToolMode, UserType> ||
                        HasInfallibleConversion(::composebox_query::mojom::ToolMode()),
                    "::composebox_query::mojom::ToolMode 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<::composebox_query::mojom::InputType, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = EnumTraits<::composebox_query::mojom::InputType, 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<::composebox_query::mojom::InputType>(input));
    if constexpr (requires {
                    {
                      Traits::FromMojom(known_value)
                    } -> std::same_as<UserType>;
                  }) {
      static_assert(std::same_as<::composebox_query::mojom::InputType, UserType> ||
                        HasInfallibleConversion(::composebox_query::mojom::InputType()),
                    "::composebox_query::mojom::InputType 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<::composebox_query::mojom::AimUrlParamDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::composebox_query::mojom::AimUrlParamDataView, UserType>;

  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::composebox_query::mojom::internal::AimUrlParam_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

    decltype(Traits::param_key(input)) in_param_key = Traits::param_key(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->param_key)::BaseType> param_key_fragment(
            fragment.message());
    
    mojo::internal::Serialize<mojo::StringDataView>(
      in_param_key,
      param_key_fragment);

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

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

    decltype(Traits::param_value(input)) in_param_value = Traits::param_value(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->param_value)::BaseType> param_value_fragment(
            fragment.message());
    
    mojo::internal::Serialize<mojo::StringDataView>(
      in_param_value,
      param_value_fragment);

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

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

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::composebox_query::mojom::InputTypeConfigDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::composebox_query::mojom::InputTypeConfigDataView, UserType>;

  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::composebox_query::mojom::internal::InputTypeConfig_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

    
    mojo::internal::Serialize<::composebox_query::mojom::InputType>(
      Traits::input_type(input),
      &fragment->input_type);

    decltype(Traits::menu_label(input)) in_menu_label = Traits::menu_label(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->menu_label)::BaseType> menu_label_fragment(
            fragment.message());
    
    mojo::internal::Serialize<mojo::StringDataView>(
      in_menu_label,
      menu_label_fragment);

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

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

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::composebox_query::mojom::ToolConfigDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::composebox_query::mojom::ToolConfigDataView, UserType>;

  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::composebox_query::mojom::internal::ToolConfig_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

    
    mojo::internal::Serialize<::composebox_query::mojom::ToolMode>(
      Traits::tool(input),
      &fragment->tool);

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

    decltype(Traits::menu_label(input)) in_menu_label = Traits::menu_label(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->menu_label)::BaseType> menu_label_fragment(
            fragment.message());
    
    mojo::internal::Serialize<mojo::StringDataView>(
      in_menu_label,
      menu_label_fragment);

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

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

    decltype(Traits::chip_label(input)) in_chip_label = Traits::chip_label(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->chip_label)::BaseType> chip_label_fragment(
            fragment.message());
    
    mojo::internal::Serialize<mojo::StringDataView>(
      in_chip_label,
      chip_label_fragment);

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

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

    decltype(Traits::hint_text(input)) in_hint_text = Traits::hint_text(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->hint_text)::BaseType> hint_text_fragment(
            fragment.message());
    
    mojo::internal::Serialize<mojo::StringDataView>(
      in_hint_text,
      hint_text_fragment);

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

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

    decltype(Traits::aim_url_params(input)) in_aim_url_params = Traits::aim_url_params(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->aim_url_params)::BaseType>
        aim_url_params_fragment(fragment.message());
    constexpr const mojo::internal::ContainerValidateParams& aim_url_params_validate_params =
        mojo::internal::GetArrayValidator<0, false, nullptr>();
    
    mojo::internal::Serialize<mojo::ArrayDataView<::composebox_query::mojom::AimUrlParamDataView>>(
      in_aim_url_params,
      aim_url_params_fragment,
      &aim_url_params_validate_params);

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

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

    decltype(Traits::menu_tooltip(input)) in_menu_tooltip = Traits::menu_tooltip(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->menu_tooltip)::BaseType> menu_tooltip_fragment(
            fragment.message());
    
    mojo::internal::Serialize<mojo::StringDataView>(
      in_menu_tooltip,
      menu_tooltip_fragment);

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

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

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::composebox_query::mojom::ModelConfigDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::composebox_query::mojom::ModelConfigDataView, UserType>;

  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::composebox_query::mojom::internal::ModelConfig_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

    
    mojo::internal::Serialize<::composebox_query::mojom::ModelMode>(
      Traits::model(input),
      &fragment->model);

    decltype(Traits::menu_label(input)) in_menu_label = Traits::menu_label(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->menu_label)::BaseType> menu_label_fragment(
            fragment.message());
    
    mojo::internal::Serialize<mojo::StringDataView>(
      in_menu_label,
      menu_label_fragment);

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

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

    decltype(Traits::hint_text(input)) in_hint_text = Traits::hint_text(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->hint_text)::BaseType> hint_text_fragment(
            fragment.message());
    
    mojo::internal::Serialize<mojo::StringDataView>(
      in_hint_text,
      hint_text_fragment);

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

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

    decltype(Traits::aim_url_params(input)) in_aim_url_params = Traits::aim_url_params(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->aim_url_params)::BaseType>
        aim_url_params_fragment(fragment.message());
    constexpr const mojo::internal::ContainerValidateParams& aim_url_params_validate_params =
        mojo::internal::GetArrayValidator<0, false, nullptr>();
    
    mojo::internal::Serialize<mojo::ArrayDataView<::composebox_query::mojom::AimUrlParamDataView>>(
      in_aim_url_params,
      aim_url_params_fragment,
      &aim_url_params_validate_params);

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

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

    decltype(Traits::menu_tooltip(input)) in_menu_tooltip = Traits::menu_tooltip(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->menu_tooltip)::BaseType> menu_tooltip_fragment(
            fragment.message());
    
    mojo::internal::Serialize<mojo::StringDataView>(
      in_menu_tooltip,
      menu_tooltip_fragment);

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

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

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::composebox_query::mojom::SectionConfigDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::composebox_query::mojom::SectionConfigDataView, UserType>;

  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::composebox_query::mojom::internal::SectionConfig_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

    decltype(Traits::header(input)) in_header = Traits::header(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->header)::BaseType> header_fragment(
            fragment.message());
    
    mojo::internal::Serialize<mojo::StringDataView>(
      in_header,
      header_fragment);

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

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

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

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

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::composebox_query::mojom::InputStateDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::composebox_query::mojom::InputStateDataView, UserType>;

  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::composebox_query::mojom::internal::InputState_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

    decltype(Traits::allowed_models(input)) in_allowed_models = Traits::allowed_models(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->allowed_models)::BaseType>
        allowed_models_fragment(fragment.message());
    constexpr const mojo::internal::ContainerValidateParams& allowed_models_validate_params =
        mojo::internal::GetArrayOfEnumsValidator<0, false, ::composebox_query::mojom::internal::ModelMode_Data::Validate>();
    
    mojo::internal::Serialize<mojo::ArrayDataView<::composebox_query::mojom::ModelMode>>(
      in_allowed_models,
      allowed_models_fragment,
      &allowed_models_validate_params);

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

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

    decltype(Traits::allowed_tools(input)) in_allowed_tools = Traits::allowed_tools(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->allowed_tools)::BaseType>
        allowed_tools_fragment(fragment.message());
    constexpr const mojo::internal::ContainerValidateParams& allowed_tools_validate_params =
        mojo::internal::GetArrayOfEnumsValidator<0, false, ::composebox_query::mojom::internal::ToolMode_Data::Validate>();
    
    mojo::internal::Serialize<mojo::ArrayDataView<::composebox_query::mojom::ToolMode>>(
      in_allowed_tools,
      allowed_tools_fragment,
      &allowed_tools_validate_params);

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

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

    decltype(Traits::allowed_input_types(input)) in_allowed_input_types = Traits::allowed_input_types(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->allowed_input_types)::BaseType>
        allowed_input_types_fragment(fragment.message());
    constexpr const mojo::internal::ContainerValidateParams& allowed_input_types_validate_params =
        mojo::internal::GetArrayOfEnumsValidator<0, false, ::composebox_query::mojom::internal::InputType_Data::Validate>();
    
    mojo::internal::Serialize<mojo::ArrayDataView<::composebox_query::mojom::InputType>>(
      in_allowed_input_types,
      allowed_input_types_fragment,
      &allowed_input_types_validate_params);

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

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

    
    mojo::internal::Serialize<::composebox_query::mojom::ModelMode>(
      Traits::active_model(input),
      &fragment->active_model);

    
    mojo::internal::Serialize<::composebox_query::mojom::ToolMode>(
      Traits::active_tool(input),
      &fragment->active_tool);

    decltype(Traits::disabled_models(input)) in_disabled_models = Traits::disabled_models(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->disabled_models)::BaseType>
        disabled_models_fragment(fragment.message());
    constexpr const mojo::internal::ContainerValidateParams& disabled_models_validate_params =
        mojo::internal::GetArrayOfEnumsValidator<0, false, ::composebox_query::mojom::internal::ModelMode_Data::Validate>();
    
    mojo::internal::Serialize<mojo::ArrayDataView<::composebox_query::mojom::ModelMode>>(
      in_disabled_models,
      disabled_models_fragment,
      &disabled_models_validate_params);

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

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

    decltype(Traits::disabled_tools(input)) in_disabled_tools = Traits::disabled_tools(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->disabled_tools)::BaseType>
        disabled_tools_fragment(fragment.message());
    constexpr const mojo::internal::ContainerValidateParams& disabled_tools_validate_params =
        mojo::internal::GetArrayOfEnumsValidator<0, false, ::composebox_query::mojom::internal::ToolMode_Data::Validate>();
    
    mojo::internal::Serialize<mojo::ArrayDataView<::composebox_query::mojom::ToolMode>>(
      in_disabled_tools,
      disabled_tools_fragment,
      &disabled_tools_validate_params);

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

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

    decltype(Traits::disabled_input_types(input)) in_disabled_input_types = Traits::disabled_input_types(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->disabled_input_types)::BaseType>
        disabled_input_types_fragment(fragment.message());
    constexpr const mojo::internal::ContainerValidateParams& disabled_input_types_validate_params =
        mojo::internal::GetArrayOfEnumsValidator<0, false, ::composebox_query::mojom::internal::InputType_Data::Validate>();
    
    mojo::internal::Serialize<mojo::ArrayDataView<::composebox_query::mojom::InputType>>(
      in_disabled_input_types,
      disabled_input_types_fragment,
      &disabled_input_types_validate_params);

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

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

    decltype(Traits::tool_configs(input)) in_tool_configs = Traits::tool_configs(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->tool_configs)::BaseType>
        tool_configs_fragment(fragment.message());
    constexpr const mojo::internal::ContainerValidateParams& tool_configs_validate_params =
        mojo::internal::GetArrayValidator<0, false, nullptr>();
    
    mojo::internal::Serialize<mojo::ArrayDataView<::composebox_query::mojom::ToolConfigDataView>>(
      in_tool_configs,
      tool_configs_fragment,
      &tool_configs_validate_params);

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

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

    decltype(Traits::model_configs(input)) in_model_configs = Traits::model_configs(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->model_configs)::BaseType>
        model_configs_fragment(fragment.message());
    constexpr const mojo::internal::ContainerValidateParams& model_configs_validate_params =
        mojo::internal::GetArrayValidator<0, false, nullptr>();
    
    mojo::internal::Serialize<mojo::ArrayDataView<::composebox_query::mojom::ModelConfigDataView>>(
      in_model_configs,
      model_configs_fragment,
      &model_configs_validate_params);

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

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

    decltype(Traits::input_type_configs(input)) in_input_type_configs = Traits::input_type_configs(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->input_type_configs)::BaseType>
        input_type_configs_fragment(fragment.message());
    constexpr const mojo::internal::ContainerValidateParams& input_type_configs_validate_params =
        mojo::internal::GetArrayValidator<0, false, nullptr>();
    
    mojo::internal::Serialize<mojo::ArrayDataView<::composebox_query::mojom::InputTypeConfigDataView>>(
      in_input_type_configs,
      input_type_configs_fragment,
      &input_type_configs_validate_params);

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

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

    decltype(Traits::tools_section_config(input)) in_tools_section_config = Traits::tools_section_config(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->tools_section_config)::BaseType> tools_section_config_fragment(
            fragment.message());
    
    mojo::internal::Serialize<::composebox_query::mojom::SectionConfigDataView>(
      in_tools_section_config,
      tools_section_config_fragment);

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

    decltype(Traits::model_section_config(input)) in_model_section_config = Traits::model_section_config(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->model_section_config)::BaseType> model_section_config_fragment(
            fragment.message());
    
    mojo::internal::Serialize<::composebox_query::mojom::SectionConfigDataView>(
      in_model_section_config,
      model_section_config_fragment);

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

    decltype(Traits::hint_text(input)) in_hint_text = Traits::hint_text(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->hint_text)::BaseType> hint_text_fragment(
            fragment.message());
    
    mojo::internal::Serialize<mojo::StringDataView>(
      in_hint_text,
      hint_text_fragment);

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

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

    decltype(Traits::max_inputs_by_type(input)) in_max_inputs_by_type = Traits::max_inputs_by_type(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->max_inputs_by_type)::BaseType>
        max_inputs_by_type_fragment(fragment.message());
    constexpr const mojo::internal::ContainerValidateParams& max_inputs_by_type_validate_params =
        mojo::internal::GetMapValidator<*&mojo::internal::GetArrayOfEnumsValidator<0, false, ::composebox_query::mojom::internal::InputType_Data::Validate>(), *&mojo::internal::GetArrayValidator<0, false, nullptr>()>();
    
    mojo::internal::Serialize<mojo::MapDataView<::composebox_query::mojom::InputType, int32_t>>(
      in_max_inputs_by_type,
      max_inputs_by_type_fragment,
      &max_inputs_by_type_validate_params);

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

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

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

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

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

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

}  // namespace internal

}  // namespace mojo


namespace composebox_query::mojom {

inline void AimUrlParamDataView::GetParamKeyDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->param_key.Get();
  *output = mojo::StringDataView(pointer, message_);
}
inline void AimUrlParamDataView::GetParamValueDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->param_value.Get();
  *output = mojo::StringDataView(pointer, message_);
}


inline void InputTypeConfigDataView::GetMenuLabelDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->menu_label.Get();
  *output = mojo::StringDataView(pointer, message_);
}


inline void ToolConfigDataView::GetMenuLabelDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->menu_label.Get();
  *output = mojo::StringDataView(pointer, message_);
}
inline void ToolConfigDataView::GetChipLabelDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->chip_label.Get();
  *output = mojo::StringDataView(pointer, message_);
}
inline void ToolConfigDataView::GetHintTextDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->hint_text.Get();
  *output = mojo::StringDataView(pointer, message_);
}
inline void ToolConfigDataView::GetAimUrlParamsDataView(
    mojo::ArrayDataView<AimUrlParamDataView>* output) {
  auto pointer = data_->aim_url_params.Get();
  *output = mojo::ArrayDataView<AimUrlParamDataView>(pointer, message_);
}
inline void ToolConfigDataView::GetMenuTooltipDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->menu_tooltip.Get();
  *output = mojo::StringDataView(pointer, message_);
}


inline void ModelConfigDataView::GetMenuLabelDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->menu_label.Get();
  *output = mojo::StringDataView(pointer, message_);
}
inline void ModelConfigDataView::GetHintTextDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->hint_text.Get();
  *output = mojo::StringDataView(pointer, message_);
}
inline void ModelConfigDataView::GetAimUrlParamsDataView(
    mojo::ArrayDataView<AimUrlParamDataView>* output) {
  auto pointer = data_->aim_url_params.Get();
  *output = mojo::ArrayDataView<AimUrlParamDataView>(pointer, message_);
}
inline void ModelConfigDataView::GetMenuTooltipDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->menu_tooltip.Get();
  *output = mojo::StringDataView(pointer, message_);
}


inline void SectionConfigDataView::GetHeaderDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->header.Get();
  *output = mojo::StringDataView(pointer, message_);
}


inline void InputStateDataView::GetAllowedModelsDataView(
    mojo::ArrayDataView<ModelMode>* output) {
  auto pointer = data_->allowed_models.Get();
  *output = mojo::ArrayDataView<ModelMode>(pointer, message_);
}
inline void InputStateDataView::GetAllowedToolsDataView(
    mojo::ArrayDataView<ToolMode>* output) {
  auto pointer = data_->allowed_tools.Get();
  *output = mojo::ArrayDataView<ToolMode>(pointer, message_);
}
inline void InputStateDataView::GetAllowedInputTypesDataView(
    mojo::ArrayDataView<InputType>* output) {
  auto pointer = data_->allowed_input_types.Get();
  *output = mojo::ArrayDataView<InputType>(pointer, message_);
}
inline void InputStateDataView::GetDisabledModelsDataView(
    mojo::ArrayDataView<ModelMode>* output) {
  auto pointer = data_->disabled_models.Get();
  *output = mojo::ArrayDataView<ModelMode>(pointer, message_);
}
inline void InputStateDataView::GetDisabledToolsDataView(
    mojo::ArrayDataView<ToolMode>* output) {
  auto pointer = data_->disabled_tools.Get();
  *output = mojo::ArrayDataView<ToolMode>(pointer, message_);
}
inline void InputStateDataView::GetDisabledInputTypesDataView(
    mojo::ArrayDataView<InputType>* output) {
  auto pointer = data_->disabled_input_types.Get();
  *output = mojo::ArrayDataView<InputType>(pointer, message_);
}
inline void InputStateDataView::GetToolConfigsDataView(
    mojo::ArrayDataView<ToolConfigDataView>* output) {
  auto pointer = data_->tool_configs.Get();
  *output = mojo::ArrayDataView<ToolConfigDataView>(pointer, message_);
}
inline void InputStateDataView::GetModelConfigsDataView(
    mojo::ArrayDataView<ModelConfigDataView>* output) {
  auto pointer = data_->model_configs.Get();
  *output = mojo::ArrayDataView<ModelConfigDataView>(pointer, message_);
}
inline void InputStateDataView::GetInputTypeConfigsDataView(
    mojo::ArrayDataView<InputTypeConfigDataView>* output) {
  auto pointer = data_->input_type_configs.Get();
  *output = mojo::ArrayDataView<InputTypeConfigDataView>(pointer, message_);
}
inline void InputStateDataView::GetToolsSectionConfigDataView(
    SectionConfigDataView* output) {
  auto pointer = data_->tools_section_config.Get();
  *output = SectionConfigDataView(pointer, message_);
}
inline void InputStateDataView::GetModelSectionConfigDataView(
    SectionConfigDataView* output) {
  auto pointer = data_->model_section_config.Get();
  *output = SectionConfigDataView(pointer, message_);
}
inline void InputStateDataView::GetHintTextDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->hint_text.Get();
  *output = mojo::StringDataView(pointer, message_);
}
inline void InputStateDataView::GetMaxInputsByTypeDataView(
    mojo::MapDataView<InputType, int32_t>* output) {
  auto pointer = data_->max_inputs_by_type.Get();
  *output = mojo::MapDataView<InputType, int32_t>(pointer, message_);
}



}  // composebox_query::mojom

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

namespace perfetto {

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

} // namespace perfetto

namespace perfetto {

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

} // namespace perfetto

namespace perfetto {

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

} // namespace perfetto

namespace perfetto {

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

} // namespace perfetto

namespace perfetto {

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

} // namespace perfetto

#endif  // COMPONENTS_OMNIBOX_COMPOSEBOX_COMPOSEBOX_QUERY_MOJOM_SHARED_H_