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_