chromium/out/Default/gen/third_party/blink/public/mojom/tokens/tokens.mojom-blink.h

// third_party/blink/public/mojom/tokens/tokens.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 THIRD_PARTY_BLINK_PUBLIC_MOJOM_TOKENS_TOKENS_MOJOM_BLINK_H_
#define THIRD_PARTY_BLINK_PUBLIC_MOJOM_TOKENS_TOKENS_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 "third_party/blink/public/mojom/tokens/tokens.mojom-features.h"  // IWYU pragma: export
#include "third_party/blink/public/mojom/tokens/tokens.mojom-shared.h"  // IWYU pragma: export
#include "third_party/blink/public/mojom/tokens/tokens.mojom-blink-forward.h"  // IWYU pragma: export
#include "mojo/public/mojom/base/unguessable_token.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 "third_party/blink/public/common/tokens/token_mojom_traits_helper.h"
#include "third_party/blink/public/common/tokens/tokens_mojom_traits.h"
#include "third_party/blink/renderer/platform/platform_export.h"




namespace blink::mojom::blink {
























class PLATFORM_EXPORT FrameToken { … };



class PLATFORM_EXPORT WorkerToken { … };



class PLATFORM_EXPORT WorkletToken { … };



class PLATFORM_EXPORT ExecutionContextToken { … };



class PLATFORM_EXPORT WebGPUExecutionContextToken { … };





class PLATFORM_EXPORT DocumentToken { … };

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

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

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

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





class PLATFORM_EXPORT LocalFrameToken { … };

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

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

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

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





class PLATFORM_EXPORT RemoteFrameToken { … };

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

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

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

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





class PLATFORM_EXPORT DedicatedWorkerToken { … };

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

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

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

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





class PLATFORM_EXPORT ServiceWorkerToken { … };

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

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

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

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





class PLATFORM_EXPORT SharedWorkerToken { … };

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

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

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

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





class PLATFORM_EXPORT AnimationWorkletToken { … };

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

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

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

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





class PLATFORM_EXPORT AudioWorkletToken { … };

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

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

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

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





class PLATFORM_EXPORT LayoutWorkletToken { … };

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

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

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

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





class PLATFORM_EXPORT PaintWorkletToken { … };

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

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

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

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





class PLATFORM_EXPORT SharedStorageWorkletToken { … };

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

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

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

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





class PLATFORM_EXPORT ShadowRealmToken { … };

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

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

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

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





class PLATFORM_EXPORT AttributionSrcToken { … };

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

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

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

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





class PLATFORM_EXPORT ClipboardSequenceNumberToken { … };

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

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

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

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





class PLATFORM_EXPORT SameDocNavigationScreenshotDestinationToken { … };

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

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

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

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





class PLATFORM_EXPORT V8ContextToken { … };

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

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

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

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





class PLATFORM_EXPORT ViewTransitionToken { … };

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

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

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

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





class PLATFORM_EXPORT WebNNContextToken { … };

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

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

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

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





class PLATFORM_EXPORT WebNNBufferToken { … };

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

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

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

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

template <typename UnionPtrType>
FrameTokenPtr FrameToken::Clone() const { … }

template <typename T,
          typename std::enable_if<std::is_same<
              T, FrameToken>::value>::type*>
bool FrameToken::Equals(const T& other) const { … }
template <typename UnionPtrType>
WorkerTokenPtr WorkerToken::Clone() const { … }

template <typename T,
          typename std::enable_if<std::is_same<
              T, WorkerToken>::value>::type*>
bool WorkerToken::Equals(const T& other) const { … }
template <typename UnionPtrType>
WorkletTokenPtr WorkletToken::Clone() const { … }

template <typename T,
          typename std::enable_if<std::is_same<
              T, WorkletToken>::value>::type*>
bool WorkletToken::Equals(const T& other) const { … }
template <typename UnionPtrType>
ExecutionContextTokenPtr ExecutionContextToken::Clone() const { … }

template <typename T,
          typename std::enable_if<std::is_same<
              T, ExecutionContextToken>::value>::type*>
bool ExecutionContextToken::Equals(const T& other) const { … }
template <typename UnionPtrType>
WebGPUExecutionContextTokenPtr WebGPUExecutionContextToken::Clone() const { … }

template <typename T,
          typename std::enable_if<std::is_same<
              T, WebGPUExecutionContextToken>::value>::type*>
bool WebGPUExecutionContextToken::Equals(const T& other) const { … }
template <typename StructPtrType>
DocumentTokenPtr DocumentToken::Clone() const { … }

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

template <typename T, DocumentToken::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
LocalFrameTokenPtr LocalFrameToken::Clone() const { … }

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

template <typename T, LocalFrameToken::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
RemoteFrameTokenPtr RemoteFrameToken::Clone() const { … }

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

template <typename T, RemoteFrameToken::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
DedicatedWorkerTokenPtr DedicatedWorkerToken::Clone() const { … }

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

template <typename T, DedicatedWorkerToken::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
ServiceWorkerTokenPtr ServiceWorkerToken::Clone() const { … }

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

template <typename T, ServiceWorkerToken::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
SharedWorkerTokenPtr SharedWorkerToken::Clone() const { … }

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

template <typename T, SharedWorkerToken::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
AnimationWorkletTokenPtr AnimationWorkletToken::Clone() const { … }

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

template <typename T, AnimationWorkletToken::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
AudioWorkletTokenPtr AudioWorkletToken::Clone() const { … }

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

template <typename T, AudioWorkletToken::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
LayoutWorkletTokenPtr LayoutWorkletToken::Clone() const { … }

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

template <typename T, LayoutWorkletToken::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
PaintWorkletTokenPtr PaintWorkletToken::Clone() const { … }

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

template <typename T, PaintWorkletToken::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
SharedStorageWorkletTokenPtr SharedStorageWorkletToken::Clone() const { … }

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

template <typename T, SharedStorageWorkletToken::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
ShadowRealmTokenPtr ShadowRealmToken::Clone() const { … }

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

template <typename T, ShadowRealmToken::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
AttributionSrcTokenPtr AttributionSrcToken::Clone() const { … }

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

template <typename T, AttributionSrcToken::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
ClipboardSequenceNumberTokenPtr ClipboardSequenceNumberToken::Clone() const { … }

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

template <typename T, ClipboardSequenceNumberToken::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
SameDocNavigationScreenshotDestinationTokenPtr SameDocNavigationScreenshotDestinationToken::Clone() const { … }

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

template <typename T, SameDocNavigationScreenshotDestinationToken::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
V8ContextTokenPtr V8ContextToken::Clone() const { … }

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

template <typename T, V8ContextToken::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
ViewTransitionTokenPtr ViewTransitionToken::Clone() const { … }

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

template <typename T, ViewTransitionToken::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
WebNNContextTokenPtr WebNNContextToken::Clone() const { … }

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

template <typename T, WebNNContextToken::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
WebNNBufferTokenPtr WebNNBufferToken::Clone() const { … }

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

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


}  // blink::mojom::blink

namespace mojo {


template <>
struct PLATFORM_EXPORT StructTraits<::blink::mojom::blink::DocumentToken::DataView,
                                         ::blink::mojom::blink::DocumentTokenPtr> { … };


template <>
struct PLATFORM_EXPORT StructTraits<::blink::mojom::blink::LocalFrameToken::DataView,
                                         ::blink::mojom::blink::LocalFrameTokenPtr> { … };


template <>
struct PLATFORM_EXPORT StructTraits<::blink::mojom::blink::RemoteFrameToken::DataView,
                                         ::blink::mojom::blink::RemoteFrameTokenPtr> { … };


template <>
struct PLATFORM_EXPORT StructTraits<::blink::mojom::blink::DedicatedWorkerToken::DataView,
                                         ::blink::mojom::blink::DedicatedWorkerTokenPtr> { … };


template <>
struct PLATFORM_EXPORT StructTraits<::blink::mojom::blink::ServiceWorkerToken::DataView,
                                         ::blink::mojom::blink::ServiceWorkerTokenPtr> { … };


template <>
struct PLATFORM_EXPORT StructTraits<::blink::mojom::blink::SharedWorkerToken::DataView,
                                         ::blink::mojom::blink::SharedWorkerTokenPtr> { … };


template <>
struct PLATFORM_EXPORT StructTraits<::blink::mojom::blink::AnimationWorkletToken::DataView,
                                         ::blink::mojom::blink::AnimationWorkletTokenPtr> { … };


template <>
struct PLATFORM_EXPORT StructTraits<::blink::mojom::blink::AudioWorkletToken::DataView,
                                         ::blink::mojom::blink::AudioWorkletTokenPtr> { … };


template <>
struct PLATFORM_EXPORT StructTraits<::blink::mojom::blink::LayoutWorkletToken::DataView,
                                         ::blink::mojom::blink::LayoutWorkletTokenPtr> { … };


template <>
struct PLATFORM_EXPORT StructTraits<::blink::mojom::blink::PaintWorkletToken::DataView,
                                         ::blink::mojom::blink::PaintWorkletTokenPtr> { … };


template <>
struct PLATFORM_EXPORT StructTraits<::blink::mojom::blink::SharedStorageWorkletToken::DataView,
                                         ::blink::mojom::blink::SharedStorageWorkletTokenPtr> { … };


template <>
struct PLATFORM_EXPORT StructTraits<::blink::mojom::blink::ShadowRealmToken::DataView,
                                         ::blink::mojom::blink::ShadowRealmTokenPtr> { … };


template <>
struct PLATFORM_EXPORT StructTraits<::blink::mojom::blink::AttributionSrcToken::DataView,
                                         ::blink::mojom::blink::AttributionSrcTokenPtr> { … };


template <>
struct PLATFORM_EXPORT StructTraits<::blink::mojom::blink::ClipboardSequenceNumberToken::DataView,
                                         ::blink::mojom::blink::ClipboardSequenceNumberTokenPtr> { … };


template <>
struct PLATFORM_EXPORT StructTraits<::blink::mojom::blink::SameDocNavigationScreenshotDestinationToken::DataView,
                                         ::blink::mojom::blink::SameDocNavigationScreenshotDestinationTokenPtr> { … };


template <>
struct PLATFORM_EXPORT StructTraits<::blink::mojom::blink::V8ContextToken::DataView,
                                         ::blink::mojom::blink::V8ContextTokenPtr> { … };


template <>
struct PLATFORM_EXPORT StructTraits<::blink::mojom::blink::ViewTransitionToken::DataView,
                                         ::blink::mojom::blink::ViewTransitionTokenPtr> { … };


template <>
struct PLATFORM_EXPORT StructTraits<::blink::mojom::blink::WebNNContextToken::DataView,
                                         ::blink::mojom::blink::WebNNContextTokenPtr> { … };


template <>
struct PLATFORM_EXPORT StructTraits<::blink::mojom::blink::WebNNBufferToken::DataView,
                                         ::blink::mojom::blink::WebNNBufferTokenPtr> { … };


template <>
struct PLATFORM_EXPORT UnionTraits<::blink::mojom::blink::FrameToken::DataView,
                                        ::blink::mojom::blink::FrameTokenPtr> { … };


template <>
struct PLATFORM_EXPORT UnionTraits<::blink::mojom::blink::WorkerToken::DataView,
                                        ::blink::mojom::blink::WorkerTokenPtr> { … };


template <>
struct PLATFORM_EXPORT UnionTraits<::blink::mojom::blink::WorkletToken::DataView,
                                        ::blink::mojom::blink::WorkletTokenPtr> { … };


template <>
struct PLATFORM_EXPORT UnionTraits<::blink::mojom::blink::ExecutionContextToken::DataView,
                                        ::blink::mojom::blink::ExecutionContextTokenPtr> { … };


template <>
struct PLATFORM_EXPORT UnionTraits<::blink::mojom::blink::WebGPUExecutionContextToken::DataView,
                                        ::blink::mojom::blink::WebGPUExecutionContextTokenPtr> { … };

}  // namespace mojo

#endif  // THIRD_PARTY_BLINK_PUBLIC_MOJOM_TOKENS_TOKENS_MOJOM_BLINK_H_