// services/network/public/mojom/proxy_config.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 SERVICES_NETWORK_PUBLIC_MOJOM_PROXY_CONFIG_MOJOM_SEND_VALIDATION_H_
#define SERVICES_NETWORK_PUBLIC_MOJOM_PROXY_CONFIG_MOJOM_SEND_VALIDATION_H_

#include "services/network/public/mojom/proxy_config.mojom-shared-internal.h"
#include "mojo/public/mojom/base/big_string.mojom-shared.h"
#include "mojo/public/mojom/base/time.mojom-shared.h"
#include "services/network/public/mojom/network_param.mojom-shared.h"
#include "url/mojom/scheme_host_port.mojom-shared.h"

#include "services/network/public/mojom/proxy_config.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<::network::mojom::ProxyRulesType, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::network::mojom::ProxyOverrideRuleResult, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::network::mojom::IpProtectionProxyBypassPolicy, MaybeConstUserType>
    : std::false_type {};

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

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

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

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

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

      decltype(Traits::proxies(input)) in_proxies = Traits::proxies(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->proxies)::BaseType>
          proxies_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& proxies_validate_params =
          mojo::internal::GetArrayValidator<0, false, nullptr>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<::network::mojom::ProxyChainDataView>, send_validation>(
        in_proxies,
        proxies_fragment,
        &proxies_validate_params);

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

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

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

      decltype(Traits::bypass_rules(input)) in_bypass_rules = Traits::bypass_rules(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->bypass_rules)::BaseType> bypass_rules_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::network::mojom::ProxyHostMatchingRulesDataView, send_validation>(
        in_bypass_rules,
        bypass_rules_fragment);

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

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

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

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

      decltype(Traits::single_proxies(input)) in_single_proxies = Traits::single_proxies(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->single_proxies)::BaseType> single_proxies_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::network::mojom::ProxyListDataView, send_validation>(
        in_single_proxies,
        single_proxies_fragment);

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

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

      decltype(Traits::proxies_for_http(input)) in_proxies_for_http = Traits::proxies_for_http(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->proxies_for_http)::BaseType> proxies_for_http_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::network::mojom::ProxyListDataView, send_validation>(
        in_proxies_for_http,
        proxies_for_http_fragment);

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

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

      decltype(Traits::proxies_for_https(input)) in_proxies_for_https = Traits::proxies_for_https(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->proxies_for_https)::BaseType> proxies_for_https_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::network::mojom::ProxyListDataView, send_validation>(
        in_proxies_for_https,
        proxies_for_https_fragment);

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

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

      decltype(Traits::proxies_for_ftp(input)) in_proxies_for_ftp = Traits::proxies_for_ftp(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->proxies_for_ftp)::BaseType> proxies_for_ftp_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::network::mojom::ProxyListDataView, send_validation>(
        in_proxies_for_ftp,
        proxies_for_ftp_fragment);

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

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

      decltype(Traits::fallback_proxies(input)) in_fallback_proxies = Traits::fallback_proxies(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->fallback_proxies)::BaseType> fallback_proxies_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::network::mojom::ProxyListDataView, send_validation>(
        in_fallback_proxies,
        fallback_proxies_fragment);

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

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

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

      decltype(Traits::host(input)) in_host = Traits::host(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->host)::BaseType> host_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::url::mojom::SchemeHostPortDataView, send_validation>(
        in_host,
        host_fragment);

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

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

      
      mojo::internal::Serialize<::network::mojom::ProxyOverrideRuleResult>(
        Traits::result(input),
        &fragment->result);
  }
};

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

      decltype(Traits::destination_matchers(input)) in_destination_matchers = Traits::destination_matchers(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->destination_matchers)::BaseType> destination_matchers_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::network::mojom::ProxyHostMatchingRulesDataView, send_validation>(
        in_destination_matchers,
        destination_matchers_fragment);

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

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

      decltype(Traits::exclude_destination_matchers(input)) in_exclude_destination_matchers = Traits::exclude_destination_matchers(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->exclude_destination_matchers)::BaseType> exclude_destination_matchers_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::network::mojom::ProxyHostMatchingRulesDataView, send_validation>(
        in_exclude_destination_matchers,
        exclude_destination_matchers_fragment);

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

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

      decltype(Traits::dns_conditions(input)) in_dns_conditions = Traits::dns_conditions(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->dns_conditions)::BaseType>
          dns_conditions_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& dns_conditions_validate_params =
          mojo::internal::GetArrayValidator<0, false, nullptr>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<::network::mojom::DnsProbeConditionDataView>, send_validation>(
        in_dns_conditions,
        dns_conditions_fragment,
        &dns_conditions_validate_params);

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

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

      decltype(Traits::proxy_list(input)) in_proxy_list = Traits::proxy_list(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->proxy_list)::BaseType> proxy_list_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::network::mojom::ProxyListDataView, send_validation>(
        in_proxy_list,
        proxy_list_fragment);

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

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

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

      decltype(Traits::destination_matchers(input)) in_destination_matchers = Traits::destination_matchers(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->destination_matchers)::BaseType> destination_matchers_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::network::mojom::ProxyHostMatchingRulesDataView, send_validation>(
        in_destination_matchers,
        destination_matchers_fragment);

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

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

      decltype(Traits::proxy_list(input)) in_proxy_list = Traits::proxy_list(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->proxy_list)::BaseType> proxy_list_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::network::mojom::ProxyListDataView, send_validation>(
        in_proxy_list,
        proxy_list_fragment);

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

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

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

      decltype(Traits::routing_rules(input)) in_routing_rules = Traits::routing_rules(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->routing_rules)::BaseType>
          routing_rules_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& routing_rules_validate_params =
          mojo::internal::GetArrayValidator<0, false, nullptr>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<::network::mojom::DynamicRoutingRuleDataView>, send_validation>(
        in_routing_rules,
        routing_rules_fragment,
        &routing_rules_validate_params);

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

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

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

      decltype(Traits::proxy_override_rules(input)) in_proxy_override_rules = Traits::proxy_override_rules(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->proxy_override_rules)::BaseType>
          proxy_override_rules_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& proxy_override_rules_validate_params =
          mojo::internal::GetArrayValidator<0, false, nullptr>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<::network::mojom::ProxyOverrideRuleDataView>, send_validation>(
        in_proxy_override_rules,
        proxy_override_rules_fragment,
        &proxy_override_rules_validate_params);

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

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

      decltype(Traits::dynamic_routing_config(input)) in_dynamic_routing_config = Traits::dynamic_routing_config(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->dynamic_routing_config)::BaseType> dynamic_routing_config_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::network::mojom::DynamicRoutingConfigDataView, send_validation>(
        in_dynamic_routing_config,
        dynamic_routing_config_fragment);

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

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

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

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

      decltype(Traits::pac_url(input)) in_pac_url = Traits::pac_url(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->pac_url)::BaseType> pac_url_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::mojo_base::mojom::BigStringDataView, send_validation>(
        in_pac_url,
        pac_url_fragment);

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

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

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

      decltype(Traits::proxy_rules(input)) in_proxy_rules = Traits::proxy_rules(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->proxy_rules)::BaseType> proxy_rules_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::network::mojom::ProxyRulesDataView, send_validation>(
        in_proxy_rules,
        proxy_rules_fragment);

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

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

}  // namespace mojo::internal

#endif  // SERVICES_NETWORK_PUBLIC_MOJOM_PROXY_CONFIG_MOJOM_SEND_VALIDATION_H_