// third_party/blink/public/mojom/manifest/manifest.mojom-blink.h is auto generated by mojom_bindings_generator.py, do not edit

// Copyright 2013 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef THIRD_PARTY_BLINK_PUBLIC_MOJOM_MANIFEST_MANIFEST_MOJOM_BLINK_H_
#define THIRD_PARTY_BLINK_PUBLIC_MOJOM_MANIFEST_MANIFEST_MOJOM_BLINK_H_

#include <stdint.h>

#include <limits>
#include <optional>
#include <type_traits>
#include <utility>
#include "mojo/public/cpp/bindings/clone_traits.h"
#include "mojo/public/cpp/bindings/equals_traits.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 "mojo/public/cpp/bindings/lib/serialization.h"

#include "third_party/perfetto/include/perfetto/tracing/traced_value_forward.h"

#include "third_party/blink/public/mojom/manifest/manifest.mojom-features.h"  // IWYU pragma: export
#include "third_party/blink/public/mojom/manifest/manifest.mojom-shared.h"  // IWYU pragma: export
#include "third_party/blink/public/mojom/manifest/manifest.mojom-blink-forward.h"  // IWYU pragma: export
#include "mojo/public/mojom/base/string16.mojom-blink.h"
#include "services/device/public/mojom/screen_orientation_lock_types.mojom-blink-forward.h"
#include "third_party/blink/public/mojom/manifest/display_mode.mojom-blink-forward.h"
#include "third_party/blink/public/mojom/manifest/manifest_launch_handler.mojom-blink.h"
#include "third_party/blink/public/mojom/manifest/manifest_migration_behavior.mojom-blink-forward.h"
#include "services/network/public/mojom/permissions_policy/permissions_policy.mojom-blink-forward.h"
#include "third_party/blink/public/mojom/safe_url_pattern.mojom-blink.h"
#include "ui/gfx/geometry/mojom/geometry.mojom-blink.h"
#include "url/mojom/origin.mojom-blink.h"
#include "url/mojom/url.mojom-blink.h"

#include "mojo/public/cpp/bindings/lib/wtf_clone_equals_util.h"
#include "mojo/public/cpp/bindings/lib/wtf_hash_util.h"
#include "third_party/blink/renderer/platform/wtf/hash_functions.h"
#include "third_party/blink/renderer/platform/wtf/text/wtf_string.h"




#include "third_party/blink/public/common/manifest/manifest_mojom_traits.h"
#include "third_party/blink/renderer/modules/manifest/icu_locale_hash_traits.h"
#include "third_party/blink/renderer/platform/platform_export.h"
#if !BLINK_MOJO_IMPL && !INSIDE_BLINK
#error "File must only be imported inside blink"
#endif




namespace blink::mojom::blink {







class PLATFORM_EXPORT Locale {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<Locale, T>::value>;
  using DataView = LocaleDataView;
  using Data_ = internal::Locale_Data;

  template <typename... Args>
  static LocalePtr New(Args&&... args) {
    return LocalePtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static LocalePtr From(const U& u) {
    return mojo::TypeConverter<LocalePtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, Locale>::Convert(*this);
  }


  Locale();

  explicit Locale(
      const ::blink::String& tag);


  ~Locale();

  // Clone() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Clone() or copy
  // constructor/assignment are available for members.
  template <typename StructPtrType = LocalePtr>
  LocalePtr Clone() const;

  // Equals() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Equals() or == operator
  // are available for members.
  template <typename T, Locale::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, Locale::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, Locale::EnableIfSame<T>* = nullptr>
  bool operator!=(const T& rhs) const { return !operator==(rhs); }

  template <mojo::internal::SendValidation send_validation, typename UserType>
  static ::blink::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        Locale::DataView, ::blink::Vector<uint8_t>, send_validation>(input);
  }

  template <typename UserType>
  static ::blink::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        Locale::DataView, ::blink::Vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        Locale::DataView>(input);
  }

  // The returned Message is serialized only if the message is moved
  // cross-process or cross-language. Otherwise if the message is Deserialized
  // as the same UserType |input| will just be moved to |output| in
  // DeserializeFromMessage.
  template <typename UserType>
  static mojo::Message WrapAsMessage(UserType input) {
    return mojo::Message(std::make_unique<
        internal::Locale_UnserializedMessageContext<
            UserType, Locale::DataView>>(0, 0, std::move(input)),
        MOJO_CREATE_MESSAGE_FLAG_NONE);
  }

  template <typename UserType>
  static bool Deserialize(const void* data,
                          size_t data_num_bytes,
                          UserType* output) {
    mojo::Message message;
    return mojo::internal::DeserializeImpl<Locale::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(base::span<const uint8_t> input,
                          UserType* output) {
    return Locale::Deserialize(
        input.empty() ? nullptr : input.data(), input.size(), output);
  }

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    auto context = input.TakeUnserializedContext<
        internal::Locale_UnserializedMessageContext<
            UserType, Locale::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<Locale::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
  ::blink::String tag;

  // Serialise this struct into a trace.
  void WriteIntoTrace(perfetto::TracedValue traced_context) const;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
};

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

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

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

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
























class PLATFORM_EXPORT ManifestError {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<ManifestError, T>::value>;
  using DataView = ManifestErrorDataView;
  using Data_ = internal::ManifestError_Data;

  template <typename... Args>
  static ManifestErrorPtr New(Args&&... args) {
    return ManifestErrorPtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static ManifestErrorPtr From(const U& u) {
    return mojo::TypeConverter<ManifestErrorPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, ManifestError>::Convert(*this);
  }


  ManifestError();

  ManifestError(
      const ::blink::String& message,
      bool critical,
      uint32_t line,
      uint32_t column);


  ~ManifestError();

  // Clone() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Clone() or copy
  // constructor/assignment are available for members.
  template <typename StructPtrType = ManifestErrorPtr>
  ManifestErrorPtr Clone() const;

  // Equals() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Equals() or == operator
  // are available for members.
  template <typename T, ManifestError::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, ManifestError::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, ManifestError::EnableIfSame<T>* = nullptr>
  bool operator!=(const T& rhs) const { return !operator==(rhs); }
  size_t Hash(size_t seed) const;

  template <mojo::internal::SendValidation send_validation, typename UserType>
  static ::blink::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        ManifestError::DataView, ::blink::Vector<uint8_t>, send_validation>(input);
  }

  template <typename UserType>
  static ::blink::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        ManifestError::DataView, ::blink::Vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        ManifestError::DataView>(input);
  }

  // The returned Message is serialized only if the message is moved
  // cross-process or cross-language. Otherwise if the message is Deserialized
  // as the same UserType |input| will just be moved to |output| in
  // DeserializeFromMessage.
  template <typename UserType>
  static mojo::Message WrapAsMessage(UserType input) {
    return mojo::Message(std::make_unique<
        internal::ManifestError_UnserializedMessageContext<
            UserType, ManifestError::DataView>>(0, 0, std::move(input)),
        MOJO_CREATE_MESSAGE_FLAG_NONE);
  }

  template <typename UserType>
  static bool Deserialize(const void* data,
                          size_t data_num_bytes,
                          UserType* output) {
    mojo::Message message;
    return mojo::internal::DeserializeImpl<ManifestError::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(base::span<const uint8_t> input,
                          UserType* output) {
    return ManifestError::Deserialize(
        input.empty() ? nullptr : input.data(), input.size(), output);
  }

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    auto context = input.TakeUnserializedContext<
        internal::ManifestError_UnserializedMessageContext<
            UserType, ManifestError::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<ManifestError::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
  ::blink::String message;
  
  bool critical;
  
  uint32_t line;
  
  uint32_t column;

  // Serialise this struct into a trace.
  void WriteIntoTrace(perfetto::TracedValue traced_context) const;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
};

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

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

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

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






class PLATFORM_EXPORT HomeTabUnion {
 public:
  using DataView = HomeTabUnionDataView;
  using Data_ = internal::HomeTabUnion_Data;
  using Tag = Data_::HomeTabUnion_Tag;

  template <typename... Args>
  static HomeTabUnionPtr New(Args&&... args) {
    static_assert(
        sizeof...(args) < 0,
        "Do not use Union::New(); to create a union of a given subtype, use "
        "New<SubType>(), not New() followed by set_<sub_type>(). To represent "
        "an empty union, mark the field or parameter as nullable in the mojom "
        "definition.");
    return nullptr;
  }

  // Construct an instance holding |visibility|.
  static HomeTabUnionPtr NewVisibility(
      TabStripMemberVisibility value);
  // Construct an instance holding |params|.
  static HomeTabUnionPtr NewParams(
      HomeTabParamsPtr value);

  template <typename U>
  static HomeTabUnionPtr From(const U& u) {
    return mojo::TypeConverter<HomeTabUnionPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, HomeTabUnion>::Convert(*this);
  }
  ~HomeTabUnion();

  // Delete the copy constructor and copy assignment operators because `data_`
  // contains raw pointers that must not be copied.
  HomeTabUnion(const HomeTabUnion& other) = delete;
  HomeTabUnion& operator=(const HomeTabUnion& other) = delete;

  // Clone() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Clone() or copy
  // constructor/assignment are available for members.
  template <typename UnionPtrType = HomeTabUnionPtr>
  HomeTabUnionPtr Clone() const;

  // Equals() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Equals() or == operator
  // are available for members.
  template <typename T,
            typename std::enable_if<std::is_same<
                T, HomeTabUnion>::value>::type* = nullptr>
  bool Equals(const T& other) const;

  template <typename T,
            typename std::enable_if<std::is_same<
                T, HomeTabUnion>::value>::type* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  Tag which() const {
    return tag_;
  }

  bool is_visibility() const { return tag_ == Tag::kVisibility; }
  TabStripMemberVisibility get_visibility() const {
    CHECK(tag_ == Tag::kVisibility);
    return data_.visibility;
  }
  void set_visibility(TabStripMemberVisibility visibility);

  bool is_params() const { return tag_ == Tag::kParams; }
  const HomeTabParamsPtr& get_params() const {
    CHECK(tag_ == Tag::kParams);
    return data_.params;
  }
  HomeTabParamsPtr& get_params() {
    CHECK(tag_ == Tag::kParams);
    return data_.params;
  }
  void set_params(HomeTabParamsPtr params);

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        HomeTabUnion::DataView>(input);
  }

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    return mojo::internal::DeserializeImpl<HomeTabUnion::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

 private:
  template <typename T>
  friend class ::mojo::InlinedStructPtr;
  template <typename T>
  friend class ::mojo::StructPtr;

  union Union_ {
    Union_(
        std::in_place_index_t<static_cast<size_t>(Tag::kVisibility)>,
        TabStripMemberVisibility value);
    Union_(
        std::in_place_index_t<static_cast<size_t>(Tag::kParams)>,
        HomeTabParamsPtr value);
    // The contents of the union are explicitly destroyed by `DestroyActive()`.
    ~Union_() {}

    TabStripMemberVisibility visibility;
    HomeTabParamsPtr params;
  };

  HomeTabUnion(
      std::in_place_index_t<static_cast<size_t>(Tag::kVisibility)>,
      TabStripMemberVisibility value);
  HomeTabUnion(
      std::in_place_index_t<static_cast<size_t>(Tag::kParams)>,
      HomeTabParamsPtr value);

  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  void DestroyActive();
  Tag tag_;
  Union_ data_;
};





class PLATFORM_EXPORT Manifest {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<Manifest, T>::value>;
  using DataView = ManifestDataView;
  using Data_ = internal::Manifest_Data;
  using TextDirection = Manifest_TextDirection;

  template <typename... Args>
  static ManifestPtr New(Args&&... args) {
    return ManifestPtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static ManifestPtr From(const U& u) {
    return mojo::TypeConverter<ManifestPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, Manifest>::Convert(*this);
  }


  Manifest();

  Manifest(
      const ::blink::KURL& manifest_url,
      Manifest::TextDirection dir,
      const ::blink::String& name,
      const ::blink::String& short_name,
      const ::blink::String& description,
      const ::blink::KURL& id,
      bool has_custom_id,
      const ::blink::KURL& start_url,
      bool has_valid_specified_start_url,
      ::blink::mojom::blink::DisplayMode display,
      ::blink::Vector<DisplayOverrideItemPtr> display_override,
      ::device::mojom::blink::ScreenOrientationLockType orientation,
      ::blink::Vector<ManifestImageResourcePtr> icons,
      ::blink::Vector<ManifestScreenshotPtr> screenshots,
      ::blink::Vector<ManifestShortcutItemPtr> shortcuts,
      ManifestShareTargetPtr share_target,
      ::blink::Vector<ManifestFileHandlerPtr> file_handlers,
      ::blink::Vector<ManifestProtocolHandlerPtr> protocol_handlers,
      ::blink::Vector<ManifestScopeExtensionPtr> scope_extensions,
      ManifestLockScreenPtr lock_screen,
      ManifestNoteTakingPtr note_taking,
      ::blink::Vector<ManifestRelatedApplicationPtr> related_applications,
      bool prefer_related_applications,
      ::blink::Vector<ManifestMigrateFromPtr> migrate_from,
      ManifestMigrateToPtr migrate_to,
      std::optional<uint32_t> theme_color,
      std::optional<uint32_t> background_color,
      const ::blink::String& gcm_sender_id,
      const ::blink::KURL& scope,
      const std::optional<::blink::KURL>& update_manifest_url,
      ::blink::mojom::blink::ManifestLaunchHandlerPtr launch_handler,
      ::blink::HashMap<::blink::String, ManifestTranslationItemPtr> translations,
      std::optional<uint32_t> dark_theme_color,
      std::optional<uint32_t> dark_background_color,
      ManifestTabStripPtr tab_strip,
      const ::blink::String& version,
      std::optional<::blink::HashMap<::icu::Locale, ManifestLocalizedTextObjectPtr>> name_localized,
      std::optional<::blink::HashMap<::icu::Locale, ManifestLocalizedTextObjectPtr>> short_name_localized,
      std::optional<::blink::HashMap<::icu::Locale, ManifestLocalizedTextObjectPtr>> description_localized,
      std::optional<::blink::HashMap<::icu::Locale, ::blink::Vector<ManifestImageResourcePtr>>> icons_localized);

Manifest(const Manifest&) = delete;
Manifest& operator=(const Manifest&) = delete;

  ~Manifest();

  // Clone() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Clone() or copy
  // constructor/assignment are available for members.
  template <typename StructPtrType = ManifestPtr>
  ManifestPtr Clone() const;

  // Equals() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Equals() or == operator
  // are available for members.
  template <typename T, Manifest::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, Manifest::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, Manifest::EnableIfSame<T>* = nullptr>
  bool operator!=(const T& rhs) const { return !operator==(rhs); }

  template <mojo::internal::SendValidation send_validation, typename UserType>
  static ::blink::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        Manifest::DataView, ::blink::Vector<uint8_t>, send_validation>(input);
  }

  template <typename UserType>
  static ::blink::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        Manifest::DataView, ::blink::Vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        Manifest::DataView>(input);
  }

  // The returned Message is serialized only if the message is moved
  // cross-process or cross-language. Otherwise if the message is Deserialized
  // as the same UserType |input| will just be moved to |output| in
  // DeserializeFromMessage.
  template <typename UserType>
  static mojo::Message WrapAsMessage(UserType input) {
    return mojo::Message(std::make_unique<
        internal::Manifest_UnserializedMessageContext<
            UserType, Manifest::DataView>>(0, 0, std::move(input)),
        MOJO_CREATE_MESSAGE_FLAG_NONE);
  }

  template <typename UserType>
  static bool Deserialize(const void* data,
                          size_t data_num_bytes,
                          UserType* output) {
    mojo::Message message;
    return mojo::internal::DeserializeImpl<Manifest::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(base::span<const uint8_t> input,
                          UserType* output) {
    return Manifest::Deserialize(
        input.empty() ? nullptr : input.data(), input.size(), output);
  }

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    auto context = input.TakeUnserializedContext<
        internal::Manifest_UnserializedMessageContext<
            UserType, Manifest::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<Manifest::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
  ::blink::KURL manifest_url;
  
  Manifest::TextDirection dir;
  
  ::blink::String name;
  
  ::blink::String short_name;
  
  ::blink::String description;
  
  ::blink::KURL id;
  
  bool has_custom_id;
  
  ::blink::KURL start_url;
  
  bool has_valid_specified_start_url;
  
  ::blink::mojom::blink::DisplayMode display;
  
  ::blink::Vector<DisplayOverrideItemPtr> display_override;
  
  ::device::mojom::blink::ScreenOrientationLockType orientation;
  
  ::blink::Vector<ManifestImageResourcePtr> icons;
  
  ::blink::Vector<ManifestScreenshotPtr> screenshots;
  
  ::blink::Vector<ManifestShortcutItemPtr> shortcuts;
  
  ManifestShareTargetPtr share_target;
  
  ::blink::Vector<ManifestFileHandlerPtr> file_handlers;
  
  ::blink::Vector<ManifestProtocolHandlerPtr> protocol_handlers;
  
  ::blink::Vector<ManifestScopeExtensionPtr> scope_extensions;
  
  ManifestLockScreenPtr lock_screen;
  
  ManifestNoteTakingPtr note_taking;
  
  ::blink::Vector<ManifestRelatedApplicationPtr> related_applications;
  
  bool prefer_related_applications;
  
  ::blink::Vector<ManifestMigrateFromPtr> migrate_from;
  
  ManifestMigrateToPtr migrate_to;
  
  std::optional<uint32_t> theme_color;
  
  std::optional<uint32_t> background_color;
  
  ::blink::String gcm_sender_id;
  
  ::blink::KURL scope;
  
  std::optional<::blink::KURL> update_manifest_url;
  
  ::blink::mojom::blink::ManifestLaunchHandlerPtr launch_handler;
  
  ::blink::HashMap<::blink::String, ManifestTranslationItemPtr> translations;
  
  std::optional<uint32_t> dark_theme_color;
  
  std::optional<uint32_t> dark_background_color;
  
  ManifestTabStripPtr tab_strip;
  
  ::blink::String version;
  
  std::optional<::blink::HashMap<::icu::Locale, ManifestLocalizedTextObjectPtr>> name_localized;
  
  std::optional<::blink::HashMap<::icu::Locale, ManifestLocalizedTextObjectPtr>> short_name_localized;
  
  std::optional<::blink::HashMap<::icu::Locale, ManifestLocalizedTextObjectPtr>> description_localized;
  
  std::optional<::blink::HashMap<::icu::Locale, ::blink::Vector<ManifestImageResourcePtr>>> icons_localized;

  // Serialise this struct into a trace.
  void WriteIntoTrace(perfetto::TracedValue traced_context) const;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
};

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

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

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

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





class PLATFORM_EXPORT ManifestLocalizedTextObject {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<ManifestLocalizedTextObject, T>::value>;
  using DataView = ManifestLocalizedTextObjectDataView;
  using Data_ = internal::ManifestLocalizedTextObject_Data;

  template <typename... Args>
  static ManifestLocalizedTextObjectPtr New(Args&&... args) {
    return ManifestLocalizedTextObjectPtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static ManifestLocalizedTextObjectPtr From(const U& u) {
    return mojo::TypeConverter<ManifestLocalizedTextObjectPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, ManifestLocalizedTextObject>::Convert(*this);
  }


  ManifestLocalizedTextObject();

  ManifestLocalizedTextObject(
      const ::blink::String& value,
      std::optional<Manifest::TextDirection> dir,
      const ::blink::String& lang);


  ~ManifestLocalizedTextObject();

  // Clone() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Clone() or copy
  // constructor/assignment are available for members.
  template <typename StructPtrType = ManifestLocalizedTextObjectPtr>
  ManifestLocalizedTextObjectPtr Clone() const;

  // Equals() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Equals() or == operator
  // are available for members.
  template <typename T, ManifestLocalizedTextObject::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, ManifestLocalizedTextObject::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, ManifestLocalizedTextObject::EnableIfSame<T>* = nullptr>
  bool operator!=(const T& rhs) const { return !operator==(rhs); }

  template <mojo::internal::SendValidation send_validation, typename UserType>
  static ::blink::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        ManifestLocalizedTextObject::DataView, ::blink::Vector<uint8_t>, send_validation>(input);
  }

  template <typename UserType>
  static ::blink::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        ManifestLocalizedTextObject::DataView, ::blink::Vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        ManifestLocalizedTextObject::DataView>(input);
  }

  // The returned Message is serialized only if the message is moved
  // cross-process or cross-language. Otherwise if the message is Deserialized
  // as the same UserType |input| will just be moved to |output| in
  // DeserializeFromMessage.
  template <typename UserType>
  static mojo::Message WrapAsMessage(UserType input) {
    return mojo::Message(std::make_unique<
        internal::ManifestLocalizedTextObject_UnserializedMessageContext<
            UserType, ManifestLocalizedTextObject::DataView>>(0, 0, std::move(input)),
        MOJO_CREATE_MESSAGE_FLAG_NONE);
  }

  template <typename UserType>
  static bool Deserialize(const void* data,
                          size_t data_num_bytes,
                          UserType* output) {
    mojo::Message message;
    return mojo::internal::DeserializeImpl<ManifestLocalizedTextObject::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(base::span<const uint8_t> input,
                          UserType* output) {
    return ManifestLocalizedTextObject::Deserialize(
        input.empty() ? nullptr : input.data(), input.size(), output);
  }

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    auto context = input.TakeUnserializedContext<
        internal::ManifestLocalizedTextObject_UnserializedMessageContext<
            UserType, ManifestLocalizedTextObject::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<ManifestLocalizedTextObject::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
  ::blink::String value;
  
  std::optional<Manifest::TextDirection> dir;
  
  ::blink::String lang;

  // Serialise this struct into a trace.
  void WriteIntoTrace(perfetto::TracedValue traced_context) const;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
};

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

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

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

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






class PLATFORM_EXPORT ManifestShortcutItem {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<ManifestShortcutItem, T>::value>;
  using DataView = ManifestShortcutItemDataView;
  using Data_ = internal::ManifestShortcutItem_Data;

  template <typename... Args>
  static ManifestShortcutItemPtr New(Args&&... args) {
    return ManifestShortcutItemPtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static ManifestShortcutItemPtr From(const U& u) {
    return mojo::TypeConverter<ManifestShortcutItemPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, ManifestShortcutItem>::Convert(*this);
  }


  ManifestShortcutItem();

  ManifestShortcutItem(
      const ::blink::String& name,
      const ::blink::String& short_name,
      const ::blink::String& description,
      const ::blink::KURL& url,
      ::blink::Vector<ManifestImageResourcePtr> icons,
      std::optional<::blink::HashMap<::icu::Locale, ManifestLocalizedTextObjectPtr>> name_localized,
      std::optional<::blink::HashMap<::icu::Locale, ManifestLocalizedTextObjectPtr>> short_name_localized,
      std::optional<::blink::HashMap<::icu::Locale, ManifestLocalizedTextObjectPtr>> description_localized,
      std::optional<::blink::HashMap<::icu::Locale, ::blink::Vector<ManifestImageResourcePtr>>> icons_localized);

ManifestShortcutItem(const ManifestShortcutItem&) = delete;
ManifestShortcutItem& operator=(const ManifestShortcutItem&) = delete;

  ~ManifestShortcutItem();

  // Clone() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Clone() or copy
  // constructor/assignment are available for members.
  template <typename StructPtrType = ManifestShortcutItemPtr>
  ManifestShortcutItemPtr Clone() const;

  // Equals() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Equals() or == operator
  // are available for members.
  template <typename T, ManifestShortcutItem::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, ManifestShortcutItem::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, ManifestShortcutItem::EnableIfSame<T>* = nullptr>
  bool operator!=(const T& rhs) const { return !operator==(rhs); }

  template <mojo::internal::SendValidation send_validation, typename UserType>
  static ::blink::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        ManifestShortcutItem::DataView, ::blink::Vector<uint8_t>, send_validation>(input);
  }

  template <typename UserType>
  static ::blink::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        ManifestShortcutItem::DataView, ::blink::Vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        ManifestShortcutItem::DataView>(input);
  }

  // The returned Message is serialized only if the message is moved
  // cross-process or cross-language. Otherwise if the message is Deserialized
  // as the same UserType |input| will just be moved to |output| in
  // DeserializeFromMessage.
  template <typename UserType>
  static mojo::Message WrapAsMessage(UserType input) {
    return mojo::Message(std::make_unique<
        internal::ManifestShortcutItem_UnserializedMessageContext<
            UserType, ManifestShortcutItem::DataView>>(0, 0, std::move(input)),
        MOJO_CREATE_MESSAGE_FLAG_NONE);
  }

  template <typename UserType>
  static bool Deserialize(const void* data,
                          size_t data_num_bytes,
                          UserType* output) {
    mojo::Message message;
    return mojo::internal::DeserializeImpl<ManifestShortcutItem::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(base::span<const uint8_t> input,
                          UserType* output) {
    return ManifestShortcutItem::Deserialize(
        input.empty() ? nullptr : input.data(), input.size(), output);
  }

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    auto context = input.TakeUnserializedContext<
        internal::ManifestShortcutItem_UnserializedMessageContext<
            UserType, ManifestShortcutItem::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<ManifestShortcutItem::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
  ::blink::String name;
  
  ::blink::String short_name;
  
  ::blink::String description;
  
  ::blink::KURL url;
  
  ::blink::Vector<ManifestImageResourcePtr> icons;
  
  std::optional<::blink::HashMap<::icu::Locale, ManifestLocalizedTextObjectPtr>> name_localized;
  
  std::optional<::blink::HashMap<::icu::Locale, ManifestLocalizedTextObjectPtr>> short_name_localized;
  
  std::optional<::blink::HashMap<::icu::Locale, ManifestLocalizedTextObjectPtr>> description_localized;
  
  std::optional<::blink::HashMap<::icu::Locale, ::blink::Vector<ManifestImageResourcePtr>>> icons_localized;

  // Serialise this struct into a trace.
  void WriteIntoTrace(perfetto::TracedValue traced_context) const;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
};

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

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

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

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





class PLATFORM_EXPORT ManifestImageResource {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<ManifestImageResource, T>::value>;
  using DataView = ManifestImageResourceDataView;
  using Data_ = internal::ManifestImageResource_Data;
  using Purpose = ManifestImageResource_Purpose;

  template <typename... Args>
  static ManifestImageResourcePtr New(Args&&... args) {
    return ManifestImageResourcePtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static ManifestImageResourcePtr From(const U& u) {
    return mojo::TypeConverter<ManifestImageResourcePtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, ManifestImageResource>::Convert(*this);
  }


  ManifestImageResource();

  ManifestImageResource(
      const ::blink::KURL& src,
      const ::blink::String& type,
      ::blink::Vector<::gfx::Size> sizes,
      ::blink::Vector<ManifestImageResource::Purpose> purpose);


  ~ManifestImageResource();

  // Clone() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Clone() or copy
  // constructor/assignment are available for members.
  template <typename StructPtrType = ManifestImageResourcePtr>
  ManifestImageResourcePtr Clone() const;

  // Equals() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Equals() or == operator
  // are available for members.
  template <typename T, ManifestImageResource::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, ManifestImageResource::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, ManifestImageResource::EnableIfSame<T>* = nullptr>
  bool operator!=(const T& rhs) const { return !operator==(rhs); }

  template <mojo::internal::SendValidation send_validation, typename UserType>
  static ::blink::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        ManifestImageResource::DataView, ::blink::Vector<uint8_t>, send_validation>(input);
  }

  template <typename UserType>
  static ::blink::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        ManifestImageResource::DataView, ::blink::Vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        ManifestImageResource::DataView>(input);
  }

  // The returned Message is serialized only if the message is moved
  // cross-process or cross-language. Otherwise if the message is Deserialized
  // as the same UserType |input| will just be moved to |output| in
  // DeserializeFromMessage.
  template <typename UserType>
  static mojo::Message WrapAsMessage(UserType input) {
    return mojo::Message(std::make_unique<
        internal::ManifestImageResource_UnserializedMessageContext<
            UserType, ManifestImageResource::DataView>>(0, 0, std::move(input)),
        MOJO_CREATE_MESSAGE_FLAG_NONE);
  }

  template <typename UserType>
  static bool Deserialize(const void* data,
                          size_t data_num_bytes,
                          UserType* output) {
    mojo::Message message;
    return mojo::internal::DeserializeImpl<ManifestImageResource::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(base::span<const uint8_t> input,
                          UserType* output) {
    return ManifestImageResource::Deserialize(
        input.empty() ? nullptr : input.data(), input.size(), output);
  }

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    auto context = input.TakeUnserializedContext<
        internal::ManifestImageResource_UnserializedMessageContext<
            UserType, ManifestImageResource::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<ManifestImageResource::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
  ::blink::KURL src;
  
  ::blink::String type;
  
  ::blink::Vector<::gfx::Size> sizes;
  
  ::blink::Vector<ManifestImageResource::Purpose> purpose;

  // Serialise this struct into a trace.
  void WriteIntoTrace(perfetto::TracedValue traced_context) const;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
};

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

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

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

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





class PLATFORM_EXPORT ManifestScreenshot {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<ManifestScreenshot, T>::value>;
  using DataView = ManifestScreenshotDataView;
  using Data_ = internal::ManifestScreenshot_Data;
  using FormFactor = ManifestScreenshot_FormFactor;

  template <typename... Args>
  static ManifestScreenshotPtr New(Args&&... args) {
    return ManifestScreenshotPtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static ManifestScreenshotPtr From(const U& u) {
    return mojo::TypeConverter<ManifestScreenshotPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, ManifestScreenshot>::Convert(*this);
  }


  ManifestScreenshot();

  ManifestScreenshot(
      ManifestImageResourcePtr image,
      ManifestScreenshot::FormFactor form_factor,
      const ::blink::String& label);

ManifestScreenshot(const ManifestScreenshot&) = delete;
ManifestScreenshot& operator=(const ManifestScreenshot&) = delete;

  ~ManifestScreenshot();

  // Clone() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Clone() or copy
  // constructor/assignment are available for members.
  template <typename StructPtrType = ManifestScreenshotPtr>
  ManifestScreenshotPtr Clone() const;

  // Equals() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Equals() or == operator
  // are available for members.
  template <typename T, ManifestScreenshot::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, ManifestScreenshot::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, ManifestScreenshot::EnableIfSame<T>* = nullptr>
  bool operator!=(const T& rhs) const { return !operator==(rhs); }

  template <mojo::internal::SendValidation send_validation, typename UserType>
  static ::blink::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        ManifestScreenshot::DataView, ::blink::Vector<uint8_t>, send_validation>(input);
  }

  template <typename UserType>
  static ::blink::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        ManifestScreenshot::DataView, ::blink::Vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        ManifestScreenshot::DataView>(input);
  }

  // The returned Message is serialized only if the message is moved
  // cross-process or cross-language. Otherwise if the message is Deserialized
  // as the same UserType |input| will just be moved to |output| in
  // DeserializeFromMessage.
  template <typename UserType>
  static mojo::Message WrapAsMessage(UserType input) {
    return mojo::Message(std::make_unique<
        internal::ManifestScreenshot_UnserializedMessageContext<
            UserType, ManifestScreenshot::DataView>>(0, 0, std::move(input)),
        MOJO_CREATE_MESSAGE_FLAG_NONE);
  }

  template <typename UserType>
  static bool Deserialize(const void* data,
                          size_t data_num_bytes,
                          UserType* output) {
    mojo::Message message;
    return mojo::internal::DeserializeImpl<ManifestScreenshot::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(base::span<const uint8_t> input,
                          UserType* output) {
    return ManifestScreenshot::Deserialize(
        input.empty() ? nullptr : input.data(), input.size(), output);
  }

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    auto context = input.TakeUnserializedContext<
        internal::ManifestScreenshot_UnserializedMessageContext<
            UserType, ManifestScreenshot::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<ManifestScreenshot::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
  ManifestImageResourcePtr image;
  
  ManifestScreenshot::FormFactor form_factor;
  
  ::blink::String label;

  // Serialise this struct into a trace.
  void WriteIntoTrace(perfetto::TracedValue traced_context) const;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
};

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

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

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

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





class PLATFORM_EXPORT ManifestFileFilter {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<ManifestFileFilter, T>::value>;
  using DataView = ManifestFileFilterDataView;
  using Data_ = internal::ManifestFileFilter_Data;

  template <typename... Args>
  static ManifestFileFilterPtr New(Args&&... args) {
    return ManifestFileFilterPtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static ManifestFileFilterPtr From(const U& u) {
    return mojo::TypeConverter<ManifestFileFilterPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, ManifestFileFilter>::Convert(*this);
  }


  ManifestFileFilter();

  ManifestFileFilter(
      const ::blink::String& name,
      ::blink::Vector<::blink::String> accept);


  ~ManifestFileFilter();

  // Clone() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Clone() or copy
  // constructor/assignment are available for members.
  template <typename StructPtrType = ManifestFileFilterPtr>
  ManifestFileFilterPtr Clone() const;

  // Equals() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Equals() or == operator
  // are available for members.
  template <typename T, ManifestFileFilter::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, ManifestFileFilter::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, ManifestFileFilter::EnableIfSame<T>* = nullptr>
  bool operator!=(const T& rhs) const { return !operator==(rhs); }

  template <mojo::internal::SendValidation send_validation, typename UserType>
  static ::blink::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        ManifestFileFilter::DataView, ::blink::Vector<uint8_t>, send_validation>(input);
  }

  template <typename UserType>
  static ::blink::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        ManifestFileFilter::DataView, ::blink::Vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        ManifestFileFilter::DataView>(input);
  }

  // The returned Message is serialized only if the message is moved
  // cross-process or cross-language. Otherwise if the message is Deserialized
  // as the same UserType |input| will just be moved to |output| in
  // DeserializeFromMessage.
  template <typename UserType>
  static mojo::Message WrapAsMessage(UserType input) {
    return mojo::Message(std::make_unique<
        internal::ManifestFileFilter_UnserializedMessageContext<
            UserType, ManifestFileFilter::DataView>>(0, 0, std::move(input)),
        MOJO_CREATE_MESSAGE_FLAG_NONE);
  }

  template <typename UserType>
  static bool Deserialize(const void* data,
                          size_t data_num_bytes,
                          UserType* output) {
    mojo::Message message;
    return mojo::internal::DeserializeImpl<ManifestFileFilter::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(base::span<const uint8_t> input,
                          UserType* output) {
    return ManifestFileFilter::Deserialize(
        input.empty() ? nullptr : input.data(), input.size(), output);
  }

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    auto context = input.TakeUnserializedContext<
        internal::ManifestFileFilter_UnserializedMessageContext<
            UserType, ManifestFileFilter::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<ManifestFileFilter::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
  ::blink::String name;
  
  ::blink::Vector<::blink::String> accept;

  // Serialise this struct into a trace.
  void WriteIntoTrace(perfetto::TracedValue traced_context) const;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
};

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

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

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

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





class PLATFORM_EXPORT ManifestProtocolHandler {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<ManifestProtocolHandler, T>::value>;
  using DataView = ManifestProtocolHandlerDataView;
  using Data_ = internal::ManifestProtocolHandler_Data;

  template <typename... Args>
  static ManifestProtocolHandlerPtr New(Args&&... args) {
    return ManifestProtocolHandlerPtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static ManifestProtocolHandlerPtr From(const U& u) {
    return mojo::TypeConverter<ManifestProtocolHandlerPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, ManifestProtocolHandler>::Convert(*this);
  }


  ManifestProtocolHandler();

  ManifestProtocolHandler(
      const ::blink::String& protocol,
      const ::blink::KURL& url);


  ~ManifestProtocolHandler();

  // Clone() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Clone() or copy
  // constructor/assignment are available for members.
  template <typename StructPtrType = ManifestProtocolHandlerPtr>
  ManifestProtocolHandlerPtr Clone() const;

  // Equals() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Equals() or == operator
  // are available for members.
  template <typename T, ManifestProtocolHandler::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, ManifestProtocolHandler::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, ManifestProtocolHandler::EnableIfSame<T>* = nullptr>
  bool operator!=(const T& rhs) const { return !operator==(rhs); }

  template <mojo::internal::SendValidation send_validation, typename UserType>
  static ::blink::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        ManifestProtocolHandler::DataView, ::blink::Vector<uint8_t>, send_validation>(input);
  }

  template <typename UserType>
  static ::blink::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        ManifestProtocolHandler::DataView, ::blink::Vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        ManifestProtocolHandler::DataView>(input);
  }

  // The returned Message is serialized only if the message is moved
  // cross-process or cross-language. Otherwise if the message is Deserialized
  // as the same UserType |input| will just be moved to |output| in
  // DeserializeFromMessage.
  template <typename UserType>
  static mojo::Message WrapAsMessage(UserType input) {
    return mojo::Message(std::make_unique<
        internal::ManifestProtocolHandler_UnserializedMessageContext<
            UserType, ManifestProtocolHandler::DataView>>(0, 0, std::move(input)),
        MOJO_CREATE_MESSAGE_FLAG_NONE);
  }

  template <typename UserType>
  static bool Deserialize(const void* data,
                          size_t data_num_bytes,
                          UserType* output) {
    mojo::Message message;
    return mojo::internal::DeserializeImpl<ManifestProtocolHandler::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(base::span<const uint8_t> input,
                          UserType* output) {
    return ManifestProtocolHandler::Deserialize(
        input.empty() ? nullptr : input.data(), input.size(), output);
  }

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    auto context = input.TakeUnserializedContext<
        internal::ManifestProtocolHandler_UnserializedMessageContext<
            UserType, ManifestProtocolHandler::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<ManifestProtocolHandler::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
  ::blink::String protocol;
  
  ::blink::KURL url;

  // Serialise this struct into a trace.
  void WriteIntoTrace(perfetto::TracedValue traced_context) const;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
};

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

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

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

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





class PLATFORM_EXPORT ManifestScopeExtension {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<ManifestScopeExtension, T>::value>;
  using DataView = ManifestScopeExtensionDataView;
  using Data_ = internal::ManifestScopeExtension_Data;

  template <typename... Args>
  static ManifestScopeExtensionPtr New(Args&&... args) {
    return ManifestScopeExtensionPtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static ManifestScopeExtensionPtr From(const U& u) {
    return mojo::TypeConverter<ManifestScopeExtensionPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, ManifestScopeExtension>::Convert(*this);
  }


  ManifestScopeExtension();

  ManifestScopeExtension(
      const ::scoped_refptr<const ::blink::SecurityOrigin>& origin,
      bool has_origin_wildcard);


  ~ManifestScopeExtension();

  // Clone() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Clone() or copy
  // constructor/assignment are available for members.
  template <typename StructPtrType = ManifestScopeExtensionPtr>
  ManifestScopeExtensionPtr Clone() const;

  // Equals() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Equals() or == operator
  // are available for members.
  template <typename T, ManifestScopeExtension::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, ManifestScopeExtension::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, ManifestScopeExtension::EnableIfSame<T>* = nullptr>
  bool operator!=(const T& rhs) const { return !operator==(rhs); }

  template <mojo::internal::SendValidation send_validation, typename UserType>
  static ::blink::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        ManifestScopeExtension::DataView, ::blink::Vector<uint8_t>, send_validation>(input);
  }

  template <typename UserType>
  static ::blink::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        ManifestScopeExtension::DataView, ::blink::Vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        ManifestScopeExtension::DataView>(input);
  }

  // The returned Message is serialized only if the message is moved
  // cross-process or cross-language. Otherwise if the message is Deserialized
  // as the same UserType |input| will just be moved to |output| in
  // DeserializeFromMessage.
  template <typename UserType>
  static mojo::Message WrapAsMessage(UserType input) {
    return mojo::Message(std::make_unique<
        internal::ManifestScopeExtension_UnserializedMessageContext<
            UserType, ManifestScopeExtension::DataView>>(0, 0, std::move(input)),
        MOJO_CREATE_MESSAGE_FLAG_NONE);
  }

  template <typename UserType>
  static bool Deserialize(const void* data,
                          size_t data_num_bytes,
                          UserType* output) {
    mojo::Message message;
    return mojo::internal::DeserializeImpl<ManifestScopeExtension::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(base::span<const uint8_t> input,
                          UserType* output) {
    return ManifestScopeExtension::Deserialize(
        input.empty() ? nullptr : input.data(), input.size(), output);
  }

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    auto context = input.TakeUnserializedContext<
        internal::ManifestScopeExtension_UnserializedMessageContext<
            UserType, ManifestScopeExtension::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<ManifestScopeExtension::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
  ::scoped_refptr<const ::blink::SecurityOrigin> origin;
  
  bool has_origin_wildcard;

  // Serialise this struct into a trace.
  void WriteIntoTrace(perfetto::TracedValue traced_context) const;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
};

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

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

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

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





class PLATFORM_EXPORT ManifestLockScreen {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<ManifestLockScreen, T>::value>;
  using DataView = ManifestLockScreenDataView;
  using Data_ = internal::ManifestLockScreen_Data;

  template <typename... Args>
  static ManifestLockScreenPtr New(Args&&... args) {
    return ManifestLockScreenPtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static ManifestLockScreenPtr From(const U& u) {
    return mojo::TypeConverter<ManifestLockScreenPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, ManifestLockScreen>::Convert(*this);
  }


  ManifestLockScreen();

  explicit ManifestLockScreen(
      const ::blink::KURL& start_url);


  ~ManifestLockScreen();

  // Clone() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Clone() or copy
  // constructor/assignment are available for members.
  template <typename StructPtrType = ManifestLockScreenPtr>
  ManifestLockScreenPtr Clone() const;

  // Equals() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Equals() or == operator
  // are available for members.
  template <typename T, ManifestLockScreen::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, ManifestLockScreen::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, ManifestLockScreen::EnableIfSame<T>* = nullptr>
  bool operator!=(const T& rhs) const { return !operator==(rhs); }

  template <mojo::internal::SendValidation send_validation, typename UserType>
  static ::blink::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        ManifestLockScreen::DataView, ::blink::Vector<uint8_t>, send_validation>(input);
  }

  template <typename UserType>
  static ::blink::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        ManifestLockScreen::DataView, ::blink::Vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        ManifestLockScreen::DataView>(input);
  }

  // The returned Message is serialized only if the message is moved
  // cross-process or cross-language. Otherwise if the message is Deserialized
  // as the same UserType |input| will just be moved to |output| in
  // DeserializeFromMessage.
  template <typename UserType>
  static mojo::Message WrapAsMessage(UserType input) {
    return mojo::Message(std::make_unique<
        internal::ManifestLockScreen_UnserializedMessageContext<
            UserType, ManifestLockScreen::DataView>>(0, 0, std::move(input)),
        MOJO_CREATE_MESSAGE_FLAG_NONE);
  }

  template <typename UserType>
  static bool Deserialize(const void* data,
                          size_t data_num_bytes,
                          UserType* output) {
    mojo::Message message;
    return mojo::internal::DeserializeImpl<ManifestLockScreen::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(base::span<const uint8_t> input,
                          UserType* output) {
    return ManifestLockScreen::Deserialize(
        input.empty() ? nullptr : input.data(), input.size(), output);
  }

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    auto context = input.TakeUnserializedContext<
        internal::ManifestLockScreen_UnserializedMessageContext<
            UserType, ManifestLockScreen::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<ManifestLockScreen::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
  ::blink::KURL start_url;

  // Serialise this struct into a trace.
  void WriteIntoTrace(perfetto::TracedValue traced_context) const;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
};

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

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

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

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





class PLATFORM_EXPORT ManifestNoteTaking {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<ManifestNoteTaking, T>::value>;
  using DataView = ManifestNoteTakingDataView;
  using Data_ = internal::ManifestNoteTaking_Data;

  template <typename... Args>
  static ManifestNoteTakingPtr New(Args&&... args) {
    return ManifestNoteTakingPtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static ManifestNoteTakingPtr From(const U& u) {
    return mojo::TypeConverter<ManifestNoteTakingPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, ManifestNoteTaking>::Convert(*this);
  }


  ManifestNoteTaking();

  explicit ManifestNoteTaking(
      const ::blink::KURL& new_note_url);


  ~ManifestNoteTaking();

  // Clone() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Clone() or copy
  // constructor/assignment are available for members.
  template <typename StructPtrType = ManifestNoteTakingPtr>
  ManifestNoteTakingPtr Clone() const;

  // Equals() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Equals() or == operator
  // are available for members.
  template <typename T, ManifestNoteTaking::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, ManifestNoteTaking::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, ManifestNoteTaking::EnableIfSame<T>* = nullptr>
  bool operator!=(const T& rhs) const { return !operator==(rhs); }

  template <mojo::internal::SendValidation send_validation, typename UserType>
  static ::blink::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        ManifestNoteTaking::DataView, ::blink::Vector<uint8_t>, send_validation>(input);
  }

  template <typename UserType>
  static ::blink::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        ManifestNoteTaking::DataView, ::blink::Vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        ManifestNoteTaking::DataView>(input);
  }

  // The returned Message is serialized only if the message is moved
  // cross-process or cross-language. Otherwise if the message is Deserialized
  // as the same UserType |input| will just be moved to |output| in
  // DeserializeFromMessage.
  template <typename UserType>
  static mojo::Message WrapAsMessage(UserType input) {
    return mojo::Message(std::make_unique<
        internal::ManifestNoteTaking_UnserializedMessageContext<
            UserType, ManifestNoteTaking::DataView>>(0, 0, std::move(input)),
        MOJO_CREATE_MESSAGE_FLAG_NONE);
  }

  template <typename UserType>
  static bool Deserialize(const void* data,
                          size_t data_num_bytes,
                          UserType* output) {
    mojo::Message message;
    return mojo::internal::DeserializeImpl<ManifestNoteTaking::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(base::span<const uint8_t> input,
                          UserType* output) {
    return ManifestNoteTaking::Deserialize(
        input.empty() ? nullptr : input.data(), input.size(), output);
  }

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    auto context = input.TakeUnserializedContext<
        internal::ManifestNoteTaking_UnserializedMessageContext<
            UserType, ManifestNoteTaking::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<ManifestNoteTaking::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
  ::blink::KURL new_note_url;

  // Serialise this struct into a trace.
  void WriteIntoTrace(perfetto::TracedValue traced_context) const;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
};

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

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

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

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





class PLATFORM_EXPORT ManifestRelatedApplication {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<ManifestRelatedApplication, T>::value>;
  using DataView = ManifestRelatedApplicationDataView;
  using Data_ = internal::ManifestRelatedApplication_Data;

  template <typename... Args>
  static ManifestRelatedApplicationPtr New(Args&&... args) {
    return ManifestRelatedApplicationPtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static ManifestRelatedApplicationPtr From(const U& u) {
    return mojo::TypeConverter<ManifestRelatedApplicationPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, ManifestRelatedApplication>::Convert(*this);
  }


  ManifestRelatedApplication();

  ManifestRelatedApplication(
      const ::blink::String& platform,
      const std::optional<::blink::KURL>& url,
      const ::blink::String& id);


  ~ManifestRelatedApplication();

  // Clone() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Clone() or copy
  // constructor/assignment are available for members.
  template <typename StructPtrType = ManifestRelatedApplicationPtr>
  ManifestRelatedApplicationPtr Clone() const;

  // Equals() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Equals() or == operator
  // are available for members.
  template <typename T, ManifestRelatedApplication::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, ManifestRelatedApplication::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, ManifestRelatedApplication::EnableIfSame<T>* = nullptr>
  bool operator!=(const T& rhs) const { return !operator==(rhs); }

  template <mojo::internal::SendValidation send_validation, typename UserType>
  static ::blink::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        ManifestRelatedApplication::DataView, ::blink::Vector<uint8_t>, send_validation>(input);
  }

  template <typename UserType>
  static ::blink::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        ManifestRelatedApplication::DataView, ::blink::Vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        ManifestRelatedApplication::DataView>(input);
  }

  // The returned Message is serialized only if the message is moved
  // cross-process or cross-language. Otherwise if the message is Deserialized
  // as the same UserType |input| will just be moved to |output| in
  // DeserializeFromMessage.
  template <typename UserType>
  static mojo::Message WrapAsMessage(UserType input) {
    return mojo::Message(std::make_unique<
        internal::ManifestRelatedApplication_UnserializedMessageContext<
            UserType, ManifestRelatedApplication::DataView>>(0, 0, std::move(input)),
        MOJO_CREATE_MESSAGE_FLAG_NONE);
  }

  template <typename UserType>
  static bool Deserialize(const void* data,
                          size_t data_num_bytes,
                          UserType* output) {
    mojo::Message message;
    return mojo::internal::DeserializeImpl<ManifestRelatedApplication::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(base::span<const uint8_t> input,
                          UserType* output) {
    return ManifestRelatedApplication::Deserialize(
        input.empty() ? nullptr : input.data(), input.size(), output);
  }

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    auto context = input.TakeUnserializedContext<
        internal::ManifestRelatedApplication_UnserializedMessageContext<
            UserType, ManifestRelatedApplication::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<ManifestRelatedApplication::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
  ::blink::String platform;
  
  std::optional<::blink::KURL> url;
  
  ::blink::String id;

  // Serialise this struct into a trace.
  void WriteIntoTrace(perfetto::TracedValue traced_context) const;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
};

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

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

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

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





class PLATFORM_EXPORT ManifestShareTargetParams {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<ManifestShareTargetParams, T>::value>;
  using DataView = ManifestShareTargetParamsDataView;
  using Data_ = internal::ManifestShareTargetParams_Data;

  template <typename... Args>
  static ManifestShareTargetParamsPtr New(Args&&... args) {
    return ManifestShareTargetParamsPtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static ManifestShareTargetParamsPtr From(const U& u) {
    return mojo::TypeConverter<ManifestShareTargetParamsPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, ManifestShareTargetParams>::Convert(*this);
  }


  ManifestShareTargetParams();

  ManifestShareTargetParams(
      const ::blink::String& title,
      const ::blink::String& text,
      const ::blink::String& url,
      std::optional<::blink::Vector<ManifestFileFilterPtr>> files);

ManifestShareTargetParams(const ManifestShareTargetParams&) = delete;
ManifestShareTargetParams& operator=(const ManifestShareTargetParams&) = delete;

  ~ManifestShareTargetParams();

  // Clone() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Clone() or copy
  // constructor/assignment are available for members.
  template <typename StructPtrType = ManifestShareTargetParamsPtr>
  ManifestShareTargetParamsPtr Clone() const;

  // Equals() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Equals() or == operator
  // are available for members.
  template <typename T, ManifestShareTargetParams::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, ManifestShareTargetParams::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, ManifestShareTargetParams::EnableIfSame<T>* = nullptr>
  bool operator!=(const T& rhs) const { return !operator==(rhs); }

  template <mojo::internal::SendValidation send_validation, typename UserType>
  static ::blink::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        ManifestShareTargetParams::DataView, ::blink::Vector<uint8_t>, send_validation>(input);
  }

  template <typename UserType>
  static ::blink::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        ManifestShareTargetParams::DataView, ::blink::Vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        ManifestShareTargetParams::DataView>(input);
  }

  // The returned Message is serialized only if the message is moved
  // cross-process or cross-language. Otherwise if the message is Deserialized
  // as the same UserType |input| will just be moved to |output| in
  // DeserializeFromMessage.
  template <typename UserType>
  static mojo::Message WrapAsMessage(UserType input) {
    return mojo::Message(std::make_unique<
        internal::ManifestShareTargetParams_UnserializedMessageContext<
            UserType, ManifestShareTargetParams::DataView>>(0, 0, std::move(input)),
        MOJO_CREATE_MESSAGE_FLAG_NONE);
  }

  template <typename UserType>
  static bool Deserialize(const void* data,
                          size_t data_num_bytes,
                          UserType* output) {
    mojo::Message message;
    return mojo::internal::DeserializeImpl<ManifestShareTargetParams::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(base::span<const uint8_t> input,
                          UserType* output) {
    return ManifestShareTargetParams::Deserialize(
        input.empty() ? nullptr : input.data(), input.size(), output);
  }

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    auto context = input.TakeUnserializedContext<
        internal::ManifestShareTargetParams_UnserializedMessageContext<
            UserType, ManifestShareTargetParams::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<ManifestShareTargetParams::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
  ::blink::String title;
  
  ::blink::String text;
  
  ::blink::String url;
  
  std::optional<::blink::Vector<ManifestFileFilterPtr>> files;

  // Serialise this struct into a trace.
  void WriteIntoTrace(perfetto::TracedValue traced_context) const;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
};

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

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

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

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





class PLATFORM_EXPORT ManifestShareTarget {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<ManifestShareTarget, T>::value>;
  using DataView = ManifestShareTargetDataView;
  using Data_ = internal::ManifestShareTarget_Data;
  using Method = ManifestShareTarget_Method;
  using Enctype = ManifestShareTarget_Enctype;

  template <typename... Args>
  static ManifestShareTargetPtr New(Args&&... args) {
    return ManifestShareTargetPtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static ManifestShareTargetPtr From(const U& u) {
    return mojo::TypeConverter<ManifestShareTargetPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, ManifestShareTarget>::Convert(*this);
  }


  ManifestShareTarget();

  ManifestShareTarget(
      const ::blink::KURL& action,
      ManifestShareTarget::Method method,
      ManifestShareTarget::Enctype enctype,
      ManifestShareTargetParamsPtr params);

ManifestShareTarget(const ManifestShareTarget&) = delete;
ManifestShareTarget& operator=(const ManifestShareTarget&) = delete;

  ~ManifestShareTarget();

  // Clone() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Clone() or copy
  // constructor/assignment are available for members.
  template <typename StructPtrType = ManifestShareTargetPtr>
  ManifestShareTargetPtr Clone() const;

  // Equals() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Equals() or == operator
  // are available for members.
  template <typename T, ManifestShareTarget::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, ManifestShareTarget::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, ManifestShareTarget::EnableIfSame<T>* = nullptr>
  bool operator!=(const T& rhs) const { return !operator==(rhs); }

  template <mojo::internal::SendValidation send_validation, typename UserType>
  static ::blink::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        ManifestShareTarget::DataView, ::blink::Vector<uint8_t>, send_validation>(input);
  }

  template <typename UserType>
  static ::blink::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        ManifestShareTarget::DataView, ::blink::Vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        ManifestShareTarget::DataView>(input);
  }

  // The returned Message is serialized only if the message is moved
  // cross-process or cross-language. Otherwise if the message is Deserialized
  // as the same UserType |input| will just be moved to |output| in
  // DeserializeFromMessage.
  template <typename UserType>
  static mojo::Message WrapAsMessage(UserType input) {
    return mojo::Message(std::make_unique<
        internal::ManifestShareTarget_UnserializedMessageContext<
            UserType, ManifestShareTarget::DataView>>(0, 0, std::move(input)),
        MOJO_CREATE_MESSAGE_FLAG_NONE);
  }

  template <typename UserType>
  static bool Deserialize(const void* data,
                          size_t data_num_bytes,
                          UserType* output) {
    mojo::Message message;
    return mojo::internal::DeserializeImpl<ManifestShareTarget::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(base::span<const uint8_t> input,
                          UserType* output) {
    return ManifestShareTarget::Deserialize(
        input.empty() ? nullptr : input.data(), input.size(), output);
  }

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    auto context = input.TakeUnserializedContext<
        internal::ManifestShareTarget_UnserializedMessageContext<
            UserType, ManifestShareTarget::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<ManifestShareTarget::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
  ::blink::KURL action;
  
  ManifestShareTarget::Method method;
  
  ManifestShareTarget::Enctype enctype;
  
  ManifestShareTargetParamsPtr params;

  // Serialise this struct into a trace.
  void WriteIntoTrace(perfetto::TracedValue traced_context) const;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
};

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

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

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

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





class PLATFORM_EXPORT ManifestFileHandler {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<ManifestFileHandler, T>::value>;
  using DataView = ManifestFileHandlerDataView;
  using Data_ = internal::ManifestFileHandler_Data;
  using LaunchType = ManifestFileHandler_LaunchType;

  template <typename... Args>
  static ManifestFileHandlerPtr New(Args&&... args) {
    return ManifestFileHandlerPtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static ManifestFileHandlerPtr From(const U& u) {
    return mojo::TypeConverter<ManifestFileHandlerPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, ManifestFileHandler>::Convert(*this);
  }


  ManifestFileHandler();

  ManifestFileHandler(
      const ::blink::KURL& action,
      const ::blink::String& name,
      const ::blink::HashMap<::blink::String, ::blink::Vector<::blink::String>>& accept,
      ManifestFileHandler::LaunchType launch_type);


  ~ManifestFileHandler();

  // Clone() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Clone() or copy
  // constructor/assignment are available for members.
  template <typename StructPtrType = ManifestFileHandlerPtr>
  ManifestFileHandlerPtr Clone() const;

  // Equals() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Equals() or == operator
  // are available for members.
  template <typename T, ManifestFileHandler::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, ManifestFileHandler::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, ManifestFileHandler::EnableIfSame<T>* = nullptr>
  bool operator!=(const T& rhs) const { return !operator==(rhs); }

  template <mojo::internal::SendValidation send_validation, typename UserType>
  static ::blink::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        ManifestFileHandler::DataView, ::blink::Vector<uint8_t>, send_validation>(input);
  }

  template <typename UserType>
  static ::blink::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        ManifestFileHandler::DataView, ::blink::Vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        ManifestFileHandler::DataView>(input);
  }

  // The returned Message is serialized only if the message is moved
  // cross-process or cross-language. Otherwise if the message is Deserialized
  // as the same UserType |input| will just be moved to |output| in
  // DeserializeFromMessage.
  template <typename UserType>
  static mojo::Message WrapAsMessage(UserType input) {
    return mojo::Message(std::make_unique<
        internal::ManifestFileHandler_UnserializedMessageContext<
            UserType, ManifestFileHandler::DataView>>(0, 0, std::move(input)),
        MOJO_CREATE_MESSAGE_FLAG_NONE);
  }

  template <typename UserType>
  static bool Deserialize(const void* data,
                          size_t data_num_bytes,
                          UserType* output) {
    mojo::Message message;
    return mojo::internal::DeserializeImpl<ManifestFileHandler::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(base::span<const uint8_t> input,
                          UserType* output) {
    return ManifestFileHandler::Deserialize(
        input.empty() ? nullptr : input.data(), input.size(), output);
  }

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    auto context = input.TakeUnserializedContext<
        internal::ManifestFileHandler_UnserializedMessageContext<
            UserType, ManifestFileHandler::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<ManifestFileHandler::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
  ::blink::KURL action;
  
  ::blink::String name;
  
  ::blink::HashMap<::blink::String, ::blink::Vector<::blink::String>> accept;
  
  ManifestFileHandler::LaunchType launch_type;

  // Serialise this struct into a trace.
  void WriteIntoTrace(perfetto::TracedValue traced_context) const;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
};

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

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

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

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





class PLATFORM_EXPORT ManifestTranslationItem {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<ManifestTranslationItem, T>::value>;
  using DataView = ManifestTranslationItemDataView;
  using Data_ = internal::ManifestTranslationItem_Data;

  template <typename... Args>
  static ManifestTranslationItemPtr New(Args&&... args) {
    return ManifestTranslationItemPtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static ManifestTranslationItemPtr From(const U& u) {
    return mojo::TypeConverter<ManifestTranslationItemPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, ManifestTranslationItem>::Convert(*this);
  }


  ManifestTranslationItem();

  ManifestTranslationItem(
      const ::blink::String& name,
      const ::blink::String& short_name,
      const ::blink::String& description);


  ~ManifestTranslationItem();

  // Clone() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Clone() or copy
  // constructor/assignment are available for members.
  template <typename StructPtrType = ManifestTranslationItemPtr>
  ManifestTranslationItemPtr Clone() const;

  // Equals() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Equals() or == operator
  // are available for members.
  template <typename T, ManifestTranslationItem::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, ManifestTranslationItem::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, ManifestTranslationItem::EnableIfSame<T>* = nullptr>
  bool operator!=(const T& rhs) const { return !operator==(rhs); }

  template <mojo::internal::SendValidation send_validation, typename UserType>
  static ::blink::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        ManifestTranslationItem::DataView, ::blink::Vector<uint8_t>, send_validation>(input);
  }

  template <typename UserType>
  static ::blink::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        ManifestTranslationItem::DataView, ::blink::Vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        ManifestTranslationItem::DataView>(input);
  }

  // The returned Message is serialized only if the message is moved
  // cross-process or cross-language. Otherwise if the message is Deserialized
  // as the same UserType |input| will just be moved to |output| in
  // DeserializeFromMessage.
  template <typename UserType>
  static mojo::Message WrapAsMessage(UserType input) {
    return mojo::Message(std::make_unique<
        internal::ManifestTranslationItem_UnserializedMessageContext<
            UserType, ManifestTranslationItem::DataView>>(0, 0, std::move(input)),
        MOJO_CREATE_MESSAGE_FLAG_NONE);
  }

  template <typename UserType>
  static bool Deserialize(const void* data,
                          size_t data_num_bytes,
                          UserType* output) {
    mojo::Message message;
    return mojo::internal::DeserializeImpl<ManifestTranslationItem::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(base::span<const uint8_t> input,
                          UserType* output) {
    return ManifestTranslationItem::Deserialize(
        input.empty() ? nullptr : input.data(), input.size(), output);
  }

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    auto context = input.TakeUnserializedContext<
        internal::ManifestTranslationItem_UnserializedMessageContext<
            UserType, ManifestTranslationItem::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<ManifestTranslationItem::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
  ::blink::String name;
  
  ::blink::String short_name;
  
  ::blink::String description;

  // Serialise this struct into a trace.
  void WriteIntoTrace(perfetto::TracedValue traced_context) const;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
};

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

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

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

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





class PLATFORM_EXPORT ManifestMigrateFrom {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<ManifestMigrateFrom, T>::value>;
  using DataView = ManifestMigrateFromDataView;
  using Data_ = internal::ManifestMigrateFrom_Data;

  template <typename... Args>
  static ManifestMigrateFromPtr New(Args&&... args) {
    return ManifestMigrateFromPtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static ManifestMigrateFromPtr From(const U& u) {
    return mojo::TypeConverter<ManifestMigrateFromPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, ManifestMigrateFrom>::Convert(*this);
  }


  ManifestMigrateFrom();

  ManifestMigrateFrom(
      const ::blink::KURL& id,
      const std::optional<::blink::KURL>& install_url,
      ::blink::mojom::blink::ManifestMigrationBehavior behavior);


  ~ManifestMigrateFrom();

  // Clone() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Clone() or copy
  // constructor/assignment are available for members.
  template <typename StructPtrType = ManifestMigrateFromPtr>
  ManifestMigrateFromPtr Clone() const;

  // Equals() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Equals() or == operator
  // are available for members.
  template <typename T, ManifestMigrateFrom::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, ManifestMigrateFrom::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, ManifestMigrateFrom::EnableIfSame<T>* = nullptr>
  bool operator!=(const T& rhs) const { return !operator==(rhs); }

  template <mojo::internal::SendValidation send_validation, typename UserType>
  static ::blink::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        ManifestMigrateFrom::DataView, ::blink::Vector<uint8_t>, send_validation>(input);
  }

  template <typename UserType>
  static ::blink::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        ManifestMigrateFrom::DataView, ::blink::Vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        ManifestMigrateFrom::DataView>(input);
  }

  // The returned Message is serialized only if the message is moved
  // cross-process or cross-language. Otherwise if the message is Deserialized
  // as the same UserType |input| will just be moved to |output| in
  // DeserializeFromMessage.
  template <typename UserType>
  static mojo::Message WrapAsMessage(UserType input) {
    return mojo::Message(std::make_unique<
        internal::ManifestMigrateFrom_UnserializedMessageContext<
            UserType, ManifestMigrateFrom::DataView>>(0, 0, std::move(input)),
        MOJO_CREATE_MESSAGE_FLAG_NONE);
  }

  template <typename UserType>
  static bool Deserialize(const void* data,
                          size_t data_num_bytes,
                          UserType* output) {
    mojo::Message message;
    return mojo::internal::DeserializeImpl<ManifestMigrateFrom::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(base::span<const uint8_t> input,
                          UserType* output) {
    return ManifestMigrateFrom::Deserialize(
        input.empty() ? nullptr : input.data(), input.size(), output);
  }

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    auto context = input.TakeUnserializedContext<
        internal::ManifestMigrateFrom_UnserializedMessageContext<
            UserType, ManifestMigrateFrom::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<ManifestMigrateFrom::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
  ::blink::KURL id;
  
  std::optional<::blink::KURL> install_url;
  
  ::blink::mojom::blink::ManifestMigrationBehavior behavior;

  // Serialise this struct into a trace.
  void WriteIntoTrace(perfetto::TracedValue traced_context) const;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
};

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

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

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

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





class PLATFORM_EXPORT ManifestMigrateTo {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<ManifestMigrateTo, T>::value>;
  using DataView = ManifestMigrateToDataView;
  using Data_ = internal::ManifestMigrateTo_Data;

  template <typename... Args>
  static ManifestMigrateToPtr New(Args&&... args) {
    return ManifestMigrateToPtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static ManifestMigrateToPtr From(const U& u) {
    return mojo::TypeConverter<ManifestMigrateToPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, ManifestMigrateTo>::Convert(*this);
  }


  ManifestMigrateTo();

  ManifestMigrateTo(
      const ::blink::KURL& id,
      const ::blink::KURL& install_url);


  ~ManifestMigrateTo();

  // Clone() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Clone() or copy
  // constructor/assignment are available for members.
  template <typename StructPtrType = ManifestMigrateToPtr>
  ManifestMigrateToPtr Clone() const;

  // Equals() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Equals() or == operator
  // are available for members.
  template <typename T, ManifestMigrateTo::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, ManifestMigrateTo::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, ManifestMigrateTo::EnableIfSame<T>* = nullptr>
  bool operator!=(const T& rhs) const { return !operator==(rhs); }

  template <mojo::internal::SendValidation send_validation, typename UserType>
  static ::blink::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        ManifestMigrateTo::DataView, ::blink::Vector<uint8_t>, send_validation>(input);
  }

  template <typename UserType>
  static ::blink::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        ManifestMigrateTo::DataView, ::blink::Vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        ManifestMigrateTo::DataView>(input);
  }

  // The returned Message is serialized only if the message is moved
  // cross-process or cross-language. Otherwise if the message is Deserialized
  // as the same UserType |input| will just be moved to |output| in
  // DeserializeFromMessage.
  template <typename UserType>
  static mojo::Message WrapAsMessage(UserType input) {
    return mojo::Message(std::make_unique<
        internal::ManifestMigrateTo_UnserializedMessageContext<
            UserType, ManifestMigrateTo::DataView>>(0, 0, std::move(input)),
        MOJO_CREATE_MESSAGE_FLAG_NONE);
  }

  template <typename UserType>
  static bool Deserialize(const void* data,
                          size_t data_num_bytes,
                          UserType* output) {
    mojo::Message message;
    return mojo::internal::DeserializeImpl<ManifestMigrateTo::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(base::span<const uint8_t> input,
                          UserType* output) {
    return ManifestMigrateTo::Deserialize(
        input.empty() ? nullptr : input.data(), input.size(), output);
  }

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    auto context = input.TakeUnserializedContext<
        internal::ManifestMigrateTo_UnserializedMessageContext<
            UserType, ManifestMigrateTo::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<ManifestMigrateTo::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
  ::blink::KURL id;
  
  ::blink::KURL install_url;

  // Serialise this struct into a trace.
  void WriteIntoTrace(perfetto::TracedValue traced_context) const;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
};

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

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

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

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





class PLATFORM_EXPORT ManifestTabStrip {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<ManifestTabStrip, T>::value>;
  using DataView = ManifestTabStripDataView;
  using Data_ = internal::ManifestTabStrip_Data;

  template <typename... Args>
  static ManifestTabStripPtr New(Args&&... args) {
    return ManifestTabStripPtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static ManifestTabStripPtr From(const U& u) {
    return mojo::TypeConverter<ManifestTabStripPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, ManifestTabStrip>::Convert(*this);
  }


  ManifestTabStrip();

  ManifestTabStrip(
      HomeTabUnionPtr home_tab,
      NewTabButtonParamsPtr new_tab_button);

ManifestTabStrip(const ManifestTabStrip&) = delete;
ManifestTabStrip& operator=(const ManifestTabStrip&) = delete;

  ~ManifestTabStrip();

  // Clone() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Clone() or copy
  // constructor/assignment are available for members.
  template <typename StructPtrType = ManifestTabStripPtr>
  ManifestTabStripPtr Clone() const;

  // Equals() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Equals() or == operator
  // are available for members.
  template <typename T, ManifestTabStrip::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, ManifestTabStrip::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, ManifestTabStrip::EnableIfSame<T>* = nullptr>
  bool operator!=(const T& rhs) const { return !operator==(rhs); }

  template <mojo::internal::SendValidation send_validation, typename UserType>
  static ::blink::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        ManifestTabStrip::DataView, ::blink::Vector<uint8_t>, send_validation>(input);
  }

  template <typename UserType>
  static ::blink::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        ManifestTabStrip::DataView, ::blink::Vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        ManifestTabStrip::DataView>(input);
  }

  // The returned Message is serialized only if the message is moved
  // cross-process or cross-language. Otherwise if the message is Deserialized
  // as the same UserType |input| will just be moved to |output| in
  // DeserializeFromMessage.
  template <typename UserType>
  static mojo::Message WrapAsMessage(UserType input) {
    return mojo::Message(std::make_unique<
        internal::ManifestTabStrip_UnserializedMessageContext<
            UserType, ManifestTabStrip::DataView>>(0, 0, std::move(input)),
        MOJO_CREATE_MESSAGE_FLAG_NONE);
  }

  template <typename UserType>
  static bool Deserialize(const void* data,
                          size_t data_num_bytes,
                          UserType* output) {
    mojo::Message message;
    return mojo::internal::DeserializeImpl<ManifestTabStrip::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(base::span<const uint8_t> input,
                          UserType* output) {
    return ManifestTabStrip::Deserialize(
        input.empty() ? nullptr : input.data(), input.size(), output);
  }

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    auto context = input.TakeUnserializedContext<
        internal::ManifestTabStrip_UnserializedMessageContext<
            UserType, ManifestTabStrip::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<ManifestTabStrip::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
  HomeTabUnionPtr home_tab;
  
  NewTabButtonParamsPtr new_tab_button;

  // Serialise this struct into a trace.
  void WriteIntoTrace(perfetto::TracedValue traced_context) const;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
};

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

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

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

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





class PLATFORM_EXPORT HomeTabParams {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<HomeTabParams, T>::value>;
  using DataView = HomeTabParamsDataView;
  using Data_ = internal::HomeTabParams_Data;

  template <typename... Args>
  static HomeTabParamsPtr New(Args&&... args) {
    return HomeTabParamsPtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static HomeTabParamsPtr From(const U& u) {
    return mojo::TypeConverter<HomeTabParamsPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, HomeTabParams>::Convert(*this);
  }


  HomeTabParams();

  HomeTabParams(
      ::blink::Vector<ManifestImageResourcePtr> icons,
      ::blink::Vector<::blink::SafeUrlPattern> scope_patterns);

HomeTabParams(const HomeTabParams&) = delete;
HomeTabParams& operator=(const HomeTabParams&) = delete;

  ~HomeTabParams();

  // Clone() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Clone() or copy
  // constructor/assignment are available for members.
  template <typename StructPtrType = HomeTabParamsPtr>
  HomeTabParamsPtr Clone() const;

  // Equals() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Equals() or == operator
  // are available for members.
  template <typename T, HomeTabParams::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, HomeTabParams::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, HomeTabParams::EnableIfSame<T>* = nullptr>
  bool operator!=(const T& rhs) const { return !operator==(rhs); }

  template <mojo::internal::SendValidation send_validation, typename UserType>
  static ::blink::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        HomeTabParams::DataView, ::blink::Vector<uint8_t>, send_validation>(input);
  }

  template <typename UserType>
  static ::blink::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        HomeTabParams::DataView, ::blink::Vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        HomeTabParams::DataView>(input);
  }

  // The returned Message is serialized only if the message is moved
  // cross-process or cross-language. Otherwise if the message is Deserialized
  // as the same UserType |input| will just be moved to |output| in
  // DeserializeFromMessage.
  template <typename UserType>
  static mojo::Message WrapAsMessage(UserType input) {
    return mojo::Message(std::make_unique<
        internal::HomeTabParams_UnserializedMessageContext<
            UserType, HomeTabParams::DataView>>(0, 0, std::move(input)),
        MOJO_CREATE_MESSAGE_FLAG_NONE);
  }

  template <typename UserType>
  static bool Deserialize(const void* data,
                          size_t data_num_bytes,
                          UserType* output) {
    mojo::Message message;
    return mojo::internal::DeserializeImpl<HomeTabParams::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(base::span<const uint8_t> input,
                          UserType* output) {
    return HomeTabParams::Deserialize(
        input.empty() ? nullptr : input.data(), input.size(), output);
  }

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    auto context = input.TakeUnserializedContext<
        internal::HomeTabParams_UnserializedMessageContext<
            UserType, HomeTabParams::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<HomeTabParams::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
  ::blink::Vector<ManifestImageResourcePtr> icons;
  
  ::blink::Vector<::blink::SafeUrlPattern> scope_patterns;

  // Serialise this struct into a trace.
  void WriteIntoTrace(perfetto::TracedValue traced_context) const;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
};

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

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

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

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





class PLATFORM_EXPORT NewTabButtonParams {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<NewTabButtonParams, T>::value>;
  using DataView = NewTabButtonParamsDataView;
  using Data_ = internal::NewTabButtonParams_Data;

  template <typename... Args>
  static NewTabButtonParamsPtr New(Args&&... args) {
    return NewTabButtonParamsPtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static NewTabButtonParamsPtr From(const U& u) {
    return mojo::TypeConverter<NewTabButtonParamsPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, NewTabButtonParams>::Convert(*this);
  }


  NewTabButtonParams();

  explicit NewTabButtonParams(
      const std::optional<::blink::KURL>& url);


  ~NewTabButtonParams();

  // Clone() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Clone() or copy
  // constructor/assignment are available for members.
  template <typename StructPtrType = NewTabButtonParamsPtr>
  NewTabButtonParamsPtr Clone() const;

  // Equals() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Equals() or == operator
  // are available for members.
  template <typename T, NewTabButtonParams::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, NewTabButtonParams::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, NewTabButtonParams::EnableIfSame<T>* = nullptr>
  bool operator!=(const T& rhs) const { return !operator==(rhs); }

  template <mojo::internal::SendValidation send_validation, typename UserType>
  static ::blink::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        NewTabButtonParams::DataView, ::blink::Vector<uint8_t>, send_validation>(input);
  }

  template <typename UserType>
  static ::blink::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        NewTabButtonParams::DataView, ::blink::Vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        NewTabButtonParams::DataView>(input);
  }

  // The returned Message is serialized only if the message is moved
  // cross-process or cross-language. Otherwise if the message is Deserialized
  // as the same UserType |input| will just be moved to |output| in
  // DeserializeFromMessage.
  template <typename UserType>
  static mojo::Message WrapAsMessage(UserType input) {
    return mojo::Message(std::make_unique<
        internal::NewTabButtonParams_UnserializedMessageContext<
            UserType, NewTabButtonParams::DataView>>(0, 0, std::move(input)),
        MOJO_CREATE_MESSAGE_FLAG_NONE);
  }

  template <typename UserType>
  static bool Deserialize(const void* data,
                          size_t data_num_bytes,
                          UserType* output) {
    mojo::Message message;
    return mojo::internal::DeserializeImpl<NewTabButtonParams::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(base::span<const uint8_t> input,
                          UserType* output) {
    return NewTabButtonParams::Deserialize(
        input.empty() ? nullptr : input.data(), input.size(), output);
  }

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    auto context = input.TakeUnserializedContext<
        internal::NewTabButtonParams_UnserializedMessageContext<
            UserType, NewTabButtonParams::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<NewTabButtonParams::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
  std::optional<::blink::KURL> url;

  // Serialise this struct into a trace.
  void WriteIntoTrace(perfetto::TracedValue traced_context) const;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
};

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

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

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

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





class PLATFORM_EXPORT ManifestDebugInfo {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<ManifestDebugInfo, T>::value>;
  using DataView = ManifestDebugInfoDataView;
  using Data_ = internal::ManifestDebugInfo_Data;

  template <typename... Args>
  static ManifestDebugInfoPtr New(Args&&... args) {
    return ManifestDebugInfoPtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static ManifestDebugInfoPtr From(const U& u) {
    return mojo::TypeConverter<ManifestDebugInfoPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, ManifestDebugInfo>::Convert(*this);
  }


  ManifestDebugInfo();

  ManifestDebugInfo(
      ::blink::Vector<ManifestErrorPtr> errors,
      const ::blink::String& raw_manifest);

ManifestDebugInfo(const ManifestDebugInfo&) = delete;
ManifestDebugInfo& operator=(const ManifestDebugInfo&) = delete;

  ~ManifestDebugInfo();

  // Clone() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Clone() or copy
  // constructor/assignment are available for members.
  template <typename StructPtrType = ManifestDebugInfoPtr>
  ManifestDebugInfoPtr Clone() const;

  // Equals() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Equals() or == operator
  // are available for members.
  template <typename T, ManifestDebugInfo::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, ManifestDebugInfo::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, ManifestDebugInfo::EnableIfSame<T>* = nullptr>
  bool operator!=(const T& rhs) const { return !operator==(rhs); }

  template <mojo::internal::SendValidation send_validation, typename UserType>
  static ::blink::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        ManifestDebugInfo::DataView, ::blink::Vector<uint8_t>, send_validation>(input);
  }

  template <typename UserType>
  static ::blink::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        ManifestDebugInfo::DataView, ::blink::Vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        ManifestDebugInfo::DataView>(input);
  }

  // The returned Message is serialized only if the message is moved
  // cross-process or cross-language. Otherwise if the message is Deserialized
  // as the same UserType |input| will just be moved to |output| in
  // DeserializeFromMessage.
  template <typename UserType>
  static mojo::Message WrapAsMessage(UserType input) {
    return mojo::Message(std::make_unique<
        internal::ManifestDebugInfo_UnserializedMessageContext<
            UserType, ManifestDebugInfo::DataView>>(0, 0, std::move(input)),
        MOJO_CREATE_MESSAGE_FLAG_NONE);
  }

  template <typename UserType>
  static bool Deserialize(const void* data,
                          size_t data_num_bytes,
                          UserType* output) {
    mojo::Message message;
    return mojo::internal::DeserializeImpl<ManifestDebugInfo::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(base::span<const uint8_t> input,
                          UserType* output) {
    return ManifestDebugInfo::Deserialize(
        input.empty() ? nullptr : input.data(), input.size(), output);
  }

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    auto context = input.TakeUnserializedContext<
        internal::ManifestDebugInfo_UnserializedMessageContext<
            UserType, ManifestDebugInfo::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<ManifestDebugInfo::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
  ::blink::Vector<ManifestErrorPtr> errors;
  
  ::blink::String raw_manifest;

  // Serialise this struct into a trace.
  void WriteIntoTrace(perfetto::TracedValue traced_context) const;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
};

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

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

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

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






class PLATFORM_EXPORT DisplayOverrideItem {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<DisplayOverrideItem, T>::value>;
  using DataView = DisplayOverrideItemDataView;
  using Data_ = internal::DisplayOverrideItem_Data;

  template <typename... Args>
  static DisplayOverrideItemPtr New(Args&&... args) {
    return DisplayOverrideItemPtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static DisplayOverrideItemPtr From(const U& u) {
    return mojo::TypeConverter<DisplayOverrideItemPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, DisplayOverrideItem>::Convert(*this);
  }


  DisplayOverrideItem();

  DisplayOverrideItem(
      ::blink::mojom::blink::DisplayMode display,
      ::blink::Vector<::blink::SafeUrlPattern> url_patterns);


  ~DisplayOverrideItem();

  // Clone() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Clone() or copy
  // constructor/assignment are available for members.
  template <typename StructPtrType = DisplayOverrideItemPtr>
  DisplayOverrideItemPtr Clone() const;

  // Equals() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Equals() or == operator
  // are available for members.
  template <typename T, DisplayOverrideItem::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, DisplayOverrideItem::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, DisplayOverrideItem::EnableIfSame<T>* = nullptr>
  bool operator!=(const T& rhs) const { return !operator==(rhs); }

  template <mojo::internal::SendValidation send_validation, typename UserType>
  static ::blink::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        DisplayOverrideItem::DataView, ::blink::Vector<uint8_t>, send_validation>(input);
  }

  template <typename UserType>
  static ::blink::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        DisplayOverrideItem::DataView, ::blink::Vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        DisplayOverrideItem::DataView>(input);
  }

  // The returned Message is serialized only if the message is moved
  // cross-process or cross-language. Otherwise if the message is Deserialized
  // as the same UserType |input| will just be moved to |output| in
  // DeserializeFromMessage.
  template <typename UserType>
  static mojo::Message WrapAsMessage(UserType input) {
    return mojo::Message(std::make_unique<
        internal::DisplayOverrideItem_UnserializedMessageContext<
            UserType, DisplayOverrideItem::DataView>>(0, 0, std::move(input)),
        MOJO_CREATE_MESSAGE_FLAG_NONE);
  }

  template <typename UserType>
  static bool Deserialize(const void* data,
                          size_t data_num_bytes,
                          UserType* output) {
    mojo::Message message;
    return mojo::internal::DeserializeImpl<DisplayOverrideItem::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(base::span<const uint8_t> input,
                          UserType* output) {
    return DisplayOverrideItem::Deserialize(
        input.empty() ? nullptr : input.data(), input.size(), output);
  }

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    auto context = input.TakeUnserializedContext<
        internal::DisplayOverrideItem_UnserializedMessageContext<
            UserType, DisplayOverrideItem::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<DisplayOverrideItem::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
  ::blink::mojom::blink::DisplayMode display;
  
  ::blink::Vector<::blink::SafeUrlPattern> url_patterns;

  // Serialise this struct into a trace.
  void WriteIntoTrace(perfetto::TracedValue traced_context) const;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
};

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

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

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

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

template <typename UnionPtrType>
HomeTabUnionPtr HomeTabUnion::Clone() const {
  switch (tag_) {
    case Tag::kVisibility:
      return NewVisibility(
          mojo::Clone(data_.visibility));
    case Tag::kParams:
      return NewParams(
          mojo::Clone(data_.params));
  }
  return nullptr;
}

template <typename T,
          typename std::enable_if<std::is_same<
              T, HomeTabUnion>::value>::type*>
bool HomeTabUnion::Equals(const T& other) const {
  if (tag_ != other.which())
    return false;

  switch (tag_) {
    case Tag::kVisibility:
      return mojo::Equals(data_.visibility, other.data_.visibility);
    case Tag::kParams:
      return mojo::Equals(data_.params, other.data_.params);
  }

  return false;
}
template <typename StructPtrType>
ManifestPtr Manifest::Clone() const {
  return New(
      mojo::Clone(manifest_url),
      mojo::Clone(dir),
      mojo::Clone(name),
      mojo::Clone(short_name),
      mojo::Clone(description),
      mojo::Clone(id),
      mojo::Clone(has_custom_id),
      mojo::Clone(start_url),
      mojo::Clone(has_valid_specified_start_url),
      mojo::Clone(display),
      mojo::Clone(display_override),
      mojo::Clone(orientation),
      mojo::Clone(icons),
      mojo::Clone(screenshots),
      mojo::Clone(shortcuts),
      mojo::Clone(share_target),
      mojo::Clone(file_handlers),
      mojo::Clone(protocol_handlers),
      mojo::Clone(scope_extensions),
      mojo::Clone(lock_screen),
      mojo::Clone(note_taking),
      mojo::Clone(related_applications),
      mojo::Clone(prefer_related_applications),
      mojo::Clone(migrate_from),
      mojo::Clone(migrate_to),
      mojo::Clone(theme_color),
      mojo::Clone(background_color),
      mojo::Clone(gcm_sender_id),
      mojo::Clone(scope),
      mojo::Clone(update_manifest_url),
      mojo::Clone(launch_handler),
      mojo::Clone(translations),
      mojo::Clone(dark_theme_color),
      mojo::Clone(dark_background_color),
      mojo::Clone(tab_strip),
      mojo::Clone(version),
      mojo::Clone(name_localized),
      mojo::Clone(short_name_localized),
      mojo::Clone(description_localized),
      mojo::Clone(icons_localized)
  );
}

template <typename T, Manifest::EnableIfSame<T>*>
bool Manifest::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->manifest_url, other_struct.manifest_url))
    return false;
  if (!mojo::Equals(this->dir, other_struct.dir))
    return false;
  if (!mojo::Equals(this->name, other_struct.name))
    return false;
  if (!mojo::Equals(this->short_name, other_struct.short_name))
    return false;
  if (!mojo::Equals(this->description, other_struct.description))
    return false;
  if (!mojo::Equals(this->id, other_struct.id))
    return false;
  if (!mojo::Equals(this->has_custom_id, other_struct.has_custom_id))
    return false;
  if (!mojo::Equals(this->start_url, other_struct.start_url))
    return false;
  if (!mojo::Equals(this->has_valid_specified_start_url, other_struct.has_valid_specified_start_url))
    return false;
  if (!mojo::Equals(this->display, other_struct.display))
    return false;
  if (!mojo::Equals(this->display_override, other_struct.display_override))
    return false;
  if (!mojo::Equals(this->orientation, other_struct.orientation))
    return false;
  if (!mojo::Equals(this->icons, other_struct.icons))
    return false;
  if (!mojo::Equals(this->screenshots, other_struct.screenshots))
    return false;
  if (!mojo::Equals(this->shortcuts, other_struct.shortcuts))
    return false;
  if (!mojo::Equals(this->share_target, other_struct.share_target))
    return false;
  if (!mojo::Equals(this->file_handlers, other_struct.file_handlers))
    return false;
  if (!mojo::Equals(this->protocol_handlers, other_struct.protocol_handlers))
    return false;
  if (!mojo::Equals(this->scope_extensions, other_struct.scope_extensions))
    return false;
  if (!mojo::Equals(this->lock_screen, other_struct.lock_screen))
    return false;
  if (!mojo::Equals(this->note_taking, other_struct.note_taking))
    return false;
  if (!mojo::Equals(this->related_applications, other_struct.related_applications))
    return false;
  if (!mojo::Equals(this->prefer_related_applications, other_struct.prefer_related_applications))
    return false;
  if (!mojo::Equals(this->migrate_from, other_struct.migrate_from))
    return false;
  if (!mojo::Equals(this->migrate_to, other_struct.migrate_to))
    return false;
  if (!mojo::Equals(this->theme_color, other_struct.theme_color))
    return false;
  if (!mojo::Equals(this->background_color, other_struct.background_color))
    return false;
  if (!mojo::Equals(this->gcm_sender_id, other_struct.gcm_sender_id))
    return false;
  if (!mojo::Equals(this->scope, other_struct.scope))
    return false;
  if (!mojo::Equals(this->update_manifest_url, other_struct.update_manifest_url))
    return false;
  if (!mojo::Equals(this->launch_handler, other_struct.launch_handler))
    return false;
  if (!mojo::Equals(this->translations, other_struct.translations))
    return false;
  if (!mojo::Equals(this->dark_theme_color, other_struct.dark_theme_color))
    return false;
  if (!mojo::Equals(this->dark_background_color, other_struct.dark_background_color))
    return false;
  if (!mojo::Equals(this->tab_strip, other_struct.tab_strip))
    return false;
  if (!mojo::Equals(this->version, other_struct.version))
    return false;
  if (!mojo::Equals(this->name_localized, other_struct.name_localized))
    return false;
  if (!mojo::Equals(this->short_name_localized, other_struct.short_name_localized))
    return false;
  if (!mojo::Equals(this->description_localized, other_struct.description_localized))
    return false;
  if (!mojo::Equals(this->icons_localized, other_struct.icons_localized))
    return false;
  return true;
}

template <typename T, Manifest::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.manifest_url < rhs.manifest_url)
    return true;
  if (rhs.manifest_url < lhs.manifest_url)
    return false;
  if (lhs.dir < rhs.dir)
    return true;
  if (rhs.dir < lhs.dir)
    return false;
  if (lhs.name < rhs.name)
    return true;
  if (rhs.name < lhs.name)
    return false;
  if (lhs.short_name < rhs.short_name)
    return true;
  if (rhs.short_name < lhs.short_name)
    return false;
  if (lhs.description < rhs.description)
    return true;
  if (rhs.description < lhs.description)
    return false;
  if (lhs.id < rhs.id)
    return true;
  if (rhs.id < lhs.id)
    return false;
  if (lhs.has_custom_id < rhs.has_custom_id)
    return true;
  if (rhs.has_custom_id < lhs.has_custom_id)
    return false;
  if (lhs.start_url < rhs.start_url)
    return true;
  if (rhs.start_url < lhs.start_url)
    return false;
  if (lhs.has_valid_specified_start_url < rhs.has_valid_specified_start_url)
    return true;
  if (rhs.has_valid_specified_start_url < lhs.has_valid_specified_start_url)
    return false;
  if (lhs.display < rhs.display)
    return true;
  if (rhs.display < lhs.display)
    return false;
  if (lhs.display_override < rhs.display_override)
    return true;
  if (rhs.display_override < lhs.display_override)
    return false;
  if (lhs.orientation < rhs.orientation)
    return true;
  if (rhs.orientation < lhs.orientation)
    return false;
  if (lhs.icons < rhs.icons)
    return true;
  if (rhs.icons < lhs.icons)
    return false;
  if (lhs.screenshots < rhs.screenshots)
    return true;
  if (rhs.screenshots < lhs.screenshots)
    return false;
  if (lhs.shortcuts < rhs.shortcuts)
    return true;
  if (rhs.shortcuts < lhs.shortcuts)
    return false;
  if (lhs.share_target < rhs.share_target)
    return true;
  if (rhs.share_target < lhs.share_target)
    return false;
  if (lhs.file_handlers < rhs.file_handlers)
    return true;
  if (rhs.file_handlers < lhs.file_handlers)
    return false;
  if (lhs.protocol_handlers < rhs.protocol_handlers)
    return true;
  if (rhs.protocol_handlers < lhs.protocol_handlers)
    return false;
  if (lhs.scope_extensions < rhs.scope_extensions)
    return true;
  if (rhs.scope_extensions < lhs.scope_extensions)
    return false;
  if (lhs.lock_screen < rhs.lock_screen)
    return true;
  if (rhs.lock_screen < lhs.lock_screen)
    return false;
  if (lhs.note_taking < rhs.note_taking)
    return true;
  if (rhs.note_taking < lhs.note_taking)
    return false;
  if (lhs.related_applications < rhs.related_applications)
    return true;
  if (rhs.related_applications < lhs.related_applications)
    return false;
  if (lhs.prefer_related_applications < rhs.prefer_related_applications)
    return true;
  if (rhs.prefer_related_applications < lhs.prefer_related_applications)
    return false;
  if (lhs.migrate_from < rhs.migrate_from)
    return true;
  if (rhs.migrate_from < lhs.migrate_from)
    return false;
  if (lhs.migrate_to < rhs.migrate_to)
    return true;
  if (rhs.migrate_to < lhs.migrate_to)
    return false;
  if (lhs.theme_color < rhs.theme_color)
    return true;
  if (rhs.theme_color < lhs.theme_color)
    return false;
  if (lhs.background_color < rhs.background_color)
    return true;
  if (rhs.background_color < lhs.background_color)
    return false;
  if (lhs.gcm_sender_id < rhs.gcm_sender_id)
    return true;
  if (rhs.gcm_sender_id < lhs.gcm_sender_id)
    return false;
  if (lhs.scope < rhs.scope)
    return true;
  if (rhs.scope < lhs.scope)
    return false;
  if (lhs.update_manifest_url < rhs.update_manifest_url)
    return true;
  if (rhs.update_manifest_url < lhs.update_manifest_url)
    return false;
  if (lhs.launch_handler < rhs.launch_handler)
    return true;
  if (rhs.launch_handler < lhs.launch_handler)
    return false;
  if (lhs.translations < rhs.translations)
    return true;
  if (rhs.translations < lhs.translations)
    return false;
  if (lhs.dark_theme_color < rhs.dark_theme_color)
    return true;
  if (rhs.dark_theme_color < lhs.dark_theme_color)
    return false;
  if (lhs.dark_background_color < rhs.dark_background_color)
    return true;
  if (rhs.dark_background_color < lhs.dark_background_color)
    return false;
  if (lhs.tab_strip < rhs.tab_strip)
    return true;
  if (rhs.tab_strip < lhs.tab_strip)
    return false;
  if (lhs.version < rhs.version)
    return true;
  if (rhs.version < lhs.version)
    return false;
  if (lhs.name_localized < rhs.name_localized)
    return true;
  if (rhs.name_localized < lhs.name_localized)
    return false;
  if (lhs.short_name_localized < rhs.short_name_localized)
    return true;
  if (rhs.short_name_localized < lhs.short_name_localized)
    return false;
  if (lhs.description_localized < rhs.description_localized)
    return true;
  if (rhs.description_localized < lhs.description_localized)
    return false;
  if (lhs.icons_localized < rhs.icons_localized)
    return true;
  if (rhs.icons_localized < lhs.icons_localized)
    return false;
  return false;
}
template <typename StructPtrType>
ManifestLocalizedTextObjectPtr ManifestLocalizedTextObject::Clone() const {
  return New(
      mojo::Clone(value),
      mojo::Clone(dir),
      mojo::Clone(lang)
  );
}

template <typename T, ManifestLocalizedTextObject::EnableIfSame<T>*>
bool ManifestLocalizedTextObject::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->value, other_struct.value))
    return false;
  if (!mojo::Equals(this->dir, other_struct.dir))
    return false;
  if (!mojo::Equals(this->lang, other_struct.lang))
    return false;
  return true;
}

template <typename T, ManifestLocalizedTextObject::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.value < rhs.value)
    return true;
  if (rhs.value < lhs.value)
    return false;
  if (lhs.dir < rhs.dir)
    return true;
  if (rhs.dir < lhs.dir)
    return false;
  if (lhs.lang < rhs.lang)
    return true;
  if (rhs.lang < lhs.lang)
    return false;
  return false;
}
template <typename StructPtrType>
LocalePtr Locale::Clone() const {
  return New(
      mojo::Clone(tag)
  );
}

template <typename T, Locale::EnableIfSame<T>*>
bool Locale::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->tag, other_struct.tag))
    return false;
  return true;
}

template <typename T, Locale::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.tag < rhs.tag)
    return true;
  if (rhs.tag < lhs.tag)
    return false;
  return false;
}
template <typename StructPtrType>
ManifestShortcutItemPtr ManifestShortcutItem::Clone() const {
  return New(
      mojo::Clone(name),
      mojo::Clone(short_name),
      mojo::Clone(description),
      mojo::Clone(url),
      mojo::Clone(icons),
      mojo::Clone(name_localized),
      mojo::Clone(short_name_localized),
      mojo::Clone(description_localized),
      mojo::Clone(icons_localized)
  );
}

template <typename T, ManifestShortcutItem::EnableIfSame<T>*>
bool ManifestShortcutItem::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->name, other_struct.name))
    return false;
  if (!mojo::Equals(this->short_name, other_struct.short_name))
    return false;
  if (!mojo::Equals(this->description, other_struct.description))
    return false;
  if (!mojo::Equals(this->url, other_struct.url))
    return false;
  if (!mojo::Equals(this->icons, other_struct.icons))
    return false;
  if (!mojo::Equals(this->name_localized, other_struct.name_localized))
    return false;
  if (!mojo::Equals(this->short_name_localized, other_struct.short_name_localized))
    return false;
  if (!mojo::Equals(this->description_localized, other_struct.description_localized))
    return false;
  if (!mojo::Equals(this->icons_localized, other_struct.icons_localized))
    return false;
  return true;
}

template <typename T, ManifestShortcutItem::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.name < rhs.name)
    return true;
  if (rhs.name < lhs.name)
    return false;
  if (lhs.short_name < rhs.short_name)
    return true;
  if (rhs.short_name < lhs.short_name)
    return false;
  if (lhs.description < rhs.description)
    return true;
  if (rhs.description < lhs.description)
    return false;
  if (lhs.url < rhs.url)
    return true;
  if (rhs.url < lhs.url)
    return false;
  if (lhs.icons < rhs.icons)
    return true;
  if (rhs.icons < lhs.icons)
    return false;
  if (lhs.name_localized < rhs.name_localized)
    return true;
  if (rhs.name_localized < lhs.name_localized)
    return false;
  if (lhs.short_name_localized < rhs.short_name_localized)
    return true;
  if (rhs.short_name_localized < lhs.short_name_localized)
    return false;
  if (lhs.description_localized < rhs.description_localized)
    return true;
  if (rhs.description_localized < lhs.description_localized)
    return false;
  if (lhs.icons_localized < rhs.icons_localized)
    return true;
  if (rhs.icons_localized < lhs.icons_localized)
    return false;
  return false;
}
template <typename StructPtrType>
ManifestImageResourcePtr ManifestImageResource::Clone() const {
  return New(
      mojo::Clone(src),
      mojo::Clone(type),
      mojo::Clone(sizes),
      mojo::Clone(purpose)
  );
}

template <typename T, ManifestImageResource::EnableIfSame<T>*>
bool ManifestImageResource::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->src, other_struct.src))
    return false;
  if (!mojo::Equals(this->type, other_struct.type))
    return false;
  if (!mojo::Equals(this->sizes, other_struct.sizes))
    return false;
  if (!mojo::Equals(this->purpose, other_struct.purpose))
    return false;
  return true;
}

template <typename T, ManifestImageResource::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.src < rhs.src)
    return true;
  if (rhs.src < lhs.src)
    return false;
  if (lhs.type < rhs.type)
    return true;
  if (rhs.type < lhs.type)
    return false;
  if (lhs.sizes < rhs.sizes)
    return true;
  if (rhs.sizes < lhs.sizes)
    return false;
  if (lhs.purpose < rhs.purpose)
    return true;
  if (rhs.purpose < lhs.purpose)
    return false;
  return false;
}
template <typename StructPtrType>
ManifestScreenshotPtr ManifestScreenshot::Clone() const {
  return New(
      mojo::Clone(image),
      mojo::Clone(form_factor),
      mojo::Clone(label)
  );
}

template <typename T, ManifestScreenshot::EnableIfSame<T>*>
bool ManifestScreenshot::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->image, other_struct.image))
    return false;
  if (!mojo::Equals(this->form_factor, other_struct.form_factor))
    return false;
  if (!mojo::Equals(this->label, other_struct.label))
    return false;
  return true;
}

template <typename T, ManifestScreenshot::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.image < rhs.image)
    return true;
  if (rhs.image < lhs.image)
    return false;
  if (lhs.form_factor < rhs.form_factor)
    return true;
  if (rhs.form_factor < lhs.form_factor)
    return false;
  if (lhs.label < rhs.label)
    return true;
  if (rhs.label < lhs.label)
    return false;
  return false;
}
template <typename StructPtrType>
ManifestFileFilterPtr ManifestFileFilter::Clone() const {
  return New(
      mojo::Clone(name),
      mojo::Clone(accept)
  );
}

template <typename T, ManifestFileFilter::EnableIfSame<T>*>
bool ManifestFileFilter::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->name, other_struct.name))
    return false;
  if (!mojo::Equals(this->accept, other_struct.accept))
    return false;
  return true;
}

template <typename T, ManifestFileFilter::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.name < rhs.name)
    return true;
  if (rhs.name < lhs.name)
    return false;
  if (lhs.accept < rhs.accept)
    return true;
  if (rhs.accept < lhs.accept)
    return false;
  return false;
}
template <typename StructPtrType>
ManifestProtocolHandlerPtr ManifestProtocolHandler::Clone() const {
  return New(
      mojo::Clone(protocol),
      mojo::Clone(url)
  );
}

template <typename T, ManifestProtocolHandler::EnableIfSame<T>*>
bool ManifestProtocolHandler::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->protocol, other_struct.protocol))
    return false;
  if (!mojo::Equals(this->url, other_struct.url))
    return false;
  return true;
}

template <typename T, ManifestProtocolHandler::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.protocol < rhs.protocol)
    return true;
  if (rhs.protocol < lhs.protocol)
    return false;
  if (lhs.url < rhs.url)
    return true;
  if (rhs.url < lhs.url)
    return false;
  return false;
}
template <typename StructPtrType>
ManifestScopeExtensionPtr ManifestScopeExtension::Clone() const {
  return New(
      mojo::Clone(origin),
      mojo::Clone(has_origin_wildcard)
  );
}

template <typename T, ManifestScopeExtension::EnableIfSame<T>*>
bool ManifestScopeExtension::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->origin, other_struct.origin))
    return false;
  if (!mojo::Equals(this->has_origin_wildcard, other_struct.has_origin_wildcard))
    return false;
  return true;
}

template <typename T, ManifestScopeExtension::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.origin < rhs.origin)
    return true;
  if (rhs.origin < lhs.origin)
    return false;
  if (lhs.has_origin_wildcard < rhs.has_origin_wildcard)
    return true;
  if (rhs.has_origin_wildcard < lhs.has_origin_wildcard)
    return false;
  return false;
}
template <typename StructPtrType>
ManifestLockScreenPtr ManifestLockScreen::Clone() const {
  return New(
      mojo::Clone(start_url)
  );
}

template <typename T, ManifestLockScreen::EnableIfSame<T>*>
bool ManifestLockScreen::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->start_url, other_struct.start_url))
    return false;
  return true;
}

template <typename T, ManifestLockScreen::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.start_url < rhs.start_url)
    return true;
  if (rhs.start_url < lhs.start_url)
    return false;
  return false;
}
template <typename StructPtrType>
ManifestNoteTakingPtr ManifestNoteTaking::Clone() const {
  return New(
      mojo::Clone(new_note_url)
  );
}

template <typename T, ManifestNoteTaking::EnableIfSame<T>*>
bool ManifestNoteTaking::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->new_note_url, other_struct.new_note_url))
    return false;
  return true;
}

template <typename T, ManifestNoteTaking::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.new_note_url < rhs.new_note_url)
    return true;
  if (rhs.new_note_url < lhs.new_note_url)
    return false;
  return false;
}
template <typename StructPtrType>
ManifestRelatedApplicationPtr ManifestRelatedApplication::Clone() const {
  return New(
      mojo::Clone(platform),
      mojo::Clone(url),
      mojo::Clone(id)
  );
}

template <typename T, ManifestRelatedApplication::EnableIfSame<T>*>
bool ManifestRelatedApplication::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->platform, other_struct.platform))
    return false;
  if (!mojo::Equals(this->url, other_struct.url))
    return false;
  if (!mojo::Equals(this->id, other_struct.id))
    return false;
  return true;
}

template <typename T, ManifestRelatedApplication::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.platform < rhs.platform)
    return true;
  if (rhs.platform < lhs.platform)
    return false;
  if (lhs.url < rhs.url)
    return true;
  if (rhs.url < lhs.url)
    return false;
  if (lhs.id < rhs.id)
    return true;
  if (rhs.id < lhs.id)
    return false;
  return false;
}
template <typename StructPtrType>
ManifestShareTargetParamsPtr ManifestShareTargetParams::Clone() const {
  return New(
      mojo::Clone(title),
      mojo::Clone(text),
      mojo::Clone(url),
      mojo::Clone(files)
  );
}

template <typename T, ManifestShareTargetParams::EnableIfSame<T>*>
bool ManifestShareTargetParams::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->title, other_struct.title))
    return false;
  if (!mojo::Equals(this->text, other_struct.text))
    return false;
  if (!mojo::Equals(this->url, other_struct.url))
    return false;
  if (!mojo::Equals(this->files, other_struct.files))
    return false;
  return true;
}

template <typename T, ManifestShareTargetParams::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.title < rhs.title)
    return true;
  if (rhs.title < lhs.title)
    return false;
  if (lhs.text < rhs.text)
    return true;
  if (rhs.text < lhs.text)
    return false;
  if (lhs.url < rhs.url)
    return true;
  if (rhs.url < lhs.url)
    return false;
  if (lhs.files < rhs.files)
    return true;
  if (rhs.files < lhs.files)
    return false;
  return false;
}
template <typename StructPtrType>
ManifestShareTargetPtr ManifestShareTarget::Clone() const {
  return New(
      mojo::Clone(action),
      mojo::Clone(method),
      mojo::Clone(enctype),
      mojo::Clone(params)
  );
}

template <typename T, ManifestShareTarget::EnableIfSame<T>*>
bool ManifestShareTarget::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->action, other_struct.action))
    return false;
  if (!mojo::Equals(this->method, other_struct.method))
    return false;
  if (!mojo::Equals(this->enctype, other_struct.enctype))
    return false;
  if (!mojo::Equals(this->params, other_struct.params))
    return false;
  return true;
}

template <typename T, ManifestShareTarget::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.action < rhs.action)
    return true;
  if (rhs.action < lhs.action)
    return false;
  if (lhs.method < rhs.method)
    return true;
  if (rhs.method < lhs.method)
    return false;
  if (lhs.enctype < rhs.enctype)
    return true;
  if (rhs.enctype < lhs.enctype)
    return false;
  if (lhs.params < rhs.params)
    return true;
  if (rhs.params < lhs.params)
    return false;
  return false;
}
template <typename StructPtrType>
ManifestFileHandlerPtr ManifestFileHandler::Clone() const {
  return New(
      mojo::Clone(action),
      mojo::Clone(name),
      mojo::Clone(accept),
      mojo::Clone(launch_type)
  );
}

template <typename T, ManifestFileHandler::EnableIfSame<T>*>
bool ManifestFileHandler::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->action, other_struct.action))
    return false;
  if (!mojo::Equals(this->name, other_struct.name))
    return false;
  if (!mojo::Equals(this->accept, other_struct.accept))
    return false;
  if (!mojo::Equals(this->launch_type, other_struct.launch_type))
    return false;
  return true;
}

template <typename T, ManifestFileHandler::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.action < rhs.action)
    return true;
  if (rhs.action < lhs.action)
    return false;
  if (lhs.name < rhs.name)
    return true;
  if (rhs.name < lhs.name)
    return false;
  if (lhs.accept < rhs.accept)
    return true;
  if (rhs.accept < lhs.accept)
    return false;
  if (lhs.launch_type < rhs.launch_type)
    return true;
  if (rhs.launch_type < lhs.launch_type)
    return false;
  return false;
}
template <typename StructPtrType>
ManifestTranslationItemPtr ManifestTranslationItem::Clone() const {
  return New(
      mojo::Clone(name),
      mojo::Clone(short_name),
      mojo::Clone(description)
  );
}

template <typename T, ManifestTranslationItem::EnableIfSame<T>*>
bool ManifestTranslationItem::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->name, other_struct.name))
    return false;
  if (!mojo::Equals(this->short_name, other_struct.short_name))
    return false;
  if (!mojo::Equals(this->description, other_struct.description))
    return false;
  return true;
}

template <typename T, ManifestTranslationItem::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.name < rhs.name)
    return true;
  if (rhs.name < lhs.name)
    return false;
  if (lhs.short_name < rhs.short_name)
    return true;
  if (rhs.short_name < lhs.short_name)
    return false;
  if (lhs.description < rhs.description)
    return true;
  if (rhs.description < lhs.description)
    return false;
  return false;
}
template <typename StructPtrType>
ManifestMigrateFromPtr ManifestMigrateFrom::Clone() const {
  return New(
      mojo::Clone(id),
      mojo::Clone(install_url),
      mojo::Clone(behavior)
  );
}

template <typename T, ManifestMigrateFrom::EnableIfSame<T>*>
bool ManifestMigrateFrom::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->id, other_struct.id))
    return false;
  if (!mojo::Equals(this->install_url, other_struct.install_url))
    return false;
  if (!mojo::Equals(this->behavior, other_struct.behavior))
    return false;
  return true;
}

template <typename T, ManifestMigrateFrom::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.id < rhs.id)
    return true;
  if (rhs.id < lhs.id)
    return false;
  if (lhs.install_url < rhs.install_url)
    return true;
  if (rhs.install_url < lhs.install_url)
    return false;
  if (lhs.behavior < rhs.behavior)
    return true;
  if (rhs.behavior < lhs.behavior)
    return false;
  return false;
}
template <typename StructPtrType>
ManifestMigrateToPtr ManifestMigrateTo::Clone() const {
  return New(
      mojo::Clone(id),
      mojo::Clone(install_url)
  );
}

template <typename T, ManifestMigrateTo::EnableIfSame<T>*>
bool ManifestMigrateTo::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->id, other_struct.id))
    return false;
  if (!mojo::Equals(this->install_url, other_struct.install_url))
    return false;
  return true;
}

template <typename T, ManifestMigrateTo::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.id < rhs.id)
    return true;
  if (rhs.id < lhs.id)
    return false;
  if (lhs.install_url < rhs.install_url)
    return true;
  if (rhs.install_url < lhs.install_url)
    return false;
  return false;
}
template <typename StructPtrType>
ManifestTabStripPtr ManifestTabStrip::Clone() const {
  return New(
      mojo::Clone(home_tab),
      mojo::Clone(new_tab_button)
  );
}

template <typename T, ManifestTabStrip::EnableIfSame<T>*>
bool ManifestTabStrip::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->home_tab, other_struct.home_tab))
    return false;
  if (!mojo::Equals(this->new_tab_button, other_struct.new_tab_button))
    return false;
  return true;
}

template <typename T, ManifestTabStrip::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.home_tab < rhs.home_tab)
    return true;
  if (rhs.home_tab < lhs.home_tab)
    return false;
  if (lhs.new_tab_button < rhs.new_tab_button)
    return true;
  if (rhs.new_tab_button < lhs.new_tab_button)
    return false;
  return false;
}
template <typename StructPtrType>
HomeTabParamsPtr HomeTabParams::Clone() const {
  return New(
      mojo::Clone(icons),
      mojo::Clone(scope_patterns)
  );
}

template <typename T, HomeTabParams::EnableIfSame<T>*>
bool HomeTabParams::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->icons, other_struct.icons))
    return false;
  if (!mojo::Equals(this->scope_patterns, other_struct.scope_patterns))
    return false;
  return true;
}

template <typename T, HomeTabParams::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.icons < rhs.icons)
    return true;
  if (rhs.icons < lhs.icons)
    return false;
  if (lhs.scope_patterns < rhs.scope_patterns)
    return true;
  if (rhs.scope_patterns < lhs.scope_patterns)
    return false;
  return false;
}
template <typename StructPtrType>
NewTabButtonParamsPtr NewTabButtonParams::Clone() const {
  return New(
      mojo::Clone(url)
  );
}

template <typename T, NewTabButtonParams::EnableIfSame<T>*>
bool NewTabButtonParams::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->url, other_struct.url))
    return false;
  return true;
}

template <typename T, NewTabButtonParams::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.url < rhs.url)
    return true;
  if (rhs.url < lhs.url)
    return false;
  return false;
}
template <typename StructPtrType>
ManifestDebugInfoPtr ManifestDebugInfo::Clone() const {
  return New(
      mojo::Clone(errors),
      mojo::Clone(raw_manifest)
  );
}

template <typename T, ManifestDebugInfo::EnableIfSame<T>*>
bool ManifestDebugInfo::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->errors, other_struct.errors))
    return false;
  if (!mojo::Equals(this->raw_manifest, other_struct.raw_manifest))
    return false;
  return true;
}

template <typename T, ManifestDebugInfo::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.errors < rhs.errors)
    return true;
  if (rhs.errors < lhs.errors)
    return false;
  if (lhs.raw_manifest < rhs.raw_manifest)
    return true;
  if (rhs.raw_manifest < lhs.raw_manifest)
    return false;
  return false;
}
template <typename StructPtrType>
ManifestErrorPtr ManifestError::Clone() const {
  return New(
      mojo::Clone(message),
      mojo::Clone(critical),
      mojo::Clone(line),
      mojo::Clone(column)
  );
}

template <typename T, ManifestError::EnableIfSame<T>*>
bool ManifestError::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->message, other_struct.message))
    return false;
  if (!mojo::Equals(this->critical, other_struct.critical))
    return false;
  if (!mojo::Equals(this->line, other_struct.line))
    return false;
  if (!mojo::Equals(this->column, other_struct.column))
    return false;
  return true;
}

template <typename T, ManifestError::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.message < rhs.message)
    return true;
  if (rhs.message < lhs.message)
    return false;
  if (lhs.critical < rhs.critical)
    return true;
  if (rhs.critical < lhs.critical)
    return false;
  if (lhs.line < rhs.line)
    return true;
  if (rhs.line < lhs.line)
    return false;
  if (lhs.column < rhs.column)
    return true;
  if (rhs.column < lhs.column)
    return false;
  return false;
}
template <typename StructPtrType>
DisplayOverrideItemPtr DisplayOverrideItem::Clone() const {
  return New(
      mojo::Clone(display),
      mojo::Clone(url_patterns)
  );
}

template <typename T, DisplayOverrideItem::EnableIfSame<T>*>
bool DisplayOverrideItem::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->display, other_struct.display))
    return false;
  if (!mojo::Equals(this->url_patterns, other_struct.url_patterns))
    return false;
  return true;
}

template <typename T, DisplayOverrideItem::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.display < rhs.display)
    return true;
  if (rhs.display < lhs.display)
    return false;
  if (lhs.url_patterns < rhs.url_patterns)
    return true;
  if (rhs.url_patterns < lhs.url_patterns)
    return false;
  return false;
}


}  // blink::mojom::blink

namespace mojo {


template <>
struct PLATFORM_EXPORT StructTraits<::blink::mojom::blink::Manifest::DataView,
                                         ::blink::mojom::blink::ManifestPtr> {
  static bool IsNull(const ::blink::mojom::blink::ManifestPtr& input) { return !input; }
  static void SetToNull(::blink::mojom::blink::ManifestPtr* output) { output->reset(); }

  static const decltype(::blink::mojom::blink::Manifest::manifest_url)& manifest_url(
      const ::blink::mojom::blink::ManifestPtr& input) {
    return input->manifest_url;
  }

  static decltype(::blink::mojom::blink::Manifest::dir) dir(
      const ::blink::mojom::blink::ManifestPtr& input) {
    return input->dir;
  }

  static const decltype(::blink::mojom::blink::Manifest::name)& name(
      const ::blink::mojom::blink::ManifestPtr& input) {
    return input->name;
  }

  static const decltype(::blink::mojom::blink::Manifest::short_name)& short_name(
      const ::blink::mojom::blink::ManifestPtr& input) {
    return input->short_name;
  }

  static const decltype(::blink::mojom::blink::Manifest::description)& description(
      const ::blink::mojom::blink::ManifestPtr& input) {
    return input->description;
  }

  static const decltype(::blink::mojom::blink::Manifest::id)& id(
      const ::blink::mojom::blink::ManifestPtr& input) {
    return input->id;
  }

  static decltype(::blink::mojom::blink::Manifest::has_custom_id) has_custom_id(
      const ::blink::mojom::blink::ManifestPtr& input) {
    return input->has_custom_id;
  }

  static const decltype(::blink::mojom::blink::Manifest::start_url)& start_url(
      const ::blink::mojom::blink::ManifestPtr& input) {
    return input->start_url;
  }

  static decltype(::blink::mojom::blink::Manifest::has_valid_specified_start_url) has_valid_specified_start_url(
      const ::blink::mojom::blink::ManifestPtr& input) {
    return input->has_valid_specified_start_url;
  }

  static decltype(::blink::mojom::blink::Manifest::display) display(
      const ::blink::mojom::blink::ManifestPtr& input) {
    return input->display;
  }

  static const decltype(::blink::mojom::blink::Manifest::display_override)& display_override(
      const ::blink::mojom::blink::ManifestPtr& input) {
    return input->display_override;
  }

  static decltype(::blink::mojom::blink::Manifest::orientation) orientation(
      const ::blink::mojom::blink::ManifestPtr& input) {
    return input->orientation;
  }

  static const decltype(::blink::mojom::blink::Manifest::icons)& icons(
      const ::blink::mojom::blink::ManifestPtr& input) {
    return input->icons;
  }

  static const decltype(::blink::mojom::blink::Manifest::screenshots)& screenshots(
      const ::blink::mojom::blink::ManifestPtr& input) {
    return input->screenshots;
  }

  static const decltype(::blink::mojom::blink::Manifest::shortcuts)& shortcuts(
      const ::blink::mojom::blink::ManifestPtr& input) {
    return input->shortcuts;
  }

  static const decltype(::blink::mojom::blink::Manifest::share_target)& share_target(
      const ::blink::mojom::blink::ManifestPtr& input) {
    return input->share_target;
  }

  static const decltype(::blink::mojom::blink::Manifest::file_handlers)& file_handlers(
      const ::blink::mojom::blink::ManifestPtr& input) {
    return input->file_handlers;
  }

  static const decltype(::blink::mojom::blink::Manifest::protocol_handlers)& protocol_handlers(
      const ::blink::mojom::blink::ManifestPtr& input) {
    return input->protocol_handlers;
  }

  static const decltype(::blink::mojom::blink::Manifest::scope_extensions)& scope_extensions(
      const ::blink::mojom::blink::ManifestPtr& input) {
    return input->scope_extensions;
  }

  static const decltype(::blink::mojom::blink::Manifest::lock_screen)& lock_screen(
      const ::blink::mojom::blink::ManifestPtr& input) {
    return input->lock_screen;
  }

  static const decltype(::blink::mojom::blink::Manifest::note_taking)& note_taking(
      const ::blink::mojom::blink::ManifestPtr& input) {
    return input->note_taking;
  }

  static const decltype(::blink::mojom::blink::Manifest::related_applications)& related_applications(
      const ::blink::mojom::blink::ManifestPtr& input) {
    return input->related_applications;
  }

  static decltype(::blink::mojom::blink::Manifest::prefer_related_applications) prefer_related_applications(
      const ::blink::mojom::blink::ManifestPtr& input) {
    return input->prefer_related_applications;
  }

  static const decltype(::blink::mojom::blink::Manifest::migrate_from)& migrate_from(
      const ::blink::mojom::blink::ManifestPtr& input) {
    return input->migrate_from;
  }

  static const decltype(::blink::mojom::blink::Manifest::migrate_to)& migrate_to(
      const ::blink::mojom::blink::ManifestPtr& input) {
    return input->migrate_to;
  }

  static decltype(::blink::mojom::blink::Manifest::theme_color) theme_color(
      const ::blink::mojom::blink::ManifestPtr& input) {
    return input->theme_color;
  }

  static decltype(::blink::mojom::blink::Manifest::background_color) background_color(
      const ::blink::mojom::blink::ManifestPtr& input) {
    return input->background_color;
  }

  static const decltype(::blink::mojom::blink::Manifest::gcm_sender_id)& gcm_sender_id(
      const ::blink::mojom::blink::ManifestPtr& input) {
    return input->gcm_sender_id;
  }

  static const decltype(::blink::mojom::blink::Manifest::scope)& scope(
      const ::blink::mojom::blink::ManifestPtr& input) {
    return input->scope;
  }

  static const decltype(::blink::mojom::blink::Manifest::update_manifest_url)& update_manifest_url(
      const ::blink::mojom::blink::ManifestPtr& input) {
    return input->update_manifest_url;
  }

  static const decltype(::blink::mojom::blink::Manifest::launch_handler)& launch_handler(
      const ::blink::mojom::blink::ManifestPtr& input) {
    return input->launch_handler;
  }

  static const decltype(::blink::mojom::blink::Manifest::translations)& translations(
      const ::blink::mojom::blink::ManifestPtr& input) {
    return input->translations;
  }

  static decltype(::blink::mojom::blink::Manifest::dark_theme_color) dark_theme_color(
      const ::blink::mojom::blink::ManifestPtr& input) {
    return input->dark_theme_color;
  }

  static decltype(::blink::mojom::blink::Manifest::dark_background_color) dark_background_color(
      const ::blink::mojom::blink::ManifestPtr& input) {
    return input->dark_background_color;
  }

  static const decltype(::blink::mojom::blink::Manifest::tab_strip)& tab_strip(
      const ::blink::mojom::blink::ManifestPtr& input) {
    return input->tab_strip;
  }

  static const decltype(::blink::mojom::blink::Manifest::version)& version(
      const ::blink::mojom::blink::ManifestPtr& input) {
    return input->version;
  }

  static const decltype(::blink::mojom::blink::Manifest::name_localized)& name_localized(
      const ::blink::mojom::blink::ManifestPtr& input) {
    return input->name_localized;
  }

  static const decltype(::blink::mojom::blink::Manifest::short_name_localized)& short_name_localized(
      const ::blink::mojom::blink::ManifestPtr& input) {
    return input->short_name_localized;
  }

  static const decltype(::blink::mojom::blink::Manifest::description_localized)& description_localized(
      const ::blink::mojom::blink::ManifestPtr& input) {
    return input->description_localized;
  }

  static const decltype(::blink::mojom::blink::Manifest::icons_localized)& icons_localized(
      const ::blink::mojom::blink::ManifestPtr& input) {
    return input->icons_localized;
  }

  static bool Read(::blink::mojom::blink::Manifest::DataView input, ::blink::mojom::blink::ManifestPtr* output);
};


template <>
struct PLATFORM_EXPORT StructTraits<::blink::mojom::blink::ManifestLocalizedTextObject::DataView,
                                         ::blink::mojom::blink::ManifestLocalizedTextObjectPtr> {
  static bool IsNull(const ::blink::mojom::blink::ManifestLocalizedTextObjectPtr& input) { return !input; }
  static void SetToNull(::blink::mojom::blink::ManifestLocalizedTextObjectPtr* output) { output->reset(); }

  static const decltype(::blink::mojom::blink::ManifestLocalizedTextObject::value)& value(
      const ::blink::mojom::blink::ManifestLocalizedTextObjectPtr& input) {
    return input->value;
  }

  static decltype(::blink::mojom::blink::ManifestLocalizedTextObject::dir) dir(
      const ::blink::mojom::blink::ManifestLocalizedTextObjectPtr& input) {
    return input->dir;
  }

  static const decltype(::blink::mojom::blink::ManifestLocalizedTextObject::lang)& lang(
      const ::blink::mojom::blink::ManifestLocalizedTextObjectPtr& input) {
    return input->lang;
  }

  static bool Read(::blink::mojom::blink::ManifestLocalizedTextObject::DataView input, ::blink::mojom::blink::ManifestLocalizedTextObjectPtr* output);
};


template <>
struct PLATFORM_EXPORT StructTraits<::blink::mojom::blink::Locale::DataView,
                                         ::blink::mojom::blink::LocalePtr> {
  static bool IsNull(const ::blink::mojom::blink::LocalePtr& input) { return !input; }
  static void SetToNull(::blink::mojom::blink::LocalePtr* output) { output->reset(); }

  static const decltype(::blink::mojom::blink::Locale::tag)& tag(
      const ::blink::mojom::blink::LocalePtr& input) {
    return input->tag;
  }

  static bool Read(::blink::mojom::blink::Locale::DataView input, ::blink::mojom::blink::LocalePtr* output);
};


template <>
struct PLATFORM_EXPORT StructTraits<::blink::mojom::blink::ManifestShortcutItem::DataView,
                                         ::blink::mojom::blink::ManifestShortcutItemPtr> {
  static bool IsNull(const ::blink::mojom::blink::ManifestShortcutItemPtr& input) { return !input; }
  static void SetToNull(::blink::mojom::blink::ManifestShortcutItemPtr* output) { output->reset(); }

  static const decltype(::blink::mojom::blink::ManifestShortcutItem::name)& name(
      const ::blink::mojom::blink::ManifestShortcutItemPtr& input) {
    return input->name;
  }

  static const decltype(::blink::mojom::blink::ManifestShortcutItem::short_name)& short_name(
      const ::blink::mojom::blink::ManifestShortcutItemPtr& input) {
    return input->short_name;
  }

  static const decltype(::blink::mojom::blink::ManifestShortcutItem::description)& description(
      const ::blink::mojom::blink::ManifestShortcutItemPtr& input) {
    return input->description;
  }

  static const decltype(::blink::mojom::blink::ManifestShortcutItem::url)& url(
      const ::blink::mojom::blink::ManifestShortcutItemPtr& input) {
    return input->url;
  }

  static const decltype(::blink::mojom::blink::ManifestShortcutItem::icons)& icons(
      const ::blink::mojom::blink::ManifestShortcutItemPtr& input) {
    return input->icons;
  }

  static const decltype(::blink::mojom::blink::ManifestShortcutItem::name_localized)& name_localized(
      const ::blink::mojom::blink::ManifestShortcutItemPtr& input) {
    return input->name_localized;
  }

  static const decltype(::blink::mojom::blink::ManifestShortcutItem::short_name_localized)& short_name_localized(
      const ::blink::mojom::blink::ManifestShortcutItemPtr& input) {
    return input->short_name_localized;
  }

  static const decltype(::blink::mojom::blink::ManifestShortcutItem::description_localized)& description_localized(
      const ::blink::mojom::blink::ManifestShortcutItemPtr& input) {
    return input->description_localized;
  }

  static const decltype(::blink::mojom::blink::ManifestShortcutItem::icons_localized)& icons_localized(
      const ::blink::mojom::blink::ManifestShortcutItemPtr& input) {
    return input->icons_localized;
  }

  static bool Read(::blink::mojom::blink::ManifestShortcutItem::DataView input, ::blink::mojom::blink::ManifestShortcutItemPtr* output);
};


template <>
struct PLATFORM_EXPORT StructTraits<::blink::mojom::blink::ManifestImageResource::DataView,
                                         ::blink::mojom::blink::ManifestImageResourcePtr> {
  static bool IsNull(const ::blink::mojom::blink::ManifestImageResourcePtr& input) { return !input; }
  static void SetToNull(::blink::mojom::blink::ManifestImageResourcePtr* output) { output->reset(); }

  static const decltype(::blink::mojom::blink::ManifestImageResource::src)& src(
      const ::blink::mojom::blink::ManifestImageResourcePtr& input) {
    return input->src;
  }

  static const decltype(::blink::mojom::blink::ManifestImageResource::type)& type(
      const ::blink::mojom::blink::ManifestImageResourcePtr& input) {
    return input->type;
  }

  static const decltype(::blink::mojom::blink::ManifestImageResource::sizes)& sizes(
      const ::blink::mojom::blink::ManifestImageResourcePtr& input) {
    return input->sizes;
  }

  static const decltype(::blink::mojom::blink::ManifestImageResource::purpose)& purpose(
      const ::blink::mojom::blink::ManifestImageResourcePtr& input) {
    return input->purpose;
  }

  static bool Read(::blink::mojom::blink::ManifestImageResource::DataView input, ::blink::mojom::blink::ManifestImageResourcePtr* output);
};


template <>
struct PLATFORM_EXPORT StructTraits<::blink::mojom::blink::ManifestScreenshot::DataView,
                                         ::blink::mojom::blink::ManifestScreenshotPtr> {
  static bool IsNull(const ::blink::mojom::blink::ManifestScreenshotPtr& input) { return !input; }
  static void SetToNull(::blink::mojom::blink::ManifestScreenshotPtr* output) { output->reset(); }

  static const decltype(::blink::mojom::blink::ManifestScreenshot::image)& image(
      const ::blink::mojom::blink::ManifestScreenshotPtr& input) {
    return input->image;
  }

  static decltype(::blink::mojom::blink::ManifestScreenshot::form_factor) form_factor(
      const ::blink::mojom::blink::ManifestScreenshotPtr& input) {
    return input->form_factor;
  }

  static const decltype(::blink::mojom::blink::ManifestScreenshot::label)& label(
      const ::blink::mojom::blink::ManifestScreenshotPtr& input) {
    return input->label;
  }

  static bool Read(::blink::mojom::blink::ManifestScreenshot::DataView input, ::blink::mojom::blink::ManifestScreenshotPtr* output);
};


template <>
struct PLATFORM_EXPORT StructTraits<::blink::mojom::blink::ManifestFileFilter::DataView,
                                         ::blink::mojom::blink::ManifestFileFilterPtr> {
  static bool IsNull(const ::blink::mojom::blink::ManifestFileFilterPtr& input) { return !input; }
  static void SetToNull(::blink::mojom::blink::ManifestFileFilterPtr* output) { output->reset(); }

  static const decltype(::blink::mojom::blink::ManifestFileFilter::name)& name(
      const ::blink::mojom::blink::ManifestFileFilterPtr& input) {
    return input->name;
  }

  static const decltype(::blink::mojom::blink::ManifestFileFilter::accept)& accept(
      const ::blink::mojom::blink::ManifestFileFilterPtr& input) {
    return input->accept;
  }

  static bool Read(::blink::mojom::blink::ManifestFileFilter::DataView input, ::blink::mojom::blink::ManifestFileFilterPtr* output);
};


template <>
struct PLATFORM_EXPORT StructTraits<::blink::mojom::blink::ManifestProtocolHandler::DataView,
                                         ::blink::mojom::blink::ManifestProtocolHandlerPtr> {
  static bool IsNull(const ::blink::mojom::blink::ManifestProtocolHandlerPtr& input) { return !input; }
  static void SetToNull(::blink::mojom::blink::ManifestProtocolHandlerPtr* output) { output->reset(); }

  static const decltype(::blink::mojom::blink::ManifestProtocolHandler::protocol)& protocol(
      const ::blink::mojom::blink::ManifestProtocolHandlerPtr& input) {
    return input->protocol;
  }

  static const decltype(::blink::mojom::blink::ManifestProtocolHandler::url)& url(
      const ::blink::mojom::blink::ManifestProtocolHandlerPtr& input) {
    return input->url;
  }

  static bool Read(::blink::mojom::blink::ManifestProtocolHandler::DataView input, ::blink::mojom::blink::ManifestProtocolHandlerPtr* output);
};


template <>
struct PLATFORM_EXPORT StructTraits<::blink::mojom::blink::ManifestScopeExtension::DataView,
                                         ::blink::mojom::blink::ManifestScopeExtensionPtr> {
  static bool IsNull(const ::blink::mojom::blink::ManifestScopeExtensionPtr& input) { return !input; }
  static void SetToNull(::blink::mojom::blink::ManifestScopeExtensionPtr* output) { output->reset(); }

  static const decltype(::blink::mojom::blink::ManifestScopeExtension::origin)& origin(
      const ::blink::mojom::blink::ManifestScopeExtensionPtr& input) {
    return input->origin;
  }

  static decltype(::blink::mojom::blink::ManifestScopeExtension::has_origin_wildcard) has_origin_wildcard(
      const ::blink::mojom::blink::ManifestScopeExtensionPtr& input) {
    return input->has_origin_wildcard;
  }

  static bool Read(::blink::mojom::blink::ManifestScopeExtension::DataView input, ::blink::mojom::blink::ManifestScopeExtensionPtr* output);
};


template <>
struct PLATFORM_EXPORT StructTraits<::blink::mojom::blink::ManifestLockScreen::DataView,
                                         ::blink::mojom::blink::ManifestLockScreenPtr> {
  static bool IsNull(const ::blink::mojom::blink::ManifestLockScreenPtr& input) { return !input; }
  static void SetToNull(::blink::mojom::blink::ManifestLockScreenPtr* output) { output->reset(); }

  static const decltype(::blink::mojom::blink::ManifestLockScreen::start_url)& start_url(
      const ::blink::mojom::blink::ManifestLockScreenPtr& input) {
    return input->start_url;
  }

  static bool Read(::blink::mojom::blink::ManifestLockScreen::DataView input, ::blink::mojom::blink::ManifestLockScreenPtr* output);
};


template <>
struct PLATFORM_EXPORT StructTraits<::blink::mojom::blink::ManifestNoteTaking::DataView,
                                         ::blink::mojom::blink::ManifestNoteTakingPtr> {
  static bool IsNull(const ::blink::mojom::blink::ManifestNoteTakingPtr& input) { return !input; }
  static void SetToNull(::blink::mojom::blink::ManifestNoteTakingPtr* output) { output->reset(); }

  static const decltype(::blink::mojom::blink::ManifestNoteTaking::new_note_url)& new_note_url(
      const ::blink::mojom::blink::ManifestNoteTakingPtr& input) {
    return input->new_note_url;
  }

  static bool Read(::blink::mojom::blink::ManifestNoteTaking::DataView input, ::blink::mojom::blink::ManifestNoteTakingPtr* output);
};


template <>
struct PLATFORM_EXPORT StructTraits<::blink::mojom::blink::ManifestRelatedApplication::DataView,
                                         ::blink::mojom::blink::ManifestRelatedApplicationPtr> {
  static bool IsNull(const ::blink::mojom::blink::ManifestRelatedApplicationPtr& input) { return !input; }
  static void SetToNull(::blink::mojom::blink::ManifestRelatedApplicationPtr* output) { output->reset(); }

  static const decltype(::blink::mojom::blink::ManifestRelatedApplication::platform)& platform(
      const ::blink::mojom::blink::ManifestRelatedApplicationPtr& input) {
    return input->platform;
  }

  static const decltype(::blink::mojom::blink::ManifestRelatedApplication::url)& url(
      const ::blink::mojom::blink::ManifestRelatedApplicationPtr& input) {
    return input->url;
  }

  static const decltype(::blink::mojom::blink::ManifestRelatedApplication::id)& id(
      const ::blink::mojom::blink::ManifestRelatedApplicationPtr& input) {
    return input->id;
  }

  static bool Read(::blink::mojom::blink::ManifestRelatedApplication::DataView input, ::blink::mojom::blink::ManifestRelatedApplicationPtr* output);
};


template <>
struct PLATFORM_EXPORT StructTraits<::blink::mojom::blink::ManifestShareTargetParams::DataView,
                                         ::blink::mojom::blink::ManifestShareTargetParamsPtr> {
  static bool IsNull(const ::blink::mojom::blink::ManifestShareTargetParamsPtr& input) { return !input; }
  static void SetToNull(::blink::mojom::blink::ManifestShareTargetParamsPtr* output) { output->reset(); }

  static const decltype(::blink::mojom::blink::ManifestShareTargetParams::title)& title(
      const ::blink::mojom::blink::ManifestShareTargetParamsPtr& input) {
    return input->title;
  }

  static const decltype(::blink::mojom::blink::ManifestShareTargetParams::text)& text(
      const ::blink::mojom::blink::ManifestShareTargetParamsPtr& input) {
    return input->text;
  }

  static const decltype(::blink::mojom::blink::ManifestShareTargetParams::url)& url(
      const ::blink::mojom::blink::ManifestShareTargetParamsPtr& input) {
    return input->url;
  }

  static const decltype(::blink::mojom::blink::ManifestShareTargetParams::files)& files(
      const ::blink::mojom::blink::ManifestShareTargetParamsPtr& input) {
    return input->files;
  }

  static bool Read(::blink::mojom::blink::ManifestShareTargetParams::DataView input, ::blink::mojom::blink::ManifestShareTargetParamsPtr* output);
};


template <>
struct PLATFORM_EXPORT StructTraits<::blink::mojom::blink::ManifestShareTarget::DataView,
                                         ::blink::mojom::blink::ManifestShareTargetPtr> {
  static bool IsNull(const ::blink::mojom::blink::ManifestShareTargetPtr& input) { return !input; }
  static void SetToNull(::blink::mojom::blink::ManifestShareTargetPtr* output) { output->reset(); }

  static const decltype(::blink::mojom::blink::ManifestShareTarget::action)& action(
      const ::blink::mojom::blink::ManifestShareTargetPtr& input) {
    return input->action;
  }

  static decltype(::blink::mojom::blink::ManifestShareTarget::method) method(
      const ::blink::mojom::blink::ManifestShareTargetPtr& input) {
    return input->method;
  }

  static decltype(::blink::mojom::blink::ManifestShareTarget::enctype) enctype(
      const ::blink::mojom::blink::ManifestShareTargetPtr& input) {
    return input->enctype;
  }

  static const decltype(::blink::mojom::blink::ManifestShareTarget::params)& params(
      const ::blink::mojom::blink::ManifestShareTargetPtr& input) {
    return input->params;
  }

  static bool Read(::blink::mojom::blink::ManifestShareTarget::DataView input, ::blink::mojom::blink::ManifestShareTargetPtr* output);
};


template <>
struct PLATFORM_EXPORT StructTraits<::blink::mojom::blink::ManifestFileHandler::DataView,
                                         ::blink::mojom::blink::ManifestFileHandlerPtr> {
  static bool IsNull(const ::blink::mojom::blink::ManifestFileHandlerPtr& input) { return !input; }
  static void SetToNull(::blink::mojom::blink::ManifestFileHandlerPtr* output) { output->reset(); }

  static const decltype(::blink::mojom::blink::ManifestFileHandler::action)& action(
      const ::blink::mojom::blink::ManifestFileHandlerPtr& input) {
    return input->action;
  }

  static const decltype(::blink::mojom::blink::ManifestFileHandler::name)& name(
      const ::blink::mojom::blink::ManifestFileHandlerPtr& input) {
    return input->name;
  }

  static const decltype(::blink::mojom::blink::ManifestFileHandler::accept)& accept(
      const ::blink::mojom::blink::ManifestFileHandlerPtr& input) {
    return input->accept;
  }

  static decltype(::blink::mojom::blink::ManifestFileHandler::launch_type) launch_type(
      const ::blink::mojom::blink::ManifestFileHandlerPtr& input) {
    return input->launch_type;
  }

  static bool Read(::blink::mojom::blink::ManifestFileHandler::DataView input, ::blink::mojom::blink::ManifestFileHandlerPtr* output);
};


template <>
struct PLATFORM_EXPORT StructTraits<::blink::mojom::blink::ManifestTranslationItem::DataView,
                                         ::blink::mojom::blink::ManifestTranslationItemPtr> {
  static bool IsNull(const ::blink::mojom::blink::ManifestTranslationItemPtr& input) { return !input; }
  static void SetToNull(::blink::mojom::blink::ManifestTranslationItemPtr* output) { output->reset(); }

  static const decltype(::blink::mojom::blink::ManifestTranslationItem::name)& name(
      const ::blink::mojom::blink::ManifestTranslationItemPtr& input) {
    return input->name;
  }

  static const decltype(::blink::mojom::blink::ManifestTranslationItem::short_name)& short_name(
      const ::blink::mojom::blink::ManifestTranslationItemPtr& input) {
    return input->short_name;
  }

  static const decltype(::blink::mojom::blink::ManifestTranslationItem::description)& description(
      const ::blink::mojom::blink::ManifestTranslationItemPtr& input) {
    return input->description;
  }

  static bool Read(::blink::mojom::blink::ManifestTranslationItem::DataView input, ::blink::mojom::blink::ManifestTranslationItemPtr* output);
};


template <>
struct PLATFORM_EXPORT StructTraits<::blink::mojom::blink::ManifestMigrateFrom::DataView,
                                         ::blink::mojom::blink::ManifestMigrateFromPtr> {
  static bool IsNull(const ::blink::mojom::blink::ManifestMigrateFromPtr& input) { return !input; }
  static void SetToNull(::blink::mojom::blink::ManifestMigrateFromPtr* output) { output->reset(); }

  static const decltype(::blink::mojom::blink::ManifestMigrateFrom::id)& id(
      const ::blink::mojom::blink::ManifestMigrateFromPtr& input) {
    return input->id;
  }

  static const decltype(::blink::mojom::blink::ManifestMigrateFrom::install_url)& install_url(
      const ::blink::mojom::blink::ManifestMigrateFromPtr& input) {
    return input->install_url;
  }

  static decltype(::blink::mojom::blink::ManifestMigrateFrom::behavior) behavior(
      const ::blink::mojom::blink::ManifestMigrateFromPtr& input) {
    return input->behavior;
  }

  static bool Read(::blink::mojom::blink::ManifestMigrateFrom::DataView input, ::blink::mojom::blink::ManifestMigrateFromPtr* output);
};


template <>
struct PLATFORM_EXPORT StructTraits<::blink::mojom::blink::ManifestMigrateTo::DataView,
                                         ::blink::mojom::blink::ManifestMigrateToPtr> {
  static bool IsNull(const ::blink::mojom::blink::ManifestMigrateToPtr& input) { return !input; }
  static void SetToNull(::blink::mojom::blink::ManifestMigrateToPtr* output) { output->reset(); }

  static const decltype(::blink::mojom::blink::ManifestMigrateTo::id)& id(
      const ::blink::mojom::blink::ManifestMigrateToPtr& input) {
    return input->id;
  }

  static const decltype(::blink::mojom::blink::ManifestMigrateTo::install_url)& install_url(
      const ::blink::mojom::blink::ManifestMigrateToPtr& input) {
    return input->install_url;
  }

  static bool Read(::blink::mojom::blink::ManifestMigrateTo::DataView input, ::blink::mojom::blink::ManifestMigrateToPtr* output);
};


template <>
struct PLATFORM_EXPORT StructTraits<::blink::mojom::blink::ManifestTabStrip::DataView,
                                         ::blink::mojom::blink::ManifestTabStripPtr> {
  static bool IsNull(const ::blink::mojom::blink::ManifestTabStripPtr& input) { return !input; }
  static void SetToNull(::blink::mojom::blink::ManifestTabStripPtr* output) { output->reset(); }

  static const decltype(::blink::mojom::blink::ManifestTabStrip::home_tab)& home_tab(
      const ::blink::mojom::blink::ManifestTabStripPtr& input) {
    return input->home_tab;
  }

  static const decltype(::blink::mojom::blink::ManifestTabStrip::new_tab_button)& new_tab_button(
      const ::blink::mojom::blink::ManifestTabStripPtr& input) {
    return input->new_tab_button;
  }

  static bool Read(::blink::mojom::blink::ManifestTabStrip::DataView input, ::blink::mojom::blink::ManifestTabStripPtr* output);
};


template <>
struct PLATFORM_EXPORT StructTraits<::blink::mojom::blink::HomeTabParams::DataView,
                                         ::blink::mojom::blink::HomeTabParamsPtr> {
  static bool IsNull(const ::blink::mojom::blink::HomeTabParamsPtr& input) { return !input; }
  static void SetToNull(::blink::mojom::blink::HomeTabParamsPtr* output) { output->reset(); }

  static const decltype(::blink::mojom::blink::HomeTabParams::icons)& icons(
      const ::blink::mojom::blink::HomeTabParamsPtr& input) {
    return input->icons;
  }

  static const decltype(::blink::mojom::blink::HomeTabParams::scope_patterns)& scope_patterns(
      const ::blink::mojom::blink::HomeTabParamsPtr& input) {
    return input->scope_patterns;
  }

  static bool Read(::blink::mojom::blink::HomeTabParams::DataView input, ::blink::mojom::blink::HomeTabParamsPtr* output);
};


template <>
struct PLATFORM_EXPORT StructTraits<::blink::mojom::blink::NewTabButtonParams::DataView,
                                         ::blink::mojom::blink::NewTabButtonParamsPtr> {
  static bool IsNull(const ::blink::mojom::blink::NewTabButtonParamsPtr& input) { return !input; }
  static void SetToNull(::blink::mojom::blink::NewTabButtonParamsPtr* output) { output->reset(); }

  static const decltype(::blink::mojom::blink::NewTabButtonParams::url)& url(
      const ::blink::mojom::blink::NewTabButtonParamsPtr& input) {
    return input->url;
  }

  static bool Read(::blink::mojom::blink::NewTabButtonParams::DataView input, ::blink::mojom::blink::NewTabButtonParamsPtr* output);
};


template <>
struct PLATFORM_EXPORT StructTraits<::blink::mojom::blink::ManifestDebugInfo::DataView,
                                         ::blink::mojom::blink::ManifestDebugInfoPtr> {
  static bool IsNull(const ::blink::mojom::blink::ManifestDebugInfoPtr& input) { return !input; }
  static void SetToNull(::blink::mojom::blink::ManifestDebugInfoPtr* output) { output->reset(); }

  static const decltype(::blink::mojom::blink::ManifestDebugInfo::errors)& errors(
      const ::blink::mojom::blink::ManifestDebugInfoPtr& input) {
    return input->errors;
  }

  static const decltype(::blink::mojom::blink::ManifestDebugInfo::raw_manifest)& raw_manifest(
      const ::blink::mojom::blink::ManifestDebugInfoPtr& input) {
    return input->raw_manifest;
  }

  static bool Read(::blink::mojom::blink::ManifestDebugInfo::DataView input, ::blink::mojom::blink::ManifestDebugInfoPtr* output);
};


template <>
struct PLATFORM_EXPORT StructTraits<::blink::mojom::blink::ManifestError::DataView,
                                         ::blink::mojom::blink::ManifestErrorPtr> {
  static bool IsNull(const ::blink::mojom::blink::ManifestErrorPtr& input) { return !input; }
  static void SetToNull(::blink::mojom::blink::ManifestErrorPtr* output) { output->reset(); }

  static const decltype(::blink::mojom::blink::ManifestError::message)& message(
      const ::blink::mojom::blink::ManifestErrorPtr& input) {
    return input->message;
  }

  static decltype(::blink::mojom::blink::ManifestError::critical) critical(
      const ::blink::mojom::blink::ManifestErrorPtr& input) {
    return input->critical;
  }

  static decltype(::blink::mojom::blink::ManifestError::line) line(
      const ::blink::mojom::blink::ManifestErrorPtr& input) {
    return input->line;
  }

  static decltype(::blink::mojom::blink::ManifestError::column) column(
      const ::blink::mojom::blink::ManifestErrorPtr& input) {
    return input->column;
  }

  static bool Read(::blink::mojom::blink::ManifestError::DataView input, ::blink::mojom::blink::ManifestErrorPtr* output);
};


template <>
struct PLATFORM_EXPORT StructTraits<::blink::mojom::blink::DisplayOverrideItem::DataView,
                                         ::blink::mojom::blink::DisplayOverrideItemPtr> {
  static bool IsNull(const ::blink::mojom::blink::DisplayOverrideItemPtr& input) { return !input; }
  static void SetToNull(::blink::mojom::blink::DisplayOverrideItemPtr* output) { output->reset(); }

  static decltype(::blink::mojom::blink::DisplayOverrideItem::display) display(
      const ::blink::mojom::blink::DisplayOverrideItemPtr& input) {
    return input->display;
  }

  static const decltype(::blink::mojom::blink::DisplayOverrideItem::url_patterns)& url_patterns(
      const ::blink::mojom::blink::DisplayOverrideItemPtr& input) {
    return input->url_patterns;
  }

  static bool Read(::blink::mojom::blink::DisplayOverrideItem::DataView input, ::blink::mojom::blink::DisplayOverrideItemPtr* output);
};


template <>
struct PLATFORM_EXPORT UnionTraits<::blink::mojom::blink::HomeTabUnion::DataView,
                                        ::blink::mojom::blink::HomeTabUnionPtr> {
  static bool IsNull(const ::blink::mojom::blink::HomeTabUnionPtr& input) { return !input; }
  static void SetToNull(::blink::mojom::blink::HomeTabUnionPtr* output) { output->reset(); }

  static ::blink::mojom::blink::HomeTabUnion::Tag GetTag(const ::blink::mojom::blink::HomeTabUnionPtr& input) {
    return input->which();
  }

  static  ::blink::mojom::blink::TabStripMemberVisibility visibility(const ::blink::mojom::blink::HomeTabUnionPtr& input) {
    return input->get_visibility();
  }

  static const ::blink::mojom::blink::HomeTabParamsPtr& params(const ::blink::mojom::blink::HomeTabUnionPtr& input) {
    return input->get_params();
  }

  static bool Read(::blink::mojom::blink::HomeTabUnion::DataView input, ::blink::mojom::blink::HomeTabUnionPtr* output);
};

}  // namespace mojo

#endif  // THIRD_PARTY_BLINK_PUBLIC_MOJOM_MANIFEST_MANIFEST_MOJOM_BLINK_H_