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

// third_party/blink/public/mojom/tokens/tokens.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 THIRD_PARTY_BLINK_PUBLIC_MOJOM_TOKENS_TOKENS_MOJOM_H_
#define THIRD_PARTY_BLINK_PUBLIC_MOJOM_TOKENS_TOKENS_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 "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-forward.h"  // IWYU pragma: export
#include "mojo/public/mojom/base/unguessable_token.mojom.h"
#include <string>
#include <vector>




#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/public/common/common_export.h"




namespace blink::mojom {
























class BLINK_COMMON_EXPORT FrameToken { … };



class BLINK_COMMON_EXPORT WorkerToken { … };



class BLINK_COMMON_EXPORT WorkletToken { … };



class BLINK_COMMON_EXPORT ExecutionContextToken { … };



class BLINK_COMMON_EXPORT WebGPUExecutionContextToken { … };





class BLINK_COMMON_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 BLINK_COMMON_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 BLINK_COMMON_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 BLINK_COMMON_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 BLINK_COMMON_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 BLINK_COMMON_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 BLINK_COMMON_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 BLINK_COMMON_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 BLINK_COMMON_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 BLINK_COMMON_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 BLINK_COMMON_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 BLINK_COMMON_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 BLINK_COMMON_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 BLINK_COMMON_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 BLINK_COMMON_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 BLINK_COMMON_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 BLINK_COMMON_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 BLINK_COMMON_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 BLINK_COMMON_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

namespace mojo {


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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

}  // namespace mojo

#endif  // THIRD_PARTY_BLINK_PUBLIC_MOJOM_TOKENS_TOKENS_MOJOM_H_