// third_party/blink/public/mojom/ai/ai_language_model.mojom-send-validation.h is auto generated by mojom_bindings_generator.py, do not edit

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

#ifndef THIRD_PARTY_BLINK_PUBLIC_MOJOM_AI_AI_LANGUAGE_MODEL_MOJOM_SEND_VALIDATION_H_
#define THIRD_PARTY_BLINK_PUBLIC_MOJOM_AI_AI_LANGUAGE_MODEL_MOJOM_SEND_VALIDATION_H_

#include "third_party/blink/public/mojom/ai/ai_language_model.mojom-shared-internal.h"
#include "mojo/public/mojom/base/values.mojom-shared.h"
#include "services/on_device_model/public/mojom/on_device_model.mojom-shared.h"
#include "skia/public/mojom/bitmap.mojom-shared.h"
#include "third_party/blink/public/mojom/ai/ai_common.mojom-shared.h"
#include "third_party/blink/public/mojom/ai/model_streaming_responder.mojom-shared.h"

#include "third_party/blink/public/mojom/ai/ai_language_model.mojom-data-view.h"

#include "mojo/public/cpp/bindings/lib/send_validation_type.h"
#include "mojo/public/cpp/bindings/lib/send_validation.h"
#include "mojo/public/cpp/bindings/lib/interface_serialization_send_validation.h"
#include "mojo/public/cpp/bindings/lib/has_send_validation_helper.h"

namespace mojo::internal {
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::blink::mojom::AILanguageModelPromptRole, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::blink::mojom::AILanguageModelPromptType, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::blink::mojom::AILanguageModelSamplingMode, MaybeConstUserType>
    : std::false_type {};

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

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

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

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

      decltype(Traits::default_sampling_params(input)) in_default_sampling_params = Traits::default_sampling_params(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->default_sampling_params)::BaseType> default_sampling_params_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::blink::mojom::AILanguageModelSamplingParamsDataView, send_validation>(
        in_default_sampling_params,
        default_sampling_params_fragment);

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

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

      decltype(Traits::max_sampling_params(input)) in_max_sampling_params = Traits::max_sampling_params(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->max_sampling_params)::BaseType> max_sampling_params_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::blink::mojom::AILanguageModelSamplingParamsDataView, send_validation>(
        in_max_sampling_params,
        max_sampling_params_fragment);

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

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

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

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

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

      decltype(Traits::sampling_params(input)) in_sampling_params = Traits::sampling_params(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->sampling_params)::BaseType> sampling_params_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::blink::mojom::AILanguageModelSamplingParamsDataView, send_validation>(
        in_sampling_params,
        sampling_params_fragment);

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

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

      decltype(Traits::input_types(input)) in_input_types = Traits::input_types(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->input_types)::BaseType>
          input_types_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& input_types_validate_params =
          mojo::internal::GetArrayOfEnumsValidator<0, false, ::blink::mojom::internal::AILanguageModelPromptType_Data::Validate>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<::blink::mojom::AILanguageModelPromptType>, send_validation>(
        in_input_types,
        input_types_fragment,
        &input_types_validate_params);

      fragment->input_types.Set(
          input_types_fragment.is_null() ? nullptr : input_types_fragment.data());
      fragment->audio_sample_rate_hz_$flag = Traits::audio_sample_rate_hz(input).has_value();
      if (Traits::audio_sample_rate_hz(input).has_value()) {
        fragment->audio_sample_rate_hz_$value = Traits::audio_sample_rate_hz(input).value();
      }
      fragment->audio_channel_count_$flag = Traits::audio_channel_count(input).has_value();
      if (Traits::audio_channel_count(input).has_value()) {
        fragment->audio_channel_count_$value = Traits::audio_channel_count(input).value();
      }
      fragment->sampling_mode_$flag = Traits::sampling_mode(input).has_value();
      if (Traits::sampling_mode(input).has_value()) {
        
        mojo::internal::Serialize<::blink::mojom::AILanguageModelSamplingMode>(
          Traits::sampling_mode(input).value(),
          &fragment->sampling_mode_$value);
      } else {
        fragment->sampling_mode_$value =
            static_cast<int32_t>(::blink::mojom::AILanguageModelSamplingMode::kMinValue);
      }
  }
};

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

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

      decltype(Traits::languages(input)) in_languages = Traits::languages(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->languages)::BaseType>
          languages_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& languages_validate_params =
          mojo::internal::GetArrayValidator<0, false, nullptr>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<::blink::mojom::AILanguageCodeDataView>, send_validation>(
        in_languages,
        languages_fragment,
        &languages_validate_params);

      fragment->languages.Set(
          languages_fragment.is_null() ? nullptr : languages_fragment.data());
  }
};

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

      
      mojo::internal::Serialize<::blink::mojom::AILanguageModelPromptRole>(
        Traits::role(input),
        &fragment->role);

      decltype(Traits::content(input)) in_content = Traits::content(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->content)::BaseType>
          content_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& content_validate_params =
          mojo::internal::GetArrayValidator<0, false, nullptr>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<::blink::mojom::AILanguageModelPromptContentDataView>, send_validation>(
        in_content,
        content_fragment,
        &content_validate_params);

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

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

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

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

      decltype(Traits::name(input)) in_name = Traits::name(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->name)::BaseType> name_fragment(
              fragment.message());
      
      mojo::internal::Serialize<mojo::StringDataView, send_validation>(
        in_name,
        name_fragment);

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

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

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

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

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

      decltype(Traits::input_schema(input)) in_input_schema = Traits::input_schema(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->input_schema)::BaseType> input_schema_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::mojo_base::mojom::DictionaryValueDataView, send_validation>(
        in_input_schema,
        input_schema_fragment);

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

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

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

      decltype(Traits::sampling_params(input)) in_sampling_params = Traits::sampling_params(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->sampling_params)::BaseType> sampling_params_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::blink::mojom::AILanguageModelSamplingParamsDataView, send_validation>(
        in_sampling_params,
        sampling_params_fragment);

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

      decltype(Traits::initial_prompts(input)) in_initial_prompts = Traits::initial_prompts(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->initial_prompts)::BaseType>
          initial_prompts_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& initial_prompts_validate_params =
          mojo::internal::GetArrayValidator<0, false, nullptr>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<::blink::mojom::AILanguageModelPromptDataView>, send_validation>(
        in_initial_prompts,
        initial_prompts_fragment,
        &initial_prompts_validate_params);

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

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

      decltype(Traits::expected_inputs(input)) in_expected_inputs = Traits::expected_inputs(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->expected_inputs)::BaseType>
          expected_inputs_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& expected_inputs_validate_params =
          mojo::internal::GetArrayValidator<0, false, nullptr>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<::blink::mojom::AILanguageModelExpectedDataView>, send_validation>(
        in_expected_inputs,
        expected_inputs_fragment,
        &expected_inputs_validate_params);

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

      decltype(Traits::expected_outputs(input)) in_expected_outputs = Traits::expected_outputs(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->expected_outputs)::BaseType>
          expected_outputs_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& expected_outputs_validate_params =
          mojo::internal::GetArrayValidator<0, false, nullptr>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<::blink::mojom::AILanguageModelExpectedDataView>, send_validation>(
        in_expected_outputs,
        expected_outputs_fragment,
        &expected_outputs_validate_params);

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

      decltype(Traits::tools(input)) in_tools = Traits::tools(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->tools)::BaseType>
          tools_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& tools_validate_params =
          mojo::internal::GetArrayValidator<0, false, nullptr>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<::blink::mojom::AILanguageModelToolDeclarationDataView>, send_validation>(
        in_tools,
        tools_fragment,
        &tools_validate_params);

      fragment->tools.Set(
          tools_fragment.is_null() ? nullptr : tools_fragment.data());
      fragment->sampling_mode_$flag = Traits::sampling_mode(input).has_value();
      if (Traits::sampling_mode(input).has_value()) {
        
        mojo::internal::Serialize<::blink::mojom::AILanguageModelSamplingMode>(
          Traits::sampling_mode(input).value(),
          &fragment->sampling_mode_$value);
      } else {
        fragment->sampling_mode_$value =
            static_cast<int32_t>(::blink::mojom::AILanguageModelSamplingMode::kMinValue);
      }
  }
};
template <typename MaybeConstUserType, SendValidation send_validation>
struct SendValidationSerializer<::blink::mojom::AILanguageModelPromptContentDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = UnionTraits<::blink::mojom::AILanguageModelPromptContentDataView, UserType>;
  static void Serialize(MaybeConstUserType& input,
                        MessageFragment<::blink::mojom::internal::AILanguageModelPromptContent_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 ::blink::mojom::AILanguageModelPromptContentDataView::Tag::kText: {
    decltype(Traits::text(input))
    in_text = Traits::text(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_text)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<mojo::StringDataView, send_validation>(
  in_text,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  send_validation,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null text in AILanguageModelPromptContent union");
    fragment->data.f_text.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
  case ::blink::mojom::AILanguageModelPromptContentDataView::Tag::kBitmap: {
    decltype(Traits::bitmap(input))
    in_bitmap = Traits::bitmap(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_bitmap)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<::skia::mojom::BitmapN32DataView, send_validation>(
  in_bitmap,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  send_validation,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null bitmap in AILanguageModelPromptContent union");
    fragment->data.f_bitmap.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
  case ::blink::mojom::AILanguageModelPromptContentDataView::Tag::kAudio: {
    decltype(Traits::audio(input))
    in_audio = Traits::audio(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_audio)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<::on_device_model::mojom::AudioDataDataView, send_validation>(
  in_audio,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  send_validation,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null audio in AILanguageModelPromptContent union");
    fragment->data.f_audio.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
  case ::blink::mojom::AILanguageModelPromptContentDataView::Tag::kToolCall: {
    decltype(Traits::tool_call(input))
    in_tool_call = Traits::tool_call(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_tool_call)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<::mojo_base::mojom::DictionaryValueDataView, send_validation>(
  in_tool_call,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  send_validation,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null tool_call in AILanguageModelPromptContent union");
    fragment->data.f_tool_call.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
  case ::blink::mojom::AILanguageModelPromptContentDataView::Tag::kToolResponse: {
    decltype(Traits::tool_response(input))
    in_tool_response = Traits::tool_response(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_tool_response)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<::mojo_base::mojom::DictionaryValueDataView, send_validation>(
  in_tool_response,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  send_validation,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null tool_response in AILanguageModelPromptContent union");
    fragment->data.f_tool_response.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
}
  }
};

}  // namespace mojo::internal

#endif  // THIRD_PARTY_BLINK_PUBLIC_MOJOM_AI_AI_LANGUAGE_MODEL_MOJOM_SEND_VALIDATION_H_