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

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

#include "mojo/public/cpp/bindings/lib/wtf_clone_equals_util.h"
#include "mojo/public/cpp/bindings/lib/wtf_hash_util.h"
#include "third_party/blink/renderer/platform/wtf/hash_functions.h"
#include "third_party/blink/renderer/platform/wtf/text/wtf_string.h"




#include "components/attribution_reporting/registration_mojom_traits.h"
#include "third_party/blink/renderer/platform/platform_export.h"




namespace attribution_reporting::mojom::blink {























class PLATFORM_EXPORT 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 PLATFORM_EXPORT 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 PLATFORM_EXPORT 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 PLATFORM_EXPORT 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 PLATFORM_EXPORT 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 PLATFORM_EXPORT 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 PLATFORM_EXPORT 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 PLATFORM_EXPORT 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 PLATFORM_EXPORT 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 PLATFORM_EXPORT 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 PLATFORM_EXPORT 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 PLATFORM_EXPORT 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 PLATFORM_EXPORT 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 PLATFORM_EXPORT 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 PLATFORM_EXPORT 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 PLATFORM_EXPORT 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 PLATFORM_EXPORT 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 PLATFORM_EXPORT 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 PLATFORM_EXPORT 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 PLATFORM_EXPORT 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 PLATFORM_EXPORT 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 PLATFORM_EXPORT 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 PLATFORM_EXPORT 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::blink

namespace mojo {


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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

}  // namespace mojo

#endif  // COMPONENTS_ATTRIBUTION_REPORTING_REGISTRATION_MOJOM_BLINK_H_