chromium/out/Default/gen/components/attribution_reporting/registration.mojom.h

// components/attribution_reporting/registration.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_ATTRIBUTION_REPORTING_REGISTRATION_MOJOM_H_
#define COMPONENTS_ATTRIBUTION_REPORTING_REGISTRATION_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/attribution_reporting/registration.mojom-features.h"  // IWYU pragma: export
#include "components/attribution_reporting/registration.mojom-shared.h"  // IWYU pragma: export
#include "components/attribution_reporting/registration.mojom-forward.h"  // IWYU pragma: export
#include "components/attribution_reporting/source_registration_time_config.mojom-forward.h"
#include "components/attribution_reporting/trigger_data_matching.mojom-forward.h"
#include "components/attribution_reporting/debug_types.mojom.h"
#include "mojo/public/mojom/base/int128.mojom.h"
#include "mojo/public/mojom/base/time.mojom.h"
#include "services/network/public/mojom/schemeful_site.mojom.h"
#include "url/mojom/origin.mojom.h"
#include "url/mojom/url.mojom.h"
#include <string>
#include <vector>




#include "components/attribution_reporting/registration_mojom_traits.h"




namespace attribution_reporting::mojom {























class  AggregatableValuesValue {};

// 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, AggregatableValuesValue::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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











class  SuitableOrigin {};

// 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, SuitableOrigin::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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





class  FilterData {};

// 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, FilterData::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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





class  FilterConfig {};

// 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, FilterConfig::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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





class  FilterPair {};

// 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, FilterPair::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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





class  AggregationKeys {};

// 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, AggregationKeys::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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





class  AggregatableTriggerData {};

// 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, AggregatableTriggerData::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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





class  DestinationSet {};

// 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, DestinationSet::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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





class  EventReportWindows {};

// 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, EventReportWindows::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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





class  TriggerSpec {};

// 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, TriggerSpec::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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





class  TriggerSpecs {};

// 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, TriggerSpecs::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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





class  AggregatableDebugReportingContribution {};

// 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, AggregatableDebugReportingContribution::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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





class  AggregatableDebugReportingConfig {};

// 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, AggregatableDebugReportingConfig::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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





class  SourceAggregatableDebugReportingConfig {};

// 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, SourceAggregatableDebugReportingConfig::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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





class  AttributionScopesSet {};

// 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, AttributionScopesSet::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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





class  AttributionScopesData {};

// 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, AttributionScopesData::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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





class  SourceRegistration {};

// 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, SourceRegistration::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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





class  EventTriggerData {};

// 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, EventTriggerData::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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





class  AggregatableDedupKey {};

// 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, AggregatableDedupKey::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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






class  AggregatableValues {};

// 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, AggregatableValues::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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





class  TriggerRegistration {};

// 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, TriggerRegistration::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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





class  OsRegistrationItem {};

// 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, OsRegistrationItem::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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





class  OsRegistration {};

// 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, OsRegistration::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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

template <typename StructPtrType>
SuitableOriginPtr SuitableOrigin::Clone() const {}

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

template <typename T, SuitableOrigin::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
FilterDataPtr FilterData::Clone() const {}

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

template <typename T, FilterData::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
FilterConfigPtr FilterConfig::Clone() const {}

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

template <typename T, FilterConfig::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
FilterPairPtr FilterPair::Clone() const {}

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

template <typename T, FilterPair::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
AggregationKeysPtr AggregationKeys::Clone() const {}

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

template <typename T, AggregationKeys::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
AggregatableTriggerDataPtr AggregatableTriggerData::Clone() const {}

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

template <typename T, AggregatableTriggerData::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
DestinationSetPtr DestinationSet::Clone() const {}

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

template <typename T, DestinationSet::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
EventReportWindowsPtr EventReportWindows::Clone() const {}

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

template <typename T, EventReportWindows::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
TriggerSpecPtr TriggerSpec::Clone() const {}

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

template <typename T, TriggerSpec::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
TriggerSpecsPtr TriggerSpecs::Clone() const {}

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

template <typename T, TriggerSpecs::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
AggregatableDebugReportingContributionPtr AggregatableDebugReportingContribution::Clone() const {}

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

template <typename T, AggregatableDebugReportingContribution::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
AggregatableDebugReportingConfigPtr AggregatableDebugReportingConfig::Clone() const {}

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

template <typename T, AggregatableDebugReportingConfig::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
SourceAggregatableDebugReportingConfigPtr SourceAggregatableDebugReportingConfig::Clone() const {}

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

template <typename T, SourceAggregatableDebugReportingConfig::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
AttributionScopesSetPtr AttributionScopesSet::Clone() const {}

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

template <typename T, AttributionScopesSet::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
AttributionScopesDataPtr AttributionScopesData::Clone() const {}

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

template <typename T, AttributionScopesData::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
SourceRegistrationPtr SourceRegistration::Clone() const {}

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

template <typename T, SourceRegistration::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
EventTriggerDataPtr EventTriggerData::Clone() const {}

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

template <typename T, EventTriggerData::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
AggregatableDedupKeyPtr AggregatableDedupKey::Clone() const {}

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

template <typename T, AggregatableDedupKey::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
AggregatableValuesValuePtr AggregatableValuesValue::Clone() const {}

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

template <typename T, AggregatableValuesValue::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
AggregatableValuesPtr AggregatableValues::Clone() const {}

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

template <typename T, AggregatableValues::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
TriggerRegistrationPtr TriggerRegistration::Clone() const {}

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

template <typename T, TriggerRegistration::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
OsRegistrationItemPtr OsRegistrationItem::Clone() const {}

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

template <typename T, OsRegistrationItem::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
OsRegistrationPtr OsRegistration::Clone() const {}

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

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


}  // attribution_reporting::mojom

namespace mojo {


template <>
struct  StructTraits<::attribution_reporting::mojom::SuitableOrigin::DataView,
                                         ::attribution_reporting::mojom::SuitableOriginPtr> {};


template <>
struct  StructTraits<::attribution_reporting::mojom::FilterData::DataView,
                                         ::attribution_reporting::mojom::FilterDataPtr> {};


template <>
struct  StructTraits<::attribution_reporting::mojom::FilterConfig::DataView,
                                         ::attribution_reporting::mojom::FilterConfigPtr> {};


template <>
struct  StructTraits<::attribution_reporting::mojom::FilterPair::DataView,
                                         ::attribution_reporting::mojom::FilterPairPtr> {};


template <>
struct  StructTraits<::attribution_reporting::mojom::AggregationKeys::DataView,
                                         ::attribution_reporting::mojom::AggregationKeysPtr> {};


template <>
struct  StructTraits<::attribution_reporting::mojom::AggregatableTriggerData::DataView,
                                         ::attribution_reporting::mojom::AggregatableTriggerDataPtr> {};


template <>
struct  StructTraits<::attribution_reporting::mojom::DestinationSet::DataView,
                                         ::attribution_reporting::mojom::DestinationSetPtr> {};


template <>
struct  StructTraits<::attribution_reporting::mojom::EventReportWindows::DataView,
                                         ::attribution_reporting::mojom::EventReportWindowsPtr> {};


template <>
struct  StructTraits<::attribution_reporting::mojom::TriggerSpec::DataView,
                                         ::attribution_reporting::mojom::TriggerSpecPtr> {};


template <>
struct  StructTraits<::attribution_reporting::mojom::TriggerSpecs::DataView,
                                         ::attribution_reporting::mojom::TriggerSpecsPtr> {};


template <>
struct  StructTraits<::attribution_reporting::mojom::AggregatableDebugReportingContribution::DataView,
                                         ::attribution_reporting::mojom::AggregatableDebugReportingContributionPtr> {};


template <>
struct  StructTraits<::attribution_reporting::mojom::AggregatableDebugReportingConfig::DataView,
                                         ::attribution_reporting::mojom::AggregatableDebugReportingConfigPtr> {};


template <>
struct  StructTraits<::attribution_reporting::mojom::SourceAggregatableDebugReportingConfig::DataView,
                                         ::attribution_reporting::mojom::SourceAggregatableDebugReportingConfigPtr> {};


template <>
struct  StructTraits<::attribution_reporting::mojom::AttributionScopesSet::DataView,
                                         ::attribution_reporting::mojom::AttributionScopesSetPtr> {};


template <>
struct  StructTraits<::attribution_reporting::mojom::AttributionScopesData::DataView,
                                         ::attribution_reporting::mojom::AttributionScopesDataPtr> {};


template <>
struct  StructTraits<::attribution_reporting::mojom::SourceRegistration::DataView,
                                         ::attribution_reporting::mojom::SourceRegistrationPtr> {};


template <>
struct  StructTraits<::attribution_reporting::mojom::EventTriggerData::DataView,
                                         ::attribution_reporting::mojom::EventTriggerDataPtr> {};


template <>
struct  StructTraits<::attribution_reporting::mojom::AggregatableDedupKey::DataView,
                                         ::attribution_reporting::mojom::AggregatableDedupKeyPtr> {};


template <>
struct  StructTraits<::attribution_reporting::mojom::AggregatableValuesValue::DataView,
                                         ::attribution_reporting::mojom::AggregatableValuesValuePtr> {};


template <>
struct  StructTraits<::attribution_reporting::mojom::AggregatableValues::DataView,
                                         ::attribution_reporting::mojom::AggregatableValuesPtr> {};


template <>
struct  StructTraits<::attribution_reporting::mojom::TriggerRegistration::DataView,
                                         ::attribution_reporting::mojom::TriggerRegistrationPtr> {};


template <>
struct  StructTraits<::attribution_reporting::mojom::OsRegistrationItem::DataView,
                                         ::attribution_reporting::mojom::OsRegistrationItemPtr> {};


template <>
struct  StructTraits<::attribution_reporting::mojom::OsRegistration::DataView,
                                         ::attribution_reporting::mojom::OsRegistrationPtr> {};

}  // namespace mojo

#endif  // COMPONENTS_ATTRIBUTION_REPORTING_REGISTRATION_MOJOM_H_