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

// services/webnn/public/mojom/webnn_graph.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 SERVICES_WEBNN_PUBLIC_MOJOM_WEBNN_GRAPH_MOJOM_H_
#define SERVICES_WEBNN_PUBLIC_MOJOM_WEBNN_GRAPH_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 "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-forward.h"  // IWYU pragma: export
#include "mojo/public/mojom/base/big_buffer.mojom.h"
#include "services/webnn/public/mojom/webnn_context_properties.mojom-forward.h"
#include "services/webnn/public/mojom/webnn_error.mojom.h"
#include "third_party/blink/public/mojom/tokens/tokens.mojom.h"
#include <string>
#include <vector>

#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 {

class WebNNGraphProxy;

template <typename ImplRefTraits>
class WebNNGraphStub;

class WebNNGraphRequestValidator;
class WebNNGraphResponseValidator;


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



class COMPONENT_EXPORT(WEBNN_MOJOM) WebNNGraphProxy
    : public WebNNGraph {};
class COMPONENT_EXPORT(WEBNN_MOJOM) 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) WebNNGraphRequestValidator : public mojo::MessageReceiver {};
class COMPONENT_EXPORT(WEBNN_MOJOM) WebNNGraphResponseValidator : public mojo::MessageReceiver {};











class COMPONENT_EXPORT(WEBNN_MOJOM) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) PaddingMode {};



class COMPONENT_EXPORT(WEBNN_MOJOM) Operation {};



class COMPONENT_EXPORT(WEBNN_MOJOM) ComputeResult {};





class COMPONENT_EXPORT(WEBNN_MOJOM) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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

namespace mojo {


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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

}  // namespace mojo

#endif  // SERVICES_WEBNN_PUBLIC_MOJOM_WEBNN_GRAPH_MOJOM_H_