chromium/out/Default/gen/services/webnn/public/mojom/webnn_graph.mojom-blink.h

// services/webnn/public/mojom/webnn_graph.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 SERVICES_WEBNN_PUBLIC_MOJOM_WEBNN_GRAPH_MOJOM_BLINK_H_
#define SERVICES_WEBNN_PUBLIC_MOJOM_WEBNN_GRAPH_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 "services/webnn/public/mojom/webnn_graph.mojom-features.h"  // IWYU pragma: export
#include "services/webnn/public/mojom/webnn_graph.mojom-shared.h"  // IWYU pragma: export
#include "services/webnn/public/mojom/webnn_graph.mojom-blink-forward.h"  // IWYU pragma: export
#include "mojo/public/mojom/base/big_buffer.mojom-blink.h"
#include "services/webnn/public/mojom/webnn_context_properties.mojom-blink-forward.h"
#include "services/webnn/public/mojom/webnn_error.mojom-blink.h"
#include "third_party/blink/public/mojom/tokens/tokens.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 "mojo/public/cpp/bindings/lib/control_message_handler.h"
#include "mojo/public/cpp/bindings/lib/message_size_estimator.h"
#include "mojo/public/cpp/bindings/raw_ptr_impl_ref_traits.h"


#include "services/webnn/public/mojom/buffer_usage_mojom_traits.h"
#include "services/webnn/public/mojom/context_properties_mojom_traits.h"
#include "services/webnn/public/mojom/data_type_limits_mojom_traits.h"
#include "services/webnn/public/mojom/operand_descriptor_mojom_traits.h"
#include "services/webnn/public/mojom/supported_data_types_mojom_traits.h"
#include "base/component_export.h"




namespace webnn::mojom::blink {

class WebNNGraphProxy;

template <typename ImplRefTraits>
class WebNNGraphStub;

class WebNNGraphRequestValidator;
class WebNNGraphResponseValidator;


class COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) WebNNGraph
    : public WebNNGraphInterfaceBase {};



class COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) WebNNGraphProxy
    : public WebNNGraph {};
class COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) WebNNGraphStubDispatch {};

template <typename ImplRefTraits =
              mojo::RawPtrImplRefTraits<WebNNGraph>>
class WebNNGraphStub
    : public mojo::MessageReceiverWithResponderStatus {
 public:
  using ImplPointerType = typename ImplRefTraits::PointerType;

  WebNNGraphStub() = default;
  ~WebNNGraphStub() override = default;

  void set_sink(ImplPointerType sink) {}
  ImplPointerType& sink() {}

  bool Accept(mojo::Message* message) override {}

  bool AcceptWithResponder(
      mojo::Message* message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) override {}

 private:
  ImplPointerType sink_;
};
class COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) WebNNGraphRequestValidator : public mojo::MessageReceiver {};
class COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) WebNNGraphResponseValidator : public mojo::MessageReceiver {};











class COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) Size2d {};

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

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

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

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








class COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) ElementWiseUnary {};

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

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

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

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





class COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) Expand {};

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

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

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

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





class COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) ConstantPadding {};

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

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

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

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





class COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) EdgePadding {};

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

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

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

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





class COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) ReflectionPadding {};

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

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

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

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





class COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) SymmetricPadding {};

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

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

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

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






class COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) Matmul {};

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

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

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

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








class COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) StartAndSize {};

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

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

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

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






class COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) Elu {};

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

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

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

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







class COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) Gelu {};

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

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

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

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









class COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) HardSwish {};

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

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

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

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






class COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) LeakyRelu {};

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

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

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

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








class COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) Prelu {};

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

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

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

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





class COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) Relu {};

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

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

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

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





class COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) Reshape {};

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

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

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

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





class COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) Sigmoid {};

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

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

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

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





class COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) Softmax {};

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

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

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

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





class COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) Softplus {};

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

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

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

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





class COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) Softsign {};

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

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

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

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






class COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) Tanh {};

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

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

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

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










class COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) PaddingMode {};



class COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) Operation {};



class COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) ComputeResult {};





class COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) OperandDescriptor {};

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

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

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

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





class COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) Operand {};

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

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

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

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





class COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) ArgMinMax {};

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

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

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

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





class COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) BatchNormalization {};

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

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

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

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





class COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) Clamp {};

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

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

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

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





class COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) Concat {};

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

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

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

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






class COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) Padding2d {};

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

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

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

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





class COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) Conv2d {};

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

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

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

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





class COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) ElementWiseBinary {};

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

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

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

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











class COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) InstanceNormalization {};

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

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

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

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






class COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) Pad {};

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

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

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

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





class COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) Reduce {};

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

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

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

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





class COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) Pool2d {};

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

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

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

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






class COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) Slice {};

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

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

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

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






class COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) Gather {};

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

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

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

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





class COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) GatherElements {};

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

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

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

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






class COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) Gru {};

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

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

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

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





class COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) GruCell {};

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

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

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

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





class COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) Gemm {};

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

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

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

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





class COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) HardSigmoid {};

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

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

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

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






class COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) LayerNormalization {};

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

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

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

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






class COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) Linear {};

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

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

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

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





class COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) Lstm {};

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

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

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

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





class COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) LstmCell {};

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

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

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

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












class COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) Split {};

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

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

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

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






class COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) Transpose {};

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

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

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

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





class COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) Triangular {};

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

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

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

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





class COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) Resample2d {};

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

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

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

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





class COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) Where {};

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

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

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

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





class COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) GraphInfo {};

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

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

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

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

template <typename UnionPtrType>
PaddingModePtr PaddingMode::Clone() const {}

template <typename T,
          typename std::enable_if<std::is_same<
              T, PaddingMode>::value>::type*>
bool PaddingMode::Equals(const T& other) const {}
template <typename UnionPtrType>
OperationPtr Operation::Clone() const {}

template <typename T,
          typename std::enable_if<std::is_same<
              T, Operation>::value>::type*>
bool Operation::Equals(const T& other) const {}
template <typename UnionPtrType>
ComputeResultPtr ComputeResult::Clone() const {}

template <typename T,
          typename std::enable_if<std::is_same<
              T, ComputeResult>::value>::type*>
bool ComputeResult::Equals(const T& other) const {}
template <typename StructPtrType>
OperandDescriptorPtr OperandDescriptor::Clone() const {}

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

template <typename T, OperandDescriptor::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
OperandPtr Operand::Clone() const {}

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

template <typename T, Operand::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
ArgMinMaxPtr ArgMinMax::Clone() const {}

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

template <typename T, ArgMinMax::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
BatchNormalizationPtr BatchNormalization::Clone() const {}

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

template <typename T, BatchNormalization::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
ClampPtr Clamp::Clone() const {}

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

template <typename T, Clamp::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
ConcatPtr Concat::Clone() const {}

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

template <typename T, Concat::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
Size2dPtr Size2d::Clone() const {}

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

template <typename T, Size2d::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
Padding2dPtr Padding2d::Clone() const {}

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

template <typename T, Padding2d::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
Conv2dPtr Conv2d::Clone() const {}

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

template <typename T, Conv2d::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
ElementWiseBinaryPtr ElementWiseBinary::Clone() const {}

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

template <typename T, ElementWiseBinary::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
ElementWiseUnaryPtr ElementWiseUnary::Clone() const {}

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

template <typename T, ElementWiseUnary::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
ExpandPtr Expand::Clone() const {}

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

template <typename T, Expand::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
ConstantPaddingPtr ConstantPadding::Clone() const {}

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

template <typename T, ConstantPadding::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
EdgePaddingPtr EdgePadding::Clone() const {}

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

template <typename T, EdgePadding::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
ReflectionPaddingPtr ReflectionPadding::Clone() const {}

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

template <typename T, ReflectionPadding::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
SymmetricPaddingPtr SymmetricPadding::Clone() const {}

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

template <typename T, SymmetricPadding::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
InstanceNormalizationPtr InstanceNormalization::Clone() const {}

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

template <typename T, InstanceNormalization::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
MatmulPtr Matmul::Clone() const {}

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

template <typename T, Matmul::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
PadPtr Pad::Clone() const {}

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

template <typename T, Pad::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
ReducePtr Reduce::Clone() const {}

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

template <typename T, Reduce::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
Pool2dPtr Pool2d::Clone() const {}

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

template <typename T, Pool2d::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
StartAndSizePtr StartAndSize::Clone() const {}

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

template <typename T, StartAndSize::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
SlicePtr Slice::Clone() const {}

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

template <typename T, Slice::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
EluPtr Elu::Clone() const {}

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

template <typename T, Elu::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
GatherPtr Gather::Clone() const {}

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

template <typename T, Gather::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
GatherElementsPtr GatherElements::Clone() const {}

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

template <typename T, GatherElements::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
GeluPtr Gelu::Clone() const {}

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

template <typename T, Gelu::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
GruPtr Gru::Clone() const {}

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

template <typename T, Gru::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
GruCellPtr GruCell::Clone() const {}

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

template <typename T, GruCell::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
GemmPtr Gemm::Clone() const {}

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

template <typename T, Gemm::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
HardSigmoidPtr HardSigmoid::Clone() const {}

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

template <typename T, HardSigmoid::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
HardSwishPtr HardSwish::Clone() const {}

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

template <typename T, HardSwish::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
LayerNormalizationPtr LayerNormalization::Clone() const {}

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

template <typename T, LayerNormalization::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
LeakyReluPtr LeakyRelu::Clone() const {}

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

template <typename T, LeakyRelu::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
LinearPtr Linear::Clone() const {}

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

template <typename T, Linear::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
LstmPtr Lstm::Clone() const {}

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

template <typename T, Lstm::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
LstmCellPtr LstmCell::Clone() const {}

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

template <typename T, LstmCell::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
PreluPtr Prelu::Clone() const {}

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

template <typename T, Prelu::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
ReluPtr Relu::Clone() const {}

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

template <typename T, Relu::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
ReshapePtr Reshape::Clone() const {}

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

template <typename T, Reshape::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
SigmoidPtr Sigmoid::Clone() const {}

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

template <typename T, Sigmoid::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
SoftmaxPtr Softmax::Clone() const {}

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

template <typename T, Softmax::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
SoftplusPtr Softplus::Clone() const {}

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

template <typename T, Softplus::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
SoftsignPtr Softsign::Clone() const {}

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

template <typename T, Softsign::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
SplitPtr Split::Clone() const {}

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

template <typename T, Split::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
TanhPtr Tanh::Clone() const {}

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

template <typename T, Tanh::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
TransposePtr Transpose::Clone() const {}

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

template <typename T, Transpose::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
TriangularPtr Triangular::Clone() const {}

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

template <typename T, Triangular::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
Resample2dPtr Resample2d::Clone() const {}

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

template <typename T, Resample2d::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
WherePtr Where::Clone() const {}

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

template <typename T, Where::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {}
template <typename StructPtrType>
GraphInfoPtr GraphInfo::Clone() const {}

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

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


}  // webnn::mojom::blink

namespace mojo {


template <>
struct COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) StructTraits<::webnn::mojom::blink::OperandDescriptor::DataView,
                                         ::webnn::mojom::blink::OperandDescriptorPtr> {};


template <>
struct COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) StructTraits<::webnn::mojom::blink::Operand::DataView,
                                         ::webnn::mojom::blink::OperandPtr> {};


template <>
struct COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) StructTraits<::webnn::mojom::blink::ArgMinMax::DataView,
                                         ::webnn::mojom::blink::ArgMinMaxPtr> {};


template <>
struct COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) StructTraits<::webnn::mojom::blink::BatchNormalization::DataView,
                                         ::webnn::mojom::blink::BatchNormalizationPtr> {};


template <>
struct COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) StructTraits<::webnn::mojom::blink::Clamp::DataView,
                                         ::webnn::mojom::blink::ClampPtr> {};


template <>
struct COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) StructTraits<::webnn::mojom::blink::Concat::DataView,
                                         ::webnn::mojom::blink::ConcatPtr> {};


template <>
struct COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) StructTraits<::webnn::mojom::blink::Size2d::DataView,
                                         ::webnn::mojom::blink::Size2dPtr> {};


template <>
struct COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) StructTraits<::webnn::mojom::blink::Padding2d::DataView,
                                         ::webnn::mojom::blink::Padding2dPtr> {};


template <>
struct COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) StructTraits<::webnn::mojom::blink::Conv2d::DataView,
                                         ::webnn::mojom::blink::Conv2dPtr> {};


template <>
struct COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) StructTraits<::webnn::mojom::blink::ElementWiseBinary::DataView,
                                         ::webnn::mojom::blink::ElementWiseBinaryPtr> {};


template <>
struct COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) StructTraits<::webnn::mojom::blink::ElementWiseUnary::DataView,
                                         ::webnn::mojom::blink::ElementWiseUnaryPtr> {};


template <>
struct COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) StructTraits<::webnn::mojom::blink::Expand::DataView,
                                         ::webnn::mojom::blink::ExpandPtr> {};


template <>
struct COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) StructTraits<::webnn::mojom::blink::ConstantPadding::DataView,
                                         ::webnn::mojom::blink::ConstantPaddingPtr> {};


template <>
struct COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) StructTraits<::webnn::mojom::blink::EdgePadding::DataView,
                                         ::webnn::mojom::blink::EdgePaddingPtr> {};


template <>
struct COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) StructTraits<::webnn::mojom::blink::ReflectionPadding::DataView,
                                         ::webnn::mojom::blink::ReflectionPaddingPtr> {};


template <>
struct COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) StructTraits<::webnn::mojom::blink::SymmetricPadding::DataView,
                                         ::webnn::mojom::blink::SymmetricPaddingPtr> {};


template <>
struct COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) StructTraits<::webnn::mojom::blink::InstanceNormalization::DataView,
                                         ::webnn::mojom::blink::InstanceNormalizationPtr> {};


template <>
struct COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) StructTraits<::webnn::mojom::blink::Matmul::DataView,
                                         ::webnn::mojom::blink::MatmulPtr> {};


template <>
struct COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) StructTraits<::webnn::mojom::blink::Pad::DataView,
                                         ::webnn::mojom::blink::PadPtr> {};


template <>
struct COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) StructTraits<::webnn::mojom::blink::Reduce::DataView,
                                         ::webnn::mojom::blink::ReducePtr> {};


template <>
struct COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) StructTraits<::webnn::mojom::blink::Pool2d::DataView,
                                         ::webnn::mojom::blink::Pool2dPtr> {};


template <>
struct COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) StructTraits<::webnn::mojom::blink::StartAndSize::DataView,
                                         ::webnn::mojom::blink::StartAndSizePtr> {};


template <>
struct COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) StructTraits<::webnn::mojom::blink::Slice::DataView,
                                         ::webnn::mojom::blink::SlicePtr> {};


template <>
struct COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) StructTraits<::webnn::mojom::blink::Elu::DataView,
                                         ::webnn::mojom::blink::EluPtr> {};


template <>
struct COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) StructTraits<::webnn::mojom::blink::Gather::DataView,
                                         ::webnn::mojom::blink::GatherPtr> {};


template <>
struct COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) StructTraits<::webnn::mojom::blink::GatherElements::DataView,
                                         ::webnn::mojom::blink::GatherElementsPtr> {};


template <>
struct COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) StructTraits<::webnn::mojom::blink::Gelu::DataView,
                                         ::webnn::mojom::blink::GeluPtr> {};


template <>
struct COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) StructTraits<::webnn::mojom::blink::Gru::DataView,
                                         ::webnn::mojom::blink::GruPtr> {};


template <>
struct COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) StructTraits<::webnn::mojom::blink::GruCell::DataView,
                                         ::webnn::mojom::blink::GruCellPtr> {};


template <>
struct COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) StructTraits<::webnn::mojom::blink::Gemm::DataView,
                                         ::webnn::mojom::blink::GemmPtr> {};


template <>
struct COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) StructTraits<::webnn::mojom::blink::HardSigmoid::DataView,
                                         ::webnn::mojom::blink::HardSigmoidPtr> {};


template <>
struct COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) StructTraits<::webnn::mojom::blink::HardSwish::DataView,
                                         ::webnn::mojom::blink::HardSwishPtr> {};


template <>
struct COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) StructTraits<::webnn::mojom::blink::LayerNormalization::DataView,
                                         ::webnn::mojom::blink::LayerNormalizationPtr> {};


template <>
struct COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) StructTraits<::webnn::mojom::blink::LeakyRelu::DataView,
                                         ::webnn::mojom::blink::LeakyReluPtr> {};


template <>
struct COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) StructTraits<::webnn::mojom::blink::Linear::DataView,
                                         ::webnn::mojom::blink::LinearPtr> {};


template <>
struct COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) StructTraits<::webnn::mojom::blink::Lstm::DataView,
                                         ::webnn::mojom::blink::LstmPtr> {};


template <>
struct COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) StructTraits<::webnn::mojom::blink::LstmCell::DataView,
                                         ::webnn::mojom::blink::LstmCellPtr> {};


template <>
struct COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) StructTraits<::webnn::mojom::blink::Prelu::DataView,
                                         ::webnn::mojom::blink::PreluPtr> {};


template <>
struct COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) StructTraits<::webnn::mojom::blink::Relu::DataView,
                                         ::webnn::mojom::blink::ReluPtr> {};


template <>
struct COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) StructTraits<::webnn::mojom::blink::Reshape::DataView,
                                         ::webnn::mojom::blink::ReshapePtr> {};


template <>
struct COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) StructTraits<::webnn::mojom::blink::Sigmoid::DataView,
                                         ::webnn::mojom::blink::SigmoidPtr> {};


template <>
struct COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) StructTraits<::webnn::mojom::blink::Softmax::DataView,
                                         ::webnn::mojom::blink::SoftmaxPtr> {};


template <>
struct COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) StructTraits<::webnn::mojom::blink::Softplus::DataView,
                                         ::webnn::mojom::blink::SoftplusPtr> {};


template <>
struct COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) StructTraits<::webnn::mojom::blink::Softsign::DataView,
                                         ::webnn::mojom::blink::SoftsignPtr> {};


template <>
struct COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) StructTraits<::webnn::mojom::blink::Split::DataView,
                                         ::webnn::mojom::blink::SplitPtr> {};


template <>
struct COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) StructTraits<::webnn::mojom::blink::Tanh::DataView,
                                         ::webnn::mojom::blink::TanhPtr> {};


template <>
struct COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) StructTraits<::webnn::mojom::blink::Transpose::DataView,
                                         ::webnn::mojom::blink::TransposePtr> {};


template <>
struct COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) StructTraits<::webnn::mojom::blink::Triangular::DataView,
                                         ::webnn::mojom::blink::TriangularPtr> {};


template <>
struct COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) StructTraits<::webnn::mojom::blink::Resample2d::DataView,
                                         ::webnn::mojom::blink::Resample2dPtr> {};


template <>
struct COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) StructTraits<::webnn::mojom::blink::Where::DataView,
                                         ::webnn::mojom::blink::WherePtr> {};


template <>
struct COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) StructTraits<::webnn::mojom::blink::GraphInfo::DataView,
                                         ::webnn::mojom::blink::GraphInfoPtr> {};


template <>
struct COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) UnionTraits<::webnn::mojom::blink::PaddingMode::DataView,
                                        ::webnn::mojom::blink::PaddingModePtr> {};


template <>
struct COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) UnionTraits<::webnn::mojom::blink::Operation::DataView,
                                        ::webnn::mojom::blink::OperationPtr> {};


template <>
struct COMPONENT_EXPORT(WEBNN_MOJOM_BLINK) UnionTraits<::webnn::mojom::blink::ComputeResult::DataView,
                                        ::webnn::mojom::blink::ComputeResultPtr> {};

}  // namespace mojo

#endif  // SERVICES_WEBNN_PUBLIC_MOJOM_WEBNN_GRAPH_MOJOM_BLINK_H_