chromium/out/Default/gen/components/autofill/core/common/mojom/autofill_types.mojom.h

// components/autofill/core/common/mojom/autofill_types.mojom.h is auto generated by mojom_bindings_generator.py, do not edit

// Copyright 2013 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_AUTOFILL_CORE_COMMON_MOJOM_AUTOFILL_TYPES_MOJOM_H_
#define COMPONENTS_AUTOFILL_CORE_COMMON_MOJOM_AUTOFILL_TYPES_MOJOM_H_

#include <stdint.h>

#include <limits>
#include <optional>
#include <type_traits>
#include <utility>

#include "base/types/cxx23_to_underlying.h"
#include "mojo/public/cpp/bindings/clone_traits.h"
#include "mojo/public/cpp/bindings/equals_traits.h"
#include "mojo/public/cpp/bindings/lib/serialization.h"
#include "mojo/public/cpp/bindings/struct_ptr.h"
#include "mojo/public/cpp/bindings/struct_traits.h"
#include "mojo/public/cpp/bindings/union_traits.h"

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

#include "components/autofill/core/common/mojom/autofill_types.mojom-features.h"  // IWYU pragma: export
#include "components/autofill/core/common/mojom/autofill_types.mojom-shared.h"  // IWYU pragma: export
#include "components/autofill/core/common/mojom/autofill_types.mojom-forward.h"  // IWYU pragma: export
#include "mojo/public/mojom/base/text_direction.mojom.h"
#include "mojo/public/mojom/base/time.mojom-forward.h"
#include "mojo/public/mojom/base/string16.mojom.h"
#include "mojo/public/mojom/base/unguessable_token.mojom.h"
#include "ui/gfx/geometry/mojom/geometry.mojom.h"
#include "url/mojom/url.mojom.h"
#include <string>
#include <vector>




#include "components/autofill/core/common/mojom/autofill_types_mojom_traits.h"




namespace autofill::mojom {







class  FormRendererId {};

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, FormRendererId::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, FormRendererId::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {}

template <typename T, FormRendererId::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {}

template <typename T, FormRendererId::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {}





class  FieldRendererId {};

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, FieldRendererId::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, FieldRendererId::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {}

template <typename T, FieldRendererId::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {}

template <typename T, FieldRendererId::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {}






class  SectionAutocomplete {};

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, SectionAutocomplete::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, SectionAutocomplete::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {}

template <typename T, SectionAutocomplete::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {}

template <typename T, SectionAutocomplete::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {}







class  AutocompleteParsingResult {};

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, AutocompleteParsingResult::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, AutocompleteParsingResult::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {}

template <typename T, AutocompleteParsingResult::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {}

template <typename T, AutocompleteParsingResult::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {}

















class  SectionValue {};





class  FrameToken {};

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, FrameToken::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, FrameToken::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {}

template <typename T, FrameToken::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {}

template <typename T, FrameToken::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {}





class  FrameTokenWithPredecessor {};

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, FrameTokenWithPredecessor::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, FrameTokenWithPredecessor::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {}

template <typename T, FrameTokenWithPredecessor::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {}

template <typename T, FrameTokenWithPredecessor::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {}







class  SelectOption {};

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, SelectOption::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, SelectOption::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {}

template <typename T, SelectOption::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {}

template <typename T, SelectOption::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {}






class  SectionFieldIdentifier {};

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, SectionFieldIdentifier::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, SectionFieldIdentifier::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {}

template <typename T, SectionFieldIdentifier::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {}

template <typename T, SectionFieldIdentifier::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {}





class  Section {};

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, Section::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, Section::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {}

template <typename T, Section::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {}

template <typename T, Section::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {}






class  FormFieldData {};

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, FormFieldData::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, FormFieldData::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {}

template <typename T, FormFieldData::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {}

template <typename T, FormFieldData::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {}





class  FormFieldData_FillData {};

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, FormFieldData_FillData::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, FormFieldData_FillData::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {}

template <typename T, FormFieldData_FillData::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {}

template <typename T, FormFieldData_FillData::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {}





class  ButtonTitleInfo {};

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, ButtonTitleInfo::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, ButtonTitleInfo::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {}

template <typename T, ButtonTitleInfo::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {}

template <typename T, ButtonTitleInfo::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {}





class  FormData {};

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, FormData::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, FormData::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {}

template <typename T, FormData::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {}

template <typename T, FormData::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {}





class  FormFieldDataPredictions {};

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, FormFieldDataPredictions::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, FormFieldDataPredictions::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {}

template <typename T, FormFieldDataPredictions::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {}

template <typename T, FormFieldDataPredictions::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {}





class  FormDataPredictions {};

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, FormDataPredictions::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, FormDataPredictions::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {}

template <typename T, FormDataPredictions::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {}

template <typename T, FormDataPredictions::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {}





class  PasswordAndMetadata {};

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, PasswordAndMetadata::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, PasswordAndMetadata::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {}

template <typename T, PasswordAndMetadata::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {}

template <typename T, PasswordAndMetadata::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {}





class  PasswordFormFillData {};

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, PasswordFormFillData::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, PasswordFormFillData::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {}

template <typename T, PasswordFormFillData::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {}

template <typename T, PasswordFormFillData::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {}





class  PasswordFormGenerationData {};

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, PasswordFormGenerationData::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, PasswordFormGenerationData::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {}

template <typename T, PasswordFormGenerationData::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {}

template <typename T, PasswordFormGenerationData::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {}





class  PasswordGenerationUIData {};

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, PasswordGenerationUIData::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, PasswordGenerationUIData::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {}

template <typename T, PasswordGenerationUIData::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {}

template <typename T, PasswordGenerationUIData::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {}





class  PasswordSuggestionRequest {};

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, PasswordSuggestionRequest::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, PasswordSuggestionRequest::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {}

template <typename T, PasswordSuggestionRequest::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {}

template <typename T, PasswordSuggestionRequest::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {}





class  ParsingResult {};

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, ParsingResult::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, ParsingResult::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {}

template <typename T, ParsingResult::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {}

template <typename T, ParsingResult::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {}

template <typename UnionPtrType>
SectionValuePtr SectionValue::Clone() const {}

template <typename T,
          typename std::enable_if<std::is_same<
              T, SectionValue>::value>::type*>
bool SectionValue::Equals(const T& other) const {}
template <typename StructPtrType>
FrameTokenPtr FrameToken::Clone() const {}

template <typename T, FrameToken::EnableIfSame<T>*>
bool FrameToken::Equals(const T& other_struct) const {}

template <typename T, FrameToken::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
FrameTokenWithPredecessorPtr FrameTokenWithPredecessor::Clone() const {}

template <typename T, FrameTokenWithPredecessor::EnableIfSame<T>*>
bool FrameTokenWithPredecessor::Equals(const T& other_struct) const {}

template <typename T, FrameTokenWithPredecessor::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
FormRendererIdPtr FormRendererId::Clone() const {}

template <typename T, FormRendererId::EnableIfSame<T>*>
bool FormRendererId::Equals(const T& other_struct) const {}

template <typename T, FormRendererId::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
FieldRendererIdPtr FieldRendererId::Clone() const {}

template <typename T, FieldRendererId::EnableIfSame<T>*>
bool FieldRendererId::Equals(const T& other_struct) const {}

template <typename T, FieldRendererId::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
SelectOptionPtr SelectOption::Clone() const {}

template <typename T, SelectOption::EnableIfSame<T>*>
bool SelectOption::Equals(const T& other_struct) const {}

template <typename T, SelectOption::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
SectionAutocompletePtr SectionAutocomplete::Clone() const {}

template <typename T, SectionAutocomplete::EnableIfSame<T>*>
bool SectionAutocomplete::Equals(const T& other_struct) const {}

template <typename T, SectionAutocomplete::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
SectionFieldIdentifierPtr SectionFieldIdentifier::Clone() const {}

template <typename T, SectionFieldIdentifier::EnableIfSame<T>*>
bool SectionFieldIdentifier::Equals(const T& other_struct) const {}

template <typename T, SectionFieldIdentifier::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
SectionPtr Section::Clone() const {}

template <typename T, Section::EnableIfSame<T>*>
bool Section::Equals(const T& other_struct) const {}

template <typename T, Section::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
AutocompleteParsingResultPtr AutocompleteParsingResult::Clone() const {}

template <typename T, AutocompleteParsingResult::EnableIfSame<T>*>
bool AutocompleteParsingResult::Equals(const T& other_struct) const {}

template <typename T, AutocompleteParsingResult::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
FormFieldDataPtr FormFieldData::Clone() const {}

template <typename T, FormFieldData::EnableIfSame<T>*>
bool FormFieldData::Equals(const T& other_struct) const {}

template <typename T, FormFieldData::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
FormFieldData_FillDataPtr FormFieldData_FillData::Clone() const {}

template <typename T, FormFieldData_FillData::EnableIfSame<T>*>
bool FormFieldData_FillData::Equals(const T& other_struct) const {}

template <typename T, FormFieldData_FillData::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
ButtonTitleInfoPtr ButtonTitleInfo::Clone() const {}

template <typename T, ButtonTitleInfo::EnableIfSame<T>*>
bool ButtonTitleInfo::Equals(const T& other_struct) const {}

template <typename T, ButtonTitleInfo::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
FormDataPtr FormData::Clone() const {}

template <typename T, FormData::EnableIfSame<T>*>
bool FormData::Equals(const T& other_struct) const {}

template <typename T, FormData::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
FormFieldDataPredictionsPtr FormFieldDataPredictions::Clone() const {}

template <typename T, FormFieldDataPredictions::EnableIfSame<T>*>
bool FormFieldDataPredictions::Equals(const T& other_struct) const {}

template <typename T, FormFieldDataPredictions::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
FormDataPredictionsPtr FormDataPredictions::Clone() const {}

template <typename T, FormDataPredictions::EnableIfSame<T>*>
bool FormDataPredictions::Equals(const T& other_struct) const {}

template <typename T, FormDataPredictions::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
PasswordAndMetadataPtr PasswordAndMetadata::Clone() const {}

template <typename T, PasswordAndMetadata::EnableIfSame<T>*>
bool PasswordAndMetadata::Equals(const T& other_struct) const {}

template <typename T, PasswordAndMetadata::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
PasswordFormFillDataPtr PasswordFormFillData::Clone() const {}

template <typename T, PasswordFormFillData::EnableIfSame<T>*>
bool PasswordFormFillData::Equals(const T& other_struct) const {}

template <typename T, PasswordFormFillData::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
PasswordFormGenerationDataPtr PasswordFormGenerationData::Clone() const {}

template <typename T, PasswordFormGenerationData::EnableIfSame<T>*>
bool PasswordFormGenerationData::Equals(const T& other_struct) const {}

template <typename T, PasswordFormGenerationData::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
PasswordGenerationUIDataPtr PasswordGenerationUIData::Clone() const {}

template <typename T, PasswordGenerationUIData::EnableIfSame<T>*>
bool PasswordGenerationUIData::Equals(const T& other_struct) const {}

template <typename T, PasswordGenerationUIData::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
PasswordSuggestionRequestPtr PasswordSuggestionRequest::Clone() const {}

template <typename T, PasswordSuggestionRequest::EnableIfSame<T>*>
bool PasswordSuggestionRequest::Equals(const T& other_struct) const {}

template <typename T, PasswordSuggestionRequest::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
ParsingResultPtr ParsingResult::Clone() const {}

template <typename T, ParsingResult::EnableIfSame<T>*>
bool ParsingResult::Equals(const T& other_struct) const {}

template <typename T, ParsingResult::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}


}  // autofill::mojom

namespace mojo {


template <>
struct  StructTraits<::autofill::mojom::FrameToken::DataView,
                                         ::autofill::mojom::FrameTokenPtr> {};


template <>
struct  StructTraits<::autofill::mojom::FrameTokenWithPredecessor::DataView,
                                         ::autofill::mojom::FrameTokenWithPredecessorPtr> {};


template <>
struct  StructTraits<::autofill::mojom::FormRendererId::DataView,
                                         ::autofill::mojom::FormRendererIdPtr> {};


template <>
struct  StructTraits<::autofill::mojom::FieldRendererId::DataView,
                                         ::autofill::mojom::FieldRendererIdPtr> {};


template <>
struct  StructTraits<::autofill::mojom::SelectOption::DataView,
                                         ::autofill::mojom::SelectOptionPtr> {};


template <>
struct  StructTraits<::autofill::mojom::SectionAutocomplete::DataView,
                                         ::autofill::mojom::SectionAutocompletePtr> {};


template <>
struct  StructTraits<::autofill::mojom::SectionFieldIdentifier::DataView,
                                         ::autofill::mojom::SectionFieldIdentifierPtr> {};


template <>
struct  StructTraits<::autofill::mojom::Section::DataView,
                                         ::autofill::mojom::SectionPtr> {};


template <>
struct  StructTraits<::autofill::mojom::AutocompleteParsingResult::DataView,
                                         ::autofill::mojom::AutocompleteParsingResultPtr> {};


template <>
struct  StructTraits<::autofill::mojom::FormFieldData::DataView,
                                         ::autofill::mojom::FormFieldDataPtr> {};


template <>
struct  StructTraits<::autofill::mojom::FormFieldData_FillData::DataView,
                                         ::autofill::mojom::FormFieldData_FillDataPtr> {};


template <>
struct  StructTraits<::autofill::mojom::ButtonTitleInfo::DataView,
                                         ::autofill::mojom::ButtonTitleInfoPtr> {};


template <>
struct  StructTraits<::autofill::mojom::FormData::DataView,
                                         ::autofill::mojom::FormDataPtr> {};


template <>
struct  StructTraits<::autofill::mojom::FormFieldDataPredictions::DataView,
                                         ::autofill::mojom::FormFieldDataPredictionsPtr> {};


template <>
struct  StructTraits<::autofill::mojom::FormDataPredictions::DataView,
                                         ::autofill::mojom::FormDataPredictionsPtr> {};


template <>
struct  StructTraits<::autofill::mojom::PasswordAndMetadata::DataView,
                                         ::autofill::mojom::PasswordAndMetadataPtr> {};


template <>
struct  StructTraits<::autofill::mojom::PasswordFormFillData::DataView,
                                         ::autofill::mojom::PasswordFormFillDataPtr> {};


template <>
struct  StructTraits<::autofill::mojom::PasswordFormGenerationData::DataView,
                                         ::autofill::mojom::PasswordFormGenerationDataPtr> {};


template <>
struct  StructTraits<::autofill::mojom::PasswordGenerationUIData::DataView,
                                         ::autofill::mojom::PasswordGenerationUIDataPtr> {};


template <>
struct  StructTraits<::autofill::mojom::PasswordSuggestionRequest::DataView,
                                         ::autofill::mojom::PasswordSuggestionRequestPtr> {};


template <>
struct  StructTraits<::autofill::mojom::ParsingResult::DataView,
                                         ::autofill::mojom::ParsingResultPtr> {};


template <>
struct  UnionTraits<::autofill::mojom::SectionValue::DataView,
                                        ::autofill::mojom::SectionValuePtr> {};

}  // namespace mojo

#endif  // COMPONENTS_AUTOFILL_CORE_COMMON_MOJOM_AUTOFILL_TYPES_MOJOM_H_