chromium/out/Default/gen/components/web_package/mojom/web_bundle_parser.mojom.h

// components/web_package/mojom/web_bundle_parser.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 COMPONENTS_WEB_PACKAGE_MOJOM_WEB_BUNDLE_PARSER_MOJOM_H_
#define COMPONENTS_WEB_PACKAGE_MOJOM_WEB_BUNDLE_PARSER_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 "components/web_package/mojom/web_bundle_parser.mojom-features.h"  // IWYU pragma: export
#include "components/web_package/mojom/web_bundle_parser.mojom-shared.h"  // IWYU pragma: export
#include "components/web_package/mojom/web_bundle_parser.mojom-forward.h"  // IWYU pragma: export
#include "mojo/public/mojom/base/read_only_file.mojom.h"
#include "url/mojom/url.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 "components/web_package/mojom/web_bundle_parser_mojom_traits.h"




namespace web_package::mojom {

class WebBundleParserFactoryProxy;

template <typename ImplRefTraits>
class WebBundleParserFactoryStub;

class WebBundleParserFactoryRequestValidator;


class WebBundleParserFactory
    : public WebBundleParserFactoryInterfaceBase { … };

class WebBundleParserProxy;

template <typename ImplRefTraits>
class WebBundleParserStub;

class WebBundleParserRequestValidator;
class WebBundleParserResponseValidator;


class WebBundleParser
    : public WebBundleParserInterfaceBase { … };

class BundleDataSourceProxy;

template <typename ImplRefTraits>
class BundleDataSourceStub;

class BundleDataSourceRequestValidator;
class BundleDataSourceResponseValidator;


class BundleDataSource
    : public BundleDataSourceInterfaceBase { … };



class  WebBundleParserFactoryProxy
    : public WebBundleParserFactory { … };



class  WebBundleParserProxy
    : public WebBundleParser { … };



class  BundleDataSourceProxy
    : public BundleDataSource { … };
class  WebBundleParserFactoryStubDispatch { … };

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

  WebBundleParserFactoryStub() = default;
  ~WebBundleParserFactoryStub() 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  WebBundleParserStubDispatch { … };

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

  WebBundleParserStub() = default;
  ~WebBundleParserStub() 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  BundleDataSourceStubDispatch { … };

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

  BundleDataSourceStub() = default;
  ~BundleDataSourceStub() 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  WebBundleParserFactoryRequestValidator : public mojo::MessageReceiver { … };
class  WebBundleParserRequestValidator : public mojo::MessageReceiver { … };
class  BundleDataSourceRequestValidator : public mojo::MessageReceiver { … };
class  WebBundleParserResponseValidator : public mojo::MessageReceiver { … };
class  BundleDataSourceResponseValidator : public mojo::MessageReceiver { … };





class  BundleIntegrityBlockParseError { … };

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

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

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

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





class  BundleMetadataParseError { … };

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

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

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

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





class  BundleResponseParseError { … };

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

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

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

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













class  SignatureInfoUnknown { … };

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

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

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

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







class  BundleResponseLocation { … };

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

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

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

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






class  SignatureInfo { … };








class  BundleIntegrityBlockAttributes { … };

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

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

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

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





class  BundleIntegrityBlock { … };

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

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

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

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





class  Ed25519PublicKey { … };

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

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

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

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





class  Ed25519Signature { … };

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

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

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

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





class  SignatureInfoEd25519 { … };

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

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

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

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





class  EcdsaP256PublicKey { … };

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

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

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

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





class  EcdsaP256SHA256Signature { … };

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

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

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

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





class  SignatureInfoEcdsaP256SHA256 { … };

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

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

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

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






class  BundleIntegrityBlockSignatureStackEntry { … };

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

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

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

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





class  BundleMetadata { … };

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

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

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

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






class  BundleResponse { … };

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

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

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

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

template <typename UnionPtrType>
SignatureInfoPtr SignatureInfo::Clone() const { … }

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

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

template <typename T, BundleIntegrityBlockParseError::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
BundleMetadataParseErrorPtr BundleMetadataParseError::Clone() const { … }

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

template <typename T, BundleMetadataParseError::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
BundleResponseParseErrorPtr BundleResponseParseError::Clone() const { … }

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

template <typename T, BundleResponseParseError::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
BundleIntegrityBlockAttributesPtr BundleIntegrityBlockAttributes::Clone() const { … }

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

template <typename T, BundleIntegrityBlockAttributes::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
BundleIntegrityBlockPtr BundleIntegrityBlock::Clone() const { … }

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

template <typename T, BundleIntegrityBlock::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
Ed25519PublicKeyPtr Ed25519PublicKey::Clone() const { … }

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

template <typename T, Ed25519PublicKey::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
Ed25519SignaturePtr Ed25519Signature::Clone() const { … }

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

template <typename T, Ed25519Signature::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
SignatureInfoEd25519Ptr SignatureInfoEd25519::Clone() const { … }

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

template <typename T, SignatureInfoEd25519::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
EcdsaP256PublicKeyPtr EcdsaP256PublicKey::Clone() const { … }

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

template <typename T, EcdsaP256PublicKey::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
EcdsaP256SHA256SignaturePtr EcdsaP256SHA256Signature::Clone() const { … }

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

template <typename T, EcdsaP256SHA256Signature::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
SignatureInfoEcdsaP256SHA256Ptr SignatureInfoEcdsaP256SHA256::Clone() const { … }

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

template <typename T, SignatureInfoEcdsaP256SHA256::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
SignatureInfoUnknownPtr SignatureInfoUnknown::Clone() const { … }

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

template <typename T, SignatureInfoUnknown::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
BundleIntegrityBlockSignatureStackEntryPtr BundleIntegrityBlockSignatureStackEntry::Clone() const { … }

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

template <typename T, BundleIntegrityBlockSignatureStackEntry::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
BundleMetadataPtr BundleMetadata::Clone() const { … }

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

template <typename T, BundleMetadata::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
BundleResponseLocationPtr BundleResponseLocation::Clone() const { … }

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

template <typename T, BundleResponseLocation::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
BundleResponsePtr BundleResponse::Clone() const { … }

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

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


}  // web_package::mojom

namespace mojo {


template <>
struct  StructTraits<::web_package::mojom::BundleIntegrityBlockParseError::DataView,
                                         ::web_package::mojom::BundleIntegrityBlockParseErrorPtr> { … };


template <>
struct  StructTraits<::web_package::mojom::BundleMetadataParseError::DataView,
                                         ::web_package::mojom::BundleMetadataParseErrorPtr> { … };


template <>
struct  StructTraits<::web_package::mojom::BundleResponseParseError::DataView,
                                         ::web_package::mojom::BundleResponseParseErrorPtr> { … };


template <>
struct  StructTraits<::web_package::mojom::BundleIntegrityBlockAttributes::DataView,
                                         ::web_package::mojom::BundleIntegrityBlockAttributesPtr> { … };


template <>
struct  StructTraits<::web_package::mojom::BundleIntegrityBlock::DataView,
                                         ::web_package::mojom::BundleIntegrityBlockPtr> { … };


template <>
struct  StructTraits<::web_package::mojom::Ed25519PublicKey::DataView,
                                         ::web_package::mojom::Ed25519PublicKeyPtr> { … };


template <>
struct  StructTraits<::web_package::mojom::Ed25519Signature::DataView,
                                         ::web_package::mojom::Ed25519SignaturePtr> { … };


template <>
struct  StructTraits<::web_package::mojom::SignatureInfoEd25519::DataView,
                                         ::web_package::mojom::SignatureInfoEd25519Ptr> { … };


template <>
struct  StructTraits<::web_package::mojom::EcdsaP256PublicKey::DataView,
                                         ::web_package::mojom::EcdsaP256PublicKeyPtr> { … };


template <>
struct  StructTraits<::web_package::mojom::EcdsaP256SHA256Signature::DataView,
                                         ::web_package::mojom::EcdsaP256SHA256SignaturePtr> { … };


template <>
struct  StructTraits<::web_package::mojom::SignatureInfoEcdsaP256SHA256::DataView,
                                         ::web_package::mojom::SignatureInfoEcdsaP256SHA256Ptr> { … };


template <>
struct  StructTraits<::web_package::mojom::SignatureInfoUnknown::DataView,
                                         ::web_package::mojom::SignatureInfoUnknownPtr> { … };


template <>
struct  StructTraits<::web_package::mojom::BundleIntegrityBlockSignatureStackEntry::DataView,
                                         ::web_package::mojom::BundleIntegrityBlockSignatureStackEntryPtr> { … };


template <>
struct  StructTraits<::web_package::mojom::BundleMetadata::DataView,
                                         ::web_package::mojom::BundleMetadataPtr> { … };


template <>
struct  StructTraits<::web_package::mojom::BundleResponseLocation::DataView,
                                         ::web_package::mojom::BundleResponseLocationPtr> { … };


template <>
struct  StructTraits<::web_package::mojom::BundleResponse::DataView,
                                         ::web_package::mojom::BundleResponsePtr> { … };


template <>
struct  UnionTraits<::web_package::mojom::SignatureInfo::DataView,
                                        ::web_package::mojom::SignatureInfoPtr> { … };

}  // namespace mojo

#endif  // COMPONENTS_WEB_PACKAGE_MOJOM_WEB_BUNDLE_PARSER_MOJOM_H_