// third_party/blink/public/mojom/safe_url_pattern.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_SAFE_URL_PATTERN_MOJOM_SEND_VALIDATION_H_
#define THIRD_PARTY_BLINK_PUBLIC_MOJOM_SAFE_URL_PATTERN_MOJOM_SEND_VALIDATION_H_

#include "third_party/blink/public/mojom/safe_url_pattern.mojom-shared-internal.h"

#include "third_party/blink/public/mojom/safe_url_pattern.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/has_send_validation_helper.h"

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

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

      decltype(Traits::protocol(input)) in_protocol = Traits::protocol(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->protocol)::BaseType>
          protocol_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& protocol_validate_params =
          mojo::internal::GetArrayValidator<0, false, nullptr>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<::blink::mojom::SafeUrlPatternPartDataView>, send_validation>(
        in_protocol,
        protocol_fragment,
        &protocol_validate_params);

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

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

      decltype(Traits::username(input)) in_username = Traits::username(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->username)::BaseType>
          username_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& username_validate_params =
          mojo::internal::GetArrayValidator<0, false, nullptr>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<::blink::mojom::SafeUrlPatternPartDataView>, send_validation>(
        in_username,
        username_fragment,
        &username_validate_params);

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

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

      decltype(Traits::password(input)) in_password = Traits::password(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->password)::BaseType>
          password_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& password_validate_params =
          mojo::internal::GetArrayValidator<0, false, nullptr>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<::blink::mojom::SafeUrlPatternPartDataView>, send_validation>(
        in_password,
        password_fragment,
        &password_validate_params);

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

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

      decltype(Traits::hostname(input)) in_hostname = Traits::hostname(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->hostname)::BaseType>
          hostname_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& hostname_validate_params =
          mojo::internal::GetArrayValidator<0, false, nullptr>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<::blink::mojom::SafeUrlPatternPartDataView>, send_validation>(
        in_hostname,
        hostname_fragment,
        &hostname_validate_params);

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

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

      decltype(Traits::port(input)) in_port = Traits::port(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->port)::BaseType>
          port_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& port_validate_params =
          mojo::internal::GetArrayValidator<0, false, nullptr>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<::blink::mojom::SafeUrlPatternPartDataView>, send_validation>(
        in_port,
        port_fragment,
        &port_validate_params);

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

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

      decltype(Traits::pathname(input)) in_pathname = Traits::pathname(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->pathname)::BaseType>
          pathname_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& pathname_validate_params =
          mojo::internal::GetArrayValidator<0, false, nullptr>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<::blink::mojom::SafeUrlPatternPartDataView>, send_validation>(
        in_pathname,
        pathname_fragment,
        &pathname_validate_params);

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

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

      decltype(Traits::search(input)) in_search = Traits::search(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->search)::BaseType>
          search_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& search_validate_params =
          mojo::internal::GetArrayValidator<0, false, nullptr>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<::blink::mojom::SafeUrlPatternPartDataView>, send_validation>(
        in_search,
        search_fragment,
        &search_validate_params);

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

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

      decltype(Traits::hash(input)) in_hash = Traits::hash(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->hash)::BaseType>
          hash_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& hash_validate_params =
          mojo::internal::GetArrayValidator<0, false, nullptr>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<::blink::mojom::SafeUrlPatternPartDataView>, send_validation>(
        in_hash,
        hash_fragment,
        &hash_validate_params);

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

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

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

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

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

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

      decltype(Traits::value(input)) in_value = Traits::value(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->value)::BaseType> value_fragment(
              fragment.message());
      
      mojo::internal::Serialize<mojo::StringDataView, send_validation>(
        in_value,
        value_fragment);

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

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

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

      decltype(Traits::prefix(input)) in_prefix = Traits::prefix(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->prefix)::BaseType> prefix_fragment(
              fragment.message());
      
      mojo::internal::Serialize<mojo::StringDataView, send_validation>(
        in_prefix,
        prefix_fragment);

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

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

      decltype(Traits::value(input)) in_value = Traits::value(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->value)::BaseType> value_fragment(
              fragment.message());
      
      mojo::internal::Serialize<mojo::StringDataView, send_validation>(
        in_value,
        value_fragment);

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

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

      decltype(Traits::suffix(input)) in_suffix = Traits::suffix(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->suffix)::BaseType> suffix_fragment(
              fragment.message());
      
      mojo::internal::Serialize<mojo::StringDataView, send_validation>(
        in_suffix,
        suffix_fragment);

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

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

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

      decltype(Traits::pattern(input)) in_pattern = Traits::pattern(input);
      mojo::internal::MessageFragment<decltype(fragment->pattern)>
          pattern_fragment(fragment.message());
      pattern_fragment.Claim(&fragment->pattern);
      
      mojo::internal::Serialize<::blink::mojom::PatternTemplateDataView, send_validation>(
        in_pattern,
        pattern_fragment,
        true);

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

      
      mojo::internal::Serialize<::blink::mojom::Modifier>(
        Traits::modifier(input),
        &fragment->modifier);
  }
};

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

      fragment->ignore_case = Traits::ignore_case(input);
  }
};
template <typename MaybeConstUserType, SendValidation send_validation>
struct SendValidationSerializer<::blink::mojom::PatternTemplateDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = UnionTraits<::blink::mojom::PatternTemplateDataView, UserType>;
  static void Serialize(MaybeConstUserType& input,
                        MessageFragment<::blink::mojom::internal::PatternTemplate_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::PatternTemplateDataView::Tag::kFixed: {
    decltype(Traits::fixed(input))
    in_fixed = Traits::fixed(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_fixed)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<::blink::mojom::FixedPatternDataView, send_validation>(
  in_fixed,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  send_validation,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null fixed in PatternTemplate union");
    fragment->data.f_fixed.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
  case ::blink::mojom::PatternTemplateDataView::Tag::kFullWildcard: {
    decltype(Traits::full_wildcard(input))
    in_full_wildcard = Traits::full_wildcard(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_full_wildcard)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<::blink::mojom::WildcardPatternDataView, send_validation>(
  in_full_wildcard,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  send_validation,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null full_wildcard in PatternTemplate union");
    fragment->data.f_full_wildcard.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
  case ::blink::mojom::PatternTemplateDataView::Tag::kSegmentWildcard: {
    decltype(Traits::segment_wildcard(input))
    in_segment_wildcard = Traits::segment_wildcard(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_segment_wildcard)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<::blink::mojom::WildcardPatternDataView, send_validation>(
  in_segment_wildcard,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  send_validation,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null segment_wildcard in PatternTemplate union");
    fragment->data.f_segment_wildcard.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
}
  }
};

}  // namespace mojo::internal

#endif  // THIRD_PARTY_BLINK_PUBLIC_MOJOM_SAFE_URL_PATTERN_MOJOM_SEND_VALIDATION_H_