// components/browser_apis/bookmarks/bookmarks_api.mojom.h is auto generated by mojom_bindings_generator.py, do not edit

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

#ifndef COMPONENTS_BROWSER_APIS_BOOKMARKS_BOOKMARKS_API_MOJOM_H_
#define COMPONENTS_BROWSER_APIS_BOOKMARKS_BOOKMARKS_API_MOJOM_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 "components/browser_apis/bookmarks/bookmarks_api.mojom-features.h"  // IWYU pragma: export
#include "components/browser_apis/bookmarks/bookmarks_api.mojom-shared.h"  // IWYU pragma: export
#include "components/browser_apis/bookmarks/bookmarks_api.mojom-forward.h"  // IWYU pragma: export
#include "mojo/public/mojom/base/empty.mojom.h"
#include "mojo/public/mojom/base/error.mojom.h"
#include "mojo/public/mojom/base/uuid.mojom.h"
#include "url/mojom/url.mojom.h"
#include <string>
#include <vector>

#include "mojo/public/cpp/bindings/lib/control_message_handler.h"
#include "mojo/public/cpp/bindings/raw_ptr_impl_ref_traits.h"


#include "base/types/expected.h"




namespace bookmarks_api::mojom {

class BookmarksObserverProxy;

template <typename ImplRefTraits>
class BookmarksObserverStub;

class BookmarksObserverRequestValidator;


class BookmarksObserver
    : public BookmarksObserverInterfaceBase {
 public:
  using IPCStableHashFunction = uint32_t(*)();
  static constexpr const char* Name_ = "bookmarks_api.mojom.BookmarksObserver";
  static IPCStableHashFunction MessageToMethodInfo_(mojo::Message& message);
  static const char* MessageToMethodName_(mojo::Message& message);
  static constexpr uint32_t Version_ = 0;
  static constexpr bool PassesAssociatedKinds_ = false;
  static constexpr bool HasUninterruptableMethods_ = false;

  using Base_ = BookmarksObserverInterfaceBase;
  using Proxy_ = BookmarksObserverProxy;

  template <typename ImplRefTraits>
  using Stub_ = BookmarksObserverStub<ImplRefTraits>;

  using RequestValidator_ = BookmarksObserverRequestValidator;
  using ResponseValidator_ = mojo::PassThroughFilter;
  enum MethodMinVersions : uint32_t {
    kOnBookmarksEventsMinVersion = 0,
  };

// crbug.com/1340245 - this causes binary size bloat on Fuchsia, and we're OK
// with not having this data in traces there.
#if !BUILDFLAG(IS_FUCHSIA)
  struct OnBookmarksEvents_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
#endif // !BUILDFLAG(IS_FUCHSIA)
  virtual ~BookmarksObserver() = default;

  virtual void OnBookmarksEvents(std::vector<BookmarksEventPtr> events) = 0;
};

class BookmarksServiceProxy;

template <typename ImplRefTraits>
class BookmarksServiceStub;

class BookmarksServiceRequestValidator;
class BookmarksServiceResponseValidator;


class BookmarksService
    : public BookmarksServiceInterfaceBase {
 public:
  using IPCStableHashFunction = uint32_t(*)();
  static constexpr const char* Name_ = "bookmarks_api.mojom.BookmarksService";
  static IPCStableHashFunction MessageToMethodInfo_(mojo::Message& message);
  static const char* MessageToMethodName_(mojo::Message& message);
  static constexpr uint32_t Version_ = 0;
  static constexpr bool PassesAssociatedKinds_ = true;
  static constexpr bool HasUninterruptableMethods_ = false;

  using Base_ = BookmarksServiceInterfaceBase;
  using Proxy_ = BookmarksServiceProxy;

  template <typename ImplRefTraits>
  using Stub_ = BookmarksServiceStub<ImplRefTraits>;

  using RequestValidator_ = BookmarksServiceRequestValidator;
  using ResponseValidator_ = BookmarksServiceResponseValidator;
  enum MethodMinVersions : uint32_t {
    kGetBookmarksMinVersion = 0,
    kGetBookmarkMinVersion = 0,
    kCreateBookmarkNodeMinVersion = 0,
    kUpdateBookmarkNodeMinVersion = 0,
    kMoveBookmarkNodeMinVersion = 0,
    kDeleteBookmarkNodesMinVersion = 0,
  };

// crbug.com/1340245 - this causes binary size bloat on Fuchsia, and we're OK
// with not having this data in traces there.
#if !BUILDFLAG(IS_FUCHSIA)
  struct GetBookmarks_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct GetBookmark_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct CreateBookmarkNode_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct UpdateBookmarkNode_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct MoveBookmarkNode_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct DeleteBookmarkNodes_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
#endif // !BUILDFLAG(IS_FUCHSIA)
  virtual ~BookmarksService() = default;

  using GetBookmarksCallback = base::OnceCallback<void(base::expected<
  BookmarksSnapshotPtr,
  ::mojo_base::mojom::ErrorPtr>)>;
  using GetBookmarksResult = base::expected<
  BookmarksSnapshotPtr,
  ::mojo_base::mojom::ErrorPtr>;
  using GetBookmarksMojoCallback = base::OnceCallback<void(BookmarksService_GetBookmarks_ResponseParam_ResultPtr)>;

  virtual void GetBookmarks(GetBookmarksCallback callback) = 0;

  using GetBookmarkCallback = base::OnceCallback<void(base::expected<
  BookmarkNodePtr,
  ::mojo_base::mojom::ErrorPtr>)>;
  using GetBookmarkResult = base::expected<
  BookmarkNodePtr,
  ::mojo_base::mojom::ErrorPtr>;
  using GetBookmarkMojoCallback = base::OnceCallback<void(BookmarksService_GetBookmark_ResponseParam_ResultPtr)>;

  virtual void GetBookmark(const ::base::Uuid& id, GetBookmarkCallback callback) = 0;

  using CreateBookmarkNodeCallback = base::OnceCallback<void(base::expected<
  BookmarkNodePtr,
  ::mojo_base::mojom::ErrorPtr>)>;
  using CreateBookmarkNodeResult = base::expected<
  BookmarkNodePtr,
  ::mojo_base::mojom::ErrorPtr>;
  using CreateBookmarkNodeMojoCallback = base::OnceCallback<void(BookmarksService_CreateBookmarkNode_ResponseParam_ResultPtr)>;

  virtual void CreateBookmarkNode(const ::base::Uuid& parent_id, std::optional<int32_t> index, BookmarkNodePtr node, CreateBookmarkNodeCallback callback) = 0;

  using UpdateBookmarkNodeCallback = base::OnceCallback<void(base::expected<
  BookmarkNodePtr,
  ::mojo_base::mojom::ErrorPtr>)>;
  using UpdateBookmarkNodeResult = base::expected<
  BookmarkNodePtr,
  ::mojo_base::mojom::ErrorPtr>;
  using UpdateBookmarkNodeMojoCallback = base::OnceCallback<void(BookmarksService_UpdateBookmarkNode_ResponseParam_ResultPtr)>;

  virtual void UpdateBookmarkNode(BookmarkNodePtr node, UpdateBookmarkNodeCallback callback) = 0;

  using MoveBookmarkNodeCallback = base::OnceCallback<void(base::expected<
  ::std::monostate,
  ::mojo_base::mojom::ErrorPtr>)>;
  using MoveBookmarkNodeResult = base::expected<
  ::std::monostate,
  ::mojo_base::mojom::ErrorPtr>;
  using MoveBookmarkNodeMojoCallback = base::OnceCallback<void(BookmarksService_MoveBookmarkNode_ResponseParam_ResultPtr)>;

  virtual void MoveBookmarkNode(const ::base::Uuid& id, const ::base::Uuid& new_parent_id, std::optional<int32_t> index, MoveBookmarkNodeCallback callback) = 0;

  using DeleteBookmarkNodesCallback = base::OnceCallback<void(base::expected<
  ::std::monostate,
  ::mojo_base::mojom::ErrorPtr>)>;
  using DeleteBookmarkNodesResult = base::expected<
  ::std::monostate,
  ::mojo_base::mojom::ErrorPtr>;
  using DeleteBookmarkNodesMojoCallback = base::OnceCallback<void(BookmarksService_DeleteBookmarkNodes_ResponseParam_ResultPtr)>;

  virtual void DeleteBookmarkNodes(const std::vector<::base::Uuid>& ids, DeleteBookmarkNodesCallback callback) = 0;
};




class BookmarksServiceDirectReturnStub {
 public:
   virtual ~BookmarksServiceDirectReturnStub() = default;


   using GetBookmarksResult = BookmarksService::GetBookmarksResult;
   virtual BookmarksService::GetBookmarksResult GetBookmarks() = 0;

   using GetBookmarkResult = BookmarksService::GetBookmarkResult;
   virtual BookmarksService::GetBookmarkResult GetBookmark(const ::base::Uuid& id) = 0;

   using CreateBookmarkNodeResult = BookmarksService::CreateBookmarkNodeResult;
   virtual BookmarksService::CreateBookmarkNodeResult CreateBookmarkNode(const ::base::Uuid& parent_id, std::optional<int32_t> index, BookmarkNodePtr node) = 0;

   using UpdateBookmarkNodeResult = BookmarksService::UpdateBookmarkNodeResult;
   virtual BookmarksService::UpdateBookmarkNodeResult UpdateBookmarkNode(BookmarkNodePtr node) = 0;

   using MoveBookmarkNodeResult = BookmarksService::MoveBookmarkNodeResult;
   virtual BookmarksService::MoveBookmarkNodeResult MoveBookmarkNode(const ::base::Uuid& id, const ::base::Uuid& new_parent_id, std::optional<int32_t> index) = 0;

   using DeleteBookmarkNodesResult = BookmarksService::DeleteBookmarkNodesResult;
   virtual BookmarksService::DeleteBookmarkNodesResult DeleteBookmarkNodes(const std::vector<::base::Uuid>& ids) = 0;

};

class BookmarksServiceBridge : public BookmarksService {
 public:
   // The bridge owns the direct return stub. Use the bridge to manage the
   // lifetime of the service, as if it was a normal mojo service impl.
   BookmarksServiceBridge(BookmarksServiceDirectReturnStub* stub);
   BookmarksServiceBridge(const BookmarksServiceBridge&) = delete;
   BookmarksServiceBridge operator=(const BookmarksServiceBridge&) = delete;
   ~BookmarksServiceBridge() override;


   void GetBookmarks(GetBookmarksCallback callback) override;
   void GetBookmark(const ::base::Uuid& id, GetBookmarkCallback callback) override;
   void CreateBookmarkNode(const ::base::Uuid& parent_id, std::optional<int32_t> index, BookmarkNodePtr node, CreateBookmarkNodeCallback callback) override;
   void UpdateBookmarkNode(BookmarkNodePtr node, UpdateBookmarkNodeCallback callback) override;
   void MoveBookmarkNode(const ::base::Uuid& id, const ::base::Uuid& new_parent_id, std::optional<int32_t> index, MoveBookmarkNodeCallback callback) override;
   void DeleteBookmarkNodes(const std::vector<::base::Uuid>& ids, DeleteBookmarkNodesCallback callback) override;

 private:
   BookmarksServiceDirectReturnStub* stub_;
};



class  BookmarksObserverProxy
    : public BookmarksObserver {
 public:
  using InterfaceType = BookmarksObserver;

  explicit BookmarksObserverProxy(mojo::MessageReceiverWithResponder* receiver);
  
  void OnBookmarksEvents(std::vector<BookmarksEventPtr> events) final;

 private:
  mojo::MessageReceiverWithResponder* receiver_;
};



class  BookmarksServiceProxy
    : public BookmarksService {
 public:
  using InterfaceType = BookmarksService;

  explicit BookmarksServiceProxy(mojo::MessageReceiverWithResponder* receiver);
  
  void GetBookmarks(GetBookmarksCallback callback) final;
  
  void GetBookmark(const ::base::Uuid& id, GetBookmarkCallback callback) final;
  
  void CreateBookmarkNode(const ::base::Uuid& parent_id, std::optional<int32_t> index, BookmarkNodePtr node, CreateBookmarkNodeCallback callback) final;
  
  void UpdateBookmarkNode(BookmarkNodePtr node, UpdateBookmarkNodeCallback callback) final;
  
  void MoveBookmarkNode(const ::base::Uuid& id, const ::base::Uuid& new_parent_id, std::optional<int32_t> index, MoveBookmarkNodeCallback callback) final;
  
  void DeleteBookmarkNodes(const std::vector<::base::Uuid>& ids, DeleteBookmarkNodesCallback callback) final;

 private:
  mojo::MessageReceiverWithResponder* receiver_;
};
class  BookmarksObserverStubDispatch {
 public:
  static bool Accept(BookmarksObserver* impl, mojo::Message* message);
  static bool AcceptWithResponder(
      BookmarksObserver* impl,
      mojo::Message* message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder);
};

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

  BookmarksObserverStub() = default;
  ~BookmarksObserverStub() override = default;

  void set_sink(ImplPointerType sink) { sink_ = std::move(sink); }
  ImplPointerType& sink() { return sink_; }

  bool Accept(mojo::Message* message) override {
    if (ImplRefTraits::IsNull(sink_))
      return false;
    return BookmarksObserverStubDispatch::Accept(
        ImplRefTraits::GetRawPointer(&sink_), message);
  }

  bool AcceptWithResponder(
      mojo::Message* message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) override {
    if (ImplRefTraits::IsNull(sink_))
      return false;
    return BookmarksObserverStubDispatch::AcceptWithResponder(
        ImplRefTraits::GetRawPointer(&sink_), message, std::move(responder));
  }

 private:
  ImplPointerType sink_;
};
class  BookmarksServiceStubDispatch {
 public:
  static bool Accept(BookmarksService* impl, mojo::Message* message);
  static bool AcceptWithResponder(
      BookmarksService* impl,
      mojo::Message* message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder);
};

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

  BookmarksServiceStub() = default;
  ~BookmarksServiceStub() override = default;

  void set_sink(ImplPointerType sink) { sink_ = std::move(sink); }
  ImplPointerType& sink() { return sink_; }

  bool Accept(mojo::Message* message) override {
    if (ImplRefTraits::IsNull(sink_))
      return false;
    return BookmarksServiceStubDispatch::Accept(
        ImplRefTraits::GetRawPointer(&sink_), message);
  }

  bool AcceptWithResponder(
      mojo::Message* message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) override {
    if (ImplRefTraits::IsNull(sink_))
      return false;
    return BookmarksServiceStubDispatch::AcceptWithResponder(
        ImplRefTraits::GetRawPointer(&sink_), message, std::move(responder));
  }

 private:
  ImplPointerType sink_;
};
class  BookmarksObserverRequestValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class  BookmarksServiceRequestValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class  BookmarksServiceResponseValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};





class  LegacyFields {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<LegacyFields, T>::value>;
  using DataView = LegacyFieldsDataView;
  using Data_ = internal::LegacyFields_Data;

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

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

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


  LegacyFields();

  explicit LegacyFields(
      std::optional<int64_t> id);


  ~LegacyFields();

  // 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 = LegacyFieldsPtr>
  LegacyFieldsPtr 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, LegacyFields::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

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

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

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

  template <typename UserType>
  static std::vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        LegacyFields::DataView, std::vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        LegacyFields::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::LegacyFields_UnserializedMessageContext<
            UserType, LegacyFields::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<LegacyFields::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(base::span<const uint8_t> input,
                          UserType* output) {
    return LegacyFields::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::LegacyFields_UnserializedMessageContext<
            UserType, LegacyFields::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<LegacyFields::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

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

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

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

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













class  BookmarkNode {
 public:
  using DataView = BookmarkNodeDataView;
  using Data_ = internal::BookmarkNode_Data;
  using Tag = Data_::BookmarkNode_Tag;

  template <typename... Args>
  static BookmarkNodePtr 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 |url|.
  static BookmarkNodePtr NewUrl(
      UrlPtr value);
  // Construct an instance holding |folder|.
  static BookmarkNodePtr NewFolder(
      FolderPtr value);

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

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

  // Delete the copy constructor and copy assignment operators because `data_`
  // contains raw pointers that must not be copied.
  BookmarkNode(const BookmarkNode& other) = delete;
  BookmarkNode& operator=(const BookmarkNode& 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 = BookmarkNodePtr>
  BookmarkNodePtr 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, BookmarkNode>::value>::type* = nullptr>
  bool Equals(const T& other) const;

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

  Tag which() const {
    return tag_;
  }

  bool is_url() const { return tag_ == Tag::kUrl; }
  const UrlPtr& get_url() const {
    CHECK(tag_ == Tag::kUrl);
    return data_.url;
  }
  UrlPtr& get_url() {
    CHECK(tag_ == Tag::kUrl);
    return data_.url;
  }
  void set_url(UrlPtr url);

  bool is_folder() const { return tag_ == Tag::kFolder; }
  const FolderPtr& get_folder() const {
    CHECK(tag_ == Tag::kFolder);
    return data_.folder;
  }
  FolderPtr& get_folder() {
    CHECK(tag_ == Tag::kFolder);
    return data_.folder;
  }
  void set_folder(FolderPtr folder);

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

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    return mojo::internal::DeserializeImpl<BookmarkNode::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::kUrl)>,
        UrlPtr value);
    Union_(
        std::in_place_index_t<static_cast<size_t>(Tag::kFolder)>,
        FolderPtr value);
    // The contents of the union are explicitly destroyed by `DestroyActive()`.
    ~Union_() {}

    UrlPtr url;
    FolderPtr folder;
  };

  BookmarkNode(
      std::in_place_index_t<static_cast<size_t>(Tag::kUrl)>,
      UrlPtr value);
  BookmarkNode(
      std::in_place_index_t<static_cast<size_t>(Tag::kFolder)>,
      FolderPtr value);

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

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



class  BookmarksEvent {
 public:
  using DataView = BookmarksEventDataView;
  using Data_ = internal::BookmarksEvent_Data;
  using Tag = Data_::BookmarksEvent_Tag;

  template <typename... Args>
  static BookmarksEventPtr 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 |added|.
  static BookmarksEventPtr NewAdded(
      BookmarkNodeCreatedPtr value);
  // Construct an instance holding |removed|.
  static BookmarksEventPtr NewRemoved(
      BookmarkNodeRemovedPtr value);
  // Construct an instance holding |moved|.
  static BookmarksEventPtr NewMoved(
      BookmarkNodeMovedPtr value);
  // Construct an instance holding |changed|.
  static BookmarksEventPtr NewChanged(
      BookmarkNodeChangedPtr value);

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

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

  // Delete the copy constructor and copy assignment operators because `data_`
  // contains raw pointers that must not be copied.
  BookmarksEvent(const BookmarksEvent& other) = delete;
  BookmarksEvent& operator=(const BookmarksEvent& 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 = BookmarksEventPtr>
  BookmarksEventPtr 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, BookmarksEvent>::value>::type* = nullptr>
  bool Equals(const T& other) const;

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

  Tag which() const {
    return tag_;
  }

  bool is_added() const { return tag_ == Tag::kAdded; }
  const BookmarkNodeCreatedPtr& get_added() const {
    CHECK(tag_ == Tag::kAdded);
    return data_.added;
  }
  BookmarkNodeCreatedPtr& get_added() {
    CHECK(tag_ == Tag::kAdded);
    return data_.added;
  }
  void set_added(BookmarkNodeCreatedPtr added);

  bool is_removed() const { return tag_ == Tag::kRemoved; }
  const BookmarkNodeRemovedPtr& get_removed() const {
    CHECK(tag_ == Tag::kRemoved);
    return data_.removed;
  }
  BookmarkNodeRemovedPtr& get_removed() {
    CHECK(tag_ == Tag::kRemoved);
    return data_.removed;
  }
  void set_removed(BookmarkNodeRemovedPtr removed);

  bool is_moved() const { return tag_ == Tag::kMoved; }
  const BookmarkNodeMovedPtr& get_moved() const {
    CHECK(tag_ == Tag::kMoved);
    return data_.moved;
  }
  BookmarkNodeMovedPtr& get_moved() {
    CHECK(tag_ == Tag::kMoved);
    return data_.moved;
  }
  void set_moved(BookmarkNodeMovedPtr moved);

  bool is_changed() const { return tag_ == Tag::kChanged; }
  const BookmarkNodeChangedPtr& get_changed() const {
    CHECK(tag_ == Tag::kChanged);
    return data_.changed;
  }
  BookmarkNodeChangedPtr& get_changed() {
    CHECK(tag_ == Tag::kChanged);
    return data_.changed;
  }
  void set_changed(BookmarkNodeChangedPtr changed);

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

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    return mojo::internal::DeserializeImpl<BookmarksEvent::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::kAdded)>,
        BookmarkNodeCreatedPtr value);
    Union_(
        std::in_place_index_t<static_cast<size_t>(Tag::kRemoved)>,
        BookmarkNodeRemovedPtr value);
    Union_(
        std::in_place_index_t<static_cast<size_t>(Tag::kMoved)>,
        BookmarkNodeMovedPtr value);
    Union_(
        std::in_place_index_t<static_cast<size_t>(Tag::kChanged)>,
        BookmarkNodeChangedPtr value);
    // The contents of the union are explicitly destroyed by `DestroyActive()`.
    ~Union_() {}

    BookmarkNodeCreatedPtr added;
    BookmarkNodeRemovedPtr removed;
    BookmarkNodeMovedPtr moved;
    BookmarkNodeChangedPtr changed;
  };

  BookmarksEvent(
      std::in_place_index_t<static_cast<size_t>(Tag::kAdded)>,
      BookmarkNodeCreatedPtr value);
  BookmarksEvent(
      std::in_place_index_t<static_cast<size_t>(Tag::kRemoved)>,
      BookmarkNodeRemovedPtr value);
  BookmarksEvent(
      std::in_place_index_t<static_cast<size_t>(Tag::kMoved)>,
      BookmarkNodeMovedPtr value);
  BookmarksEvent(
      std::in_place_index_t<static_cast<size_t>(Tag::kChanged)>,
      BookmarkNodeChangedPtr value);

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

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



class  BookmarksService_GetBookmarks_ResponseParam_Result {
 public:
  using DataView = BookmarksService_GetBookmarks_ResponseParam_ResultDataView;
  using Data_ = internal::BookmarksService_GetBookmarks_ResponseParam_Result_Data;
  using Tag = Data_::BookmarksService_GetBookmarks_ResponseParam_Result_Tag;

  template <typename... Args>
  static BookmarksService_GetBookmarks_ResponseParam_ResultPtr 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 |success|.
  static BookmarksService_GetBookmarks_ResponseParam_ResultPtr NewSuccess(
      BookmarksSnapshotPtr value);
  // Construct an instance holding |failure|.
  static BookmarksService_GetBookmarks_ResponseParam_ResultPtr NewFailure(
      ::mojo_base::mojom::ErrorPtr value);

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

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

  // Delete the copy constructor and copy assignment operators because `data_`
  // contains raw pointers that must not be copied.
  BookmarksService_GetBookmarks_ResponseParam_Result(const BookmarksService_GetBookmarks_ResponseParam_Result& other) = delete;
  BookmarksService_GetBookmarks_ResponseParam_Result& operator=(const BookmarksService_GetBookmarks_ResponseParam_Result& 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 = BookmarksService_GetBookmarks_ResponseParam_ResultPtr>
  BookmarksService_GetBookmarks_ResponseParam_ResultPtr 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, BookmarksService_GetBookmarks_ResponseParam_Result>::value>::type* = nullptr>
  bool Equals(const T& other) const;

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

  Tag which() const {
    return tag_;
  }

  bool is_success() const { return tag_ == Tag::kSuccess; }
  const BookmarksSnapshotPtr& get_success() const {
    CHECK(tag_ == Tag::kSuccess);
    return data_.success;
  }
  BookmarksSnapshotPtr& get_success() {
    CHECK(tag_ == Tag::kSuccess);
    return data_.success;
  }
  void set_success(BookmarksSnapshotPtr success);

  bool is_failure() const { return tag_ == Tag::kFailure; }
  const ::mojo_base::mojom::ErrorPtr& get_failure() const {
    CHECK(tag_ == Tag::kFailure);
    return data_.failure;
  }
  ::mojo_base::mojom::ErrorPtr& get_failure() {
    CHECK(tag_ == Tag::kFailure);
    return data_.failure;
  }
  void set_failure(::mojo_base::mojom::ErrorPtr failure);

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

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    return mojo::internal::DeserializeImpl<BookmarksService_GetBookmarks_ResponseParam_Result::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::kSuccess)>,
        BookmarksSnapshotPtr value);
    Union_(
        std::in_place_index_t<static_cast<size_t>(Tag::kFailure)>,
        ::mojo_base::mojom::ErrorPtr value);
    // The contents of the union are explicitly destroyed by `DestroyActive()`.
    ~Union_() {}

    BookmarksSnapshotPtr success;
    ::mojo_base::mojom::ErrorPtr failure;
  };

  BookmarksService_GetBookmarks_ResponseParam_Result(
      std::in_place_index_t<static_cast<size_t>(Tag::kSuccess)>,
      BookmarksSnapshotPtr value);
  BookmarksService_GetBookmarks_ResponseParam_Result(
      std::in_place_index_t<static_cast<size_t>(Tag::kFailure)>,
      ::mojo_base::mojom::ErrorPtr value);

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

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



class  BookmarksService_GetBookmark_ResponseParam_Result {
 public:
  using DataView = BookmarksService_GetBookmark_ResponseParam_ResultDataView;
  using Data_ = internal::BookmarksService_GetBookmark_ResponseParam_Result_Data;
  using Tag = Data_::BookmarksService_GetBookmark_ResponseParam_Result_Tag;

  template <typename... Args>
  static BookmarksService_GetBookmark_ResponseParam_ResultPtr 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 |success|.
  static BookmarksService_GetBookmark_ResponseParam_ResultPtr NewSuccess(
      BookmarkNodePtr value);
  // Construct an instance holding |failure|.
  static BookmarksService_GetBookmark_ResponseParam_ResultPtr NewFailure(
      ::mojo_base::mojom::ErrorPtr value);

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

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

  // Delete the copy constructor and copy assignment operators because `data_`
  // contains raw pointers that must not be copied.
  BookmarksService_GetBookmark_ResponseParam_Result(const BookmarksService_GetBookmark_ResponseParam_Result& other) = delete;
  BookmarksService_GetBookmark_ResponseParam_Result& operator=(const BookmarksService_GetBookmark_ResponseParam_Result& 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 = BookmarksService_GetBookmark_ResponseParam_ResultPtr>
  BookmarksService_GetBookmark_ResponseParam_ResultPtr 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, BookmarksService_GetBookmark_ResponseParam_Result>::value>::type* = nullptr>
  bool Equals(const T& other) const;

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

  Tag which() const {
    return tag_;
  }

  bool is_success() const { return tag_ == Tag::kSuccess; }
  const BookmarkNodePtr& get_success() const {
    CHECK(tag_ == Tag::kSuccess);
    return data_.success;
  }
  BookmarkNodePtr& get_success() {
    CHECK(tag_ == Tag::kSuccess);
    return data_.success;
  }
  void set_success(BookmarkNodePtr success);

  bool is_failure() const { return tag_ == Tag::kFailure; }
  const ::mojo_base::mojom::ErrorPtr& get_failure() const {
    CHECK(tag_ == Tag::kFailure);
    return data_.failure;
  }
  ::mojo_base::mojom::ErrorPtr& get_failure() {
    CHECK(tag_ == Tag::kFailure);
    return data_.failure;
  }
  void set_failure(::mojo_base::mojom::ErrorPtr failure);

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

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    return mojo::internal::DeserializeImpl<BookmarksService_GetBookmark_ResponseParam_Result::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::kSuccess)>,
        BookmarkNodePtr value);
    Union_(
        std::in_place_index_t<static_cast<size_t>(Tag::kFailure)>,
        ::mojo_base::mojom::ErrorPtr value);
    // The contents of the union are explicitly destroyed by `DestroyActive()`.
    ~Union_() {}

    BookmarkNodePtr success;
    ::mojo_base::mojom::ErrorPtr failure;
  };

  BookmarksService_GetBookmark_ResponseParam_Result(
      std::in_place_index_t<static_cast<size_t>(Tag::kSuccess)>,
      BookmarkNodePtr value);
  BookmarksService_GetBookmark_ResponseParam_Result(
      std::in_place_index_t<static_cast<size_t>(Tag::kFailure)>,
      ::mojo_base::mojom::ErrorPtr value);

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

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



class  BookmarksService_CreateBookmarkNode_ResponseParam_Result {
 public:
  using DataView = BookmarksService_CreateBookmarkNode_ResponseParam_ResultDataView;
  using Data_ = internal::BookmarksService_CreateBookmarkNode_ResponseParam_Result_Data;
  using Tag = Data_::BookmarksService_CreateBookmarkNode_ResponseParam_Result_Tag;

  template <typename... Args>
  static BookmarksService_CreateBookmarkNode_ResponseParam_ResultPtr 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 |success|.
  static BookmarksService_CreateBookmarkNode_ResponseParam_ResultPtr NewSuccess(
      BookmarkNodePtr value);
  // Construct an instance holding |failure|.
  static BookmarksService_CreateBookmarkNode_ResponseParam_ResultPtr NewFailure(
      ::mojo_base::mojom::ErrorPtr value);

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

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

  // Delete the copy constructor and copy assignment operators because `data_`
  // contains raw pointers that must not be copied.
  BookmarksService_CreateBookmarkNode_ResponseParam_Result(const BookmarksService_CreateBookmarkNode_ResponseParam_Result& other) = delete;
  BookmarksService_CreateBookmarkNode_ResponseParam_Result& operator=(const BookmarksService_CreateBookmarkNode_ResponseParam_Result& 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 = BookmarksService_CreateBookmarkNode_ResponseParam_ResultPtr>
  BookmarksService_CreateBookmarkNode_ResponseParam_ResultPtr 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, BookmarksService_CreateBookmarkNode_ResponseParam_Result>::value>::type* = nullptr>
  bool Equals(const T& other) const;

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

  Tag which() const {
    return tag_;
  }

  bool is_success() const { return tag_ == Tag::kSuccess; }
  const BookmarkNodePtr& get_success() const {
    CHECK(tag_ == Tag::kSuccess);
    return data_.success;
  }
  BookmarkNodePtr& get_success() {
    CHECK(tag_ == Tag::kSuccess);
    return data_.success;
  }
  void set_success(BookmarkNodePtr success);

  bool is_failure() const { return tag_ == Tag::kFailure; }
  const ::mojo_base::mojom::ErrorPtr& get_failure() const {
    CHECK(tag_ == Tag::kFailure);
    return data_.failure;
  }
  ::mojo_base::mojom::ErrorPtr& get_failure() {
    CHECK(tag_ == Tag::kFailure);
    return data_.failure;
  }
  void set_failure(::mojo_base::mojom::ErrorPtr failure);

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

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    return mojo::internal::DeserializeImpl<BookmarksService_CreateBookmarkNode_ResponseParam_Result::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::kSuccess)>,
        BookmarkNodePtr value);
    Union_(
        std::in_place_index_t<static_cast<size_t>(Tag::kFailure)>,
        ::mojo_base::mojom::ErrorPtr value);
    // The contents of the union are explicitly destroyed by `DestroyActive()`.
    ~Union_() {}

    BookmarkNodePtr success;
    ::mojo_base::mojom::ErrorPtr failure;
  };

  BookmarksService_CreateBookmarkNode_ResponseParam_Result(
      std::in_place_index_t<static_cast<size_t>(Tag::kSuccess)>,
      BookmarkNodePtr value);
  BookmarksService_CreateBookmarkNode_ResponseParam_Result(
      std::in_place_index_t<static_cast<size_t>(Tag::kFailure)>,
      ::mojo_base::mojom::ErrorPtr value);

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

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



class  BookmarksService_UpdateBookmarkNode_ResponseParam_Result {
 public:
  using DataView = BookmarksService_UpdateBookmarkNode_ResponseParam_ResultDataView;
  using Data_ = internal::BookmarksService_UpdateBookmarkNode_ResponseParam_Result_Data;
  using Tag = Data_::BookmarksService_UpdateBookmarkNode_ResponseParam_Result_Tag;

  template <typename... Args>
  static BookmarksService_UpdateBookmarkNode_ResponseParam_ResultPtr 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 |success|.
  static BookmarksService_UpdateBookmarkNode_ResponseParam_ResultPtr NewSuccess(
      BookmarkNodePtr value);
  // Construct an instance holding |failure|.
  static BookmarksService_UpdateBookmarkNode_ResponseParam_ResultPtr NewFailure(
      ::mojo_base::mojom::ErrorPtr value);

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

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

  // Delete the copy constructor and copy assignment operators because `data_`
  // contains raw pointers that must not be copied.
  BookmarksService_UpdateBookmarkNode_ResponseParam_Result(const BookmarksService_UpdateBookmarkNode_ResponseParam_Result& other) = delete;
  BookmarksService_UpdateBookmarkNode_ResponseParam_Result& operator=(const BookmarksService_UpdateBookmarkNode_ResponseParam_Result& 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 = BookmarksService_UpdateBookmarkNode_ResponseParam_ResultPtr>
  BookmarksService_UpdateBookmarkNode_ResponseParam_ResultPtr 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, BookmarksService_UpdateBookmarkNode_ResponseParam_Result>::value>::type* = nullptr>
  bool Equals(const T& other) const;

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

  Tag which() const {
    return tag_;
  }

  bool is_success() const { return tag_ == Tag::kSuccess; }
  const BookmarkNodePtr& get_success() const {
    CHECK(tag_ == Tag::kSuccess);
    return data_.success;
  }
  BookmarkNodePtr& get_success() {
    CHECK(tag_ == Tag::kSuccess);
    return data_.success;
  }
  void set_success(BookmarkNodePtr success);

  bool is_failure() const { return tag_ == Tag::kFailure; }
  const ::mojo_base::mojom::ErrorPtr& get_failure() const {
    CHECK(tag_ == Tag::kFailure);
    return data_.failure;
  }
  ::mojo_base::mojom::ErrorPtr& get_failure() {
    CHECK(tag_ == Tag::kFailure);
    return data_.failure;
  }
  void set_failure(::mojo_base::mojom::ErrorPtr failure);

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

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    return mojo::internal::DeserializeImpl<BookmarksService_UpdateBookmarkNode_ResponseParam_Result::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::kSuccess)>,
        BookmarkNodePtr value);
    Union_(
        std::in_place_index_t<static_cast<size_t>(Tag::kFailure)>,
        ::mojo_base::mojom::ErrorPtr value);
    // The contents of the union are explicitly destroyed by `DestroyActive()`.
    ~Union_() {}

    BookmarkNodePtr success;
    ::mojo_base::mojom::ErrorPtr failure;
  };

  BookmarksService_UpdateBookmarkNode_ResponseParam_Result(
      std::in_place_index_t<static_cast<size_t>(Tag::kSuccess)>,
      BookmarkNodePtr value);
  BookmarksService_UpdateBookmarkNode_ResponseParam_Result(
      std::in_place_index_t<static_cast<size_t>(Tag::kFailure)>,
      ::mojo_base::mojom::ErrorPtr value);

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

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



class  BookmarksService_MoveBookmarkNode_ResponseParam_Result {
 public:
  using DataView = BookmarksService_MoveBookmarkNode_ResponseParam_ResultDataView;
  using Data_ = internal::BookmarksService_MoveBookmarkNode_ResponseParam_Result_Data;
  using Tag = Data_::BookmarksService_MoveBookmarkNode_ResponseParam_Result_Tag;

  template <typename... Args>
  static BookmarksService_MoveBookmarkNode_ResponseParam_ResultPtr 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 |success|.
  static BookmarksService_MoveBookmarkNode_ResponseParam_ResultPtr NewSuccess(
      const ::std::monostate& value);
  // Construct an instance holding |failure|.
  static BookmarksService_MoveBookmarkNode_ResponseParam_ResultPtr NewFailure(
      ::mojo_base::mojom::ErrorPtr value);

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

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

  // Delete the copy constructor and copy assignment operators because `data_`
  // contains raw pointers that must not be copied.
  BookmarksService_MoveBookmarkNode_ResponseParam_Result(const BookmarksService_MoveBookmarkNode_ResponseParam_Result& other) = delete;
  BookmarksService_MoveBookmarkNode_ResponseParam_Result& operator=(const BookmarksService_MoveBookmarkNode_ResponseParam_Result& 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 = BookmarksService_MoveBookmarkNode_ResponseParam_ResultPtr>
  BookmarksService_MoveBookmarkNode_ResponseParam_ResultPtr 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, BookmarksService_MoveBookmarkNode_ResponseParam_Result>::value>::type* = nullptr>
  bool Equals(const T& other) const;

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

  Tag which() const {
    return tag_;
  }

  bool is_success() const { return tag_ == Tag::kSuccess; }
  const ::std::monostate& get_success() const {
    CHECK(tag_ == Tag::kSuccess);
    return data_.success;
  }
  ::std::monostate& get_success() {
    CHECK(tag_ == Tag::kSuccess);
    return data_.success;
  }
  void set_success(const ::std::monostate& success);

  bool is_failure() const { return tag_ == Tag::kFailure; }
  const ::mojo_base::mojom::ErrorPtr& get_failure() const {
    CHECK(tag_ == Tag::kFailure);
    return data_.failure;
  }
  ::mojo_base::mojom::ErrorPtr& get_failure() {
    CHECK(tag_ == Tag::kFailure);
    return data_.failure;
  }
  void set_failure(::mojo_base::mojom::ErrorPtr failure);

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

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    return mojo::internal::DeserializeImpl<BookmarksService_MoveBookmarkNode_ResponseParam_Result::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::kSuccess)>,
        const ::std::monostate& value);
    Union_(
        std::in_place_index_t<static_cast<size_t>(Tag::kFailure)>,
        ::mojo_base::mojom::ErrorPtr value);
    // The contents of the union are explicitly destroyed by `DestroyActive()`.
    ~Union_() {}

    ::std::monostate success;
    ::mojo_base::mojom::ErrorPtr failure;
  };

  BookmarksService_MoveBookmarkNode_ResponseParam_Result(
      std::in_place_index_t<static_cast<size_t>(Tag::kSuccess)>,
      const ::std::monostate& value);
  BookmarksService_MoveBookmarkNode_ResponseParam_Result(
      std::in_place_index_t<static_cast<size_t>(Tag::kFailure)>,
      ::mojo_base::mojom::ErrorPtr value);

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

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



class  BookmarksService_DeleteBookmarkNodes_ResponseParam_Result {
 public:
  using DataView = BookmarksService_DeleteBookmarkNodes_ResponseParam_ResultDataView;
  using Data_ = internal::BookmarksService_DeleteBookmarkNodes_ResponseParam_Result_Data;
  using Tag = Data_::BookmarksService_DeleteBookmarkNodes_ResponseParam_Result_Tag;

  template <typename... Args>
  static BookmarksService_DeleteBookmarkNodes_ResponseParam_ResultPtr 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 |success|.
  static BookmarksService_DeleteBookmarkNodes_ResponseParam_ResultPtr NewSuccess(
      const ::std::monostate& value);
  // Construct an instance holding |failure|.
  static BookmarksService_DeleteBookmarkNodes_ResponseParam_ResultPtr NewFailure(
      ::mojo_base::mojom::ErrorPtr value);

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

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

  // Delete the copy constructor and copy assignment operators because `data_`
  // contains raw pointers that must not be copied.
  BookmarksService_DeleteBookmarkNodes_ResponseParam_Result(const BookmarksService_DeleteBookmarkNodes_ResponseParam_Result& other) = delete;
  BookmarksService_DeleteBookmarkNodes_ResponseParam_Result& operator=(const BookmarksService_DeleteBookmarkNodes_ResponseParam_Result& 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 = BookmarksService_DeleteBookmarkNodes_ResponseParam_ResultPtr>
  BookmarksService_DeleteBookmarkNodes_ResponseParam_ResultPtr 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, BookmarksService_DeleteBookmarkNodes_ResponseParam_Result>::value>::type* = nullptr>
  bool Equals(const T& other) const;

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

  Tag which() const {
    return tag_;
  }

  bool is_success() const { return tag_ == Tag::kSuccess; }
  const ::std::monostate& get_success() const {
    CHECK(tag_ == Tag::kSuccess);
    return data_.success;
  }
  ::std::monostate& get_success() {
    CHECK(tag_ == Tag::kSuccess);
    return data_.success;
  }
  void set_success(const ::std::monostate& success);

  bool is_failure() const { return tag_ == Tag::kFailure; }
  const ::mojo_base::mojom::ErrorPtr& get_failure() const {
    CHECK(tag_ == Tag::kFailure);
    return data_.failure;
  }
  ::mojo_base::mojom::ErrorPtr& get_failure() {
    CHECK(tag_ == Tag::kFailure);
    return data_.failure;
  }
  void set_failure(::mojo_base::mojom::ErrorPtr failure);

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

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    return mojo::internal::DeserializeImpl<BookmarksService_DeleteBookmarkNodes_ResponseParam_Result::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::kSuccess)>,
        const ::std::monostate& value);
    Union_(
        std::in_place_index_t<static_cast<size_t>(Tag::kFailure)>,
        ::mojo_base::mojom::ErrorPtr value);
    // The contents of the union are explicitly destroyed by `DestroyActive()`.
    ~Union_() {}

    ::std::monostate success;
    ::mojo_base::mojom::ErrorPtr failure;
  };

  BookmarksService_DeleteBookmarkNodes_ResponseParam_Result(
      std::in_place_index_t<static_cast<size_t>(Tag::kSuccess)>,
      const ::std::monostate& value);
  BookmarksService_DeleteBookmarkNodes_ResponseParam_Result(
      std::in_place_index_t<static_cast<size_t>(Tag::kFailure)>,
      ::mojo_base::mojom::ErrorPtr value);

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

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






class  RootNode {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<RootNode, T>::value>;
  using DataView = RootNodeDataView;
  using Data_ = internal::RootNode_Data;

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

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

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


  RootNode();

  RootNode(
      const ::base::Uuid& id,
      std::vector<FolderPtr> children);

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

  ~RootNode();

  // 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 = RootNodePtr>
  RootNodePtr 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, RootNode::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

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

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

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

  template <typename UserType>
  static std::vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        RootNode::DataView, std::vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        RootNode::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::RootNode_UnserializedMessageContext<
            UserType, RootNode::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<RootNode::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(base::span<const uint8_t> input,
                          UserType* output) {
    return RootNode::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::RootNode_UnserializedMessageContext<
            UserType, RootNode::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<RootNode::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
  ::base::Uuid id;
  
  std::vector<FolderPtr> children;

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

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

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

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





class  Url {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<Url, T>::value>;
  using DataView = UrlDataView;
  using Data_ = internal::Url_Data;

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

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

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


  Url();

  Url(
      const std::optional<::base::Uuid>& id,
      LegacyFieldsPtr legacy,
      const std::string& title,
      const ::GURL& url,
      const std::optional<::GURL>& favicon_url,
      bool is_synced);

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

  ~Url();

  // 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 = UrlPtr>
  UrlPtr 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, Url::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

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

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

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

  template <typename UserType>
  static std::vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        Url::DataView, std::vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        Url::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::Url_UnserializedMessageContext<
            UserType, Url::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<Url::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(base::span<const uint8_t> input,
                          UserType* output) {
    return Url::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::Url_UnserializedMessageContext<
            UserType, Url::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<Url::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
  std::optional<::base::Uuid> id;
  
  LegacyFieldsPtr legacy;
  
  std::string title;
  
  ::GURL url;
  
  std::optional<::GURL> favicon_url;
  
  bool is_synced;

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

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

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

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





class  Folder {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<Folder, T>::value>;
  using DataView = FolderDataView;
  using Data_ = internal::Folder_Data;

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

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

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


  Folder();

  Folder(
      const std::optional<::base::Uuid>& id,
      LegacyFieldsPtr legacy,
      const std::string& title,
      std::vector<BookmarkNodePtr> children,
      std::optional<PermanentFolderType> permanent_folder_type,
      bool is_synced);

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

  ~Folder();

  // 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 = FolderPtr>
  FolderPtr 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, Folder::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

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

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

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

  template <typename UserType>
  static std::vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        Folder::DataView, std::vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        Folder::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::Folder_UnserializedMessageContext<
            UserType, Folder::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<Folder::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(base::span<const uint8_t> input,
                          UserType* output) {
    return Folder::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::Folder_UnserializedMessageContext<
            UserType, Folder::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<Folder::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
  std::optional<::base::Uuid> id;
  
  LegacyFieldsPtr legacy;
  
  std::string title;
  
  std::vector<BookmarkNodePtr> children;
  
  std::optional<PermanentFolderType> permanent_folder_type;
  
  bool is_synced;

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

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

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

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





class  BookmarksSnapshot {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<BookmarksSnapshot, T>::value>;
  using DataView = BookmarksSnapshotDataView;
  using Data_ = internal::BookmarksSnapshot_Data;

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

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

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


  BookmarksSnapshot();

  BookmarksSnapshot(
      RootNodePtr root,
      ::mojo::PendingAssociatedReceiver<BookmarksObserver> stream);

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

  ~BookmarksSnapshot();

  // 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 = BookmarksSnapshotPtr>
  BookmarksSnapshotPtr 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, BookmarksSnapshot::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

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

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

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        BookmarksSnapshot::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::BookmarksSnapshot_UnserializedMessageContext<
            UserType, BookmarksSnapshot::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<BookmarksSnapshot::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(base::span<const uint8_t> input,
                          UserType* output) {
    return BookmarksSnapshot::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::BookmarksSnapshot_UnserializedMessageContext<
            UserType, BookmarksSnapshot::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<BookmarksSnapshot::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
  RootNodePtr root;
  
  ::mojo::PendingAssociatedReceiver<BookmarksObserver> stream;

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

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

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

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





class  BookmarkNodeCreated {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<BookmarkNodeCreated, T>::value>;
  using DataView = BookmarkNodeCreatedDataView;
  using Data_ = internal::BookmarkNodeCreated_Data;

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

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

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


  BookmarkNodeCreated();

  BookmarkNodeCreated(
      const ::base::Uuid& parent_id,
      int32_t index,
      BookmarkNodePtr node);

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

  ~BookmarkNodeCreated();

  // 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 = BookmarkNodeCreatedPtr>
  BookmarkNodeCreatedPtr 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, BookmarkNodeCreated::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

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

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

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

  template <typename UserType>
  static std::vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        BookmarkNodeCreated::DataView, std::vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        BookmarkNodeCreated::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::BookmarkNodeCreated_UnserializedMessageContext<
            UserType, BookmarkNodeCreated::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<BookmarkNodeCreated::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(base::span<const uint8_t> input,
                          UserType* output) {
    return BookmarkNodeCreated::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::BookmarkNodeCreated_UnserializedMessageContext<
            UserType, BookmarkNodeCreated::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<BookmarkNodeCreated::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
  ::base::Uuid parent_id;
  
  int32_t index;
  
  BookmarkNodePtr node;

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

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

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

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





class  BookmarkNodeRemoved {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<BookmarkNodeRemoved, T>::value>;
  using DataView = BookmarkNodeRemovedDataView;
  using Data_ = internal::BookmarkNodeRemoved_Data;

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

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

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


  BookmarkNodeRemoved();

  explicit BookmarkNodeRemoved(
      const ::base::Uuid& id);


  ~BookmarkNodeRemoved();

  // 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 = BookmarkNodeRemovedPtr>
  BookmarkNodeRemovedPtr 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, BookmarkNodeRemoved::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

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

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

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

  template <typename UserType>
  static std::vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        BookmarkNodeRemoved::DataView, std::vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        BookmarkNodeRemoved::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::BookmarkNodeRemoved_UnserializedMessageContext<
            UserType, BookmarkNodeRemoved::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<BookmarkNodeRemoved::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(base::span<const uint8_t> input,
                          UserType* output) {
    return BookmarkNodeRemoved::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::BookmarkNodeRemoved_UnserializedMessageContext<
            UserType, BookmarkNodeRemoved::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<BookmarkNodeRemoved::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

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

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

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

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





class  BookmarkNodeMoved {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<BookmarkNodeMoved, T>::value>;
  using DataView = BookmarkNodeMovedDataView;
  using Data_ = internal::BookmarkNodeMoved_Data;

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

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

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


  BookmarkNodeMoved();

  BookmarkNodeMoved(
      const ::base::Uuid& old_parent_id,
      int32_t old_index,
      const ::base::Uuid& new_parent_id,
      int32_t new_index);


  ~BookmarkNodeMoved();

  // 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 = BookmarkNodeMovedPtr>
  BookmarkNodeMovedPtr 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, BookmarkNodeMoved::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

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

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

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

  template <typename UserType>
  static std::vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        BookmarkNodeMoved::DataView, std::vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        BookmarkNodeMoved::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::BookmarkNodeMoved_UnserializedMessageContext<
            UserType, BookmarkNodeMoved::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<BookmarkNodeMoved::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(base::span<const uint8_t> input,
                          UserType* output) {
    return BookmarkNodeMoved::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::BookmarkNodeMoved_UnserializedMessageContext<
            UserType, BookmarkNodeMoved::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<BookmarkNodeMoved::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
  ::base::Uuid old_parent_id;
  
  int32_t old_index;
  
  ::base::Uuid new_parent_id;
  
  int32_t new_index;

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

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

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

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





class  BookmarkNodeChanged {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<BookmarkNodeChanged, T>::value>;
  using DataView = BookmarkNodeChangedDataView;
  using Data_ = internal::BookmarkNodeChanged_Data;

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

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

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


  BookmarkNodeChanged();

  explicit BookmarkNodeChanged(
      BookmarkNodePtr node);

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

  ~BookmarkNodeChanged();

  // 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 = BookmarkNodeChangedPtr>
  BookmarkNodeChangedPtr 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, BookmarkNodeChanged::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

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

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

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

  template <typename UserType>
  static std::vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        BookmarkNodeChanged::DataView, std::vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        BookmarkNodeChanged::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::BookmarkNodeChanged_UnserializedMessageContext<
            UserType, BookmarkNodeChanged::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<BookmarkNodeChanged::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(base::span<const uint8_t> input,
                          UserType* output) {
    return BookmarkNodeChanged::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::BookmarkNodeChanged_UnserializedMessageContext<
            UserType, BookmarkNodeChanged::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<BookmarkNodeChanged::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
  BookmarkNodePtr node;

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

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

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

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

template <typename UnionPtrType>
BookmarkNodePtr BookmarkNode::Clone() const {
  switch (tag_) {
    case Tag::kUrl:
      return NewUrl(
          mojo::Clone(data_.url));
    case Tag::kFolder:
      return NewFolder(
          mojo::Clone(data_.folder));
  }
  return nullptr;
}

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

  switch (tag_) {
    case Tag::kUrl:
      return mojo::Equals(data_.url, other.data_.url);
    case Tag::kFolder:
      return mojo::Equals(data_.folder, other.data_.folder);
  }

  return false;
}
template <typename UnionPtrType>
BookmarksEventPtr BookmarksEvent::Clone() const {
  switch (tag_) {
    case Tag::kAdded:
      return NewAdded(
          mojo::Clone(data_.added));
    case Tag::kRemoved:
      return NewRemoved(
          mojo::Clone(data_.removed));
    case Tag::kMoved:
      return NewMoved(
          mojo::Clone(data_.moved));
    case Tag::kChanged:
      return NewChanged(
          mojo::Clone(data_.changed));
  }
  return nullptr;
}

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

  switch (tag_) {
    case Tag::kAdded:
      return mojo::Equals(data_.added, other.data_.added);
    case Tag::kRemoved:
      return mojo::Equals(data_.removed, other.data_.removed);
    case Tag::kMoved:
      return mojo::Equals(data_.moved, other.data_.moved);
    case Tag::kChanged:
      return mojo::Equals(data_.changed, other.data_.changed);
  }

  return false;
}
template <typename UnionPtrType>
BookmarksService_GetBookmarks_ResponseParam_ResultPtr BookmarksService_GetBookmarks_ResponseParam_Result::Clone() const {
  switch (tag_) {
    case Tag::kSuccess:
      return NewSuccess(
          mojo::Clone(data_.success));
    case Tag::kFailure:
      return NewFailure(
          mojo::Clone(data_.failure));
  }
  return nullptr;
}

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

  switch (tag_) {
    case Tag::kSuccess:
      return mojo::Equals(data_.success, other.data_.success);
    case Tag::kFailure:
      return mojo::Equals(data_.failure, other.data_.failure);
  }

  return false;
}
template <typename UnionPtrType>
BookmarksService_GetBookmark_ResponseParam_ResultPtr BookmarksService_GetBookmark_ResponseParam_Result::Clone() const {
  switch (tag_) {
    case Tag::kSuccess:
      return NewSuccess(
          mojo::Clone(data_.success));
    case Tag::kFailure:
      return NewFailure(
          mojo::Clone(data_.failure));
  }
  return nullptr;
}

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

  switch (tag_) {
    case Tag::kSuccess:
      return mojo::Equals(data_.success, other.data_.success);
    case Tag::kFailure:
      return mojo::Equals(data_.failure, other.data_.failure);
  }

  return false;
}
template <typename UnionPtrType>
BookmarksService_CreateBookmarkNode_ResponseParam_ResultPtr BookmarksService_CreateBookmarkNode_ResponseParam_Result::Clone() const {
  switch (tag_) {
    case Tag::kSuccess:
      return NewSuccess(
          mojo::Clone(data_.success));
    case Tag::kFailure:
      return NewFailure(
          mojo::Clone(data_.failure));
  }
  return nullptr;
}

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

  switch (tag_) {
    case Tag::kSuccess:
      return mojo::Equals(data_.success, other.data_.success);
    case Tag::kFailure:
      return mojo::Equals(data_.failure, other.data_.failure);
  }

  return false;
}
template <typename UnionPtrType>
BookmarksService_UpdateBookmarkNode_ResponseParam_ResultPtr BookmarksService_UpdateBookmarkNode_ResponseParam_Result::Clone() const {
  switch (tag_) {
    case Tag::kSuccess:
      return NewSuccess(
          mojo::Clone(data_.success));
    case Tag::kFailure:
      return NewFailure(
          mojo::Clone(data_.failure));
  }
  return nullptr;
}

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

  switch (tag_) {
    case Tag::kSuccess:
      return mojo::Equals(data_.success, other.data_.success);
    case Tag::kFailure:
      return mojo::Equals(data_.failure, other.data_.failure);
  }

  return false;
}
template <typename UnionPtrType>
BookmarksService_MoveBookmarkNode_ResponseParam_ResultPtr BookmarksService_MoveBookmarkNode_ResponseParam_Result::Clone() const {
  switch (tag_) {
    case Tag::kSuccess:
      return NewSuccess(
          mojo::Clone(data_.success));
    case Tag::kFailure:
      return NewFailure(
          mojo::Clone(data_.failure));
  }
  return nullptr;
}

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

  switch (tag_) {
    case Tag::kSuccess:
      return mojo::Equals(data_.success, other.data_.success);
    case Tag::kFailure:
      return mojo::Equals(data_.failure, other.data_.failure);
  }

  return false;
}
template <typename UnionPtrType>
BookmarksService_DeleteBookmarkNodes_ResponseParam_ResultPtr BookmarksService_DeleteBookmarkNodes_ResponseParam_Result::Clone() const {
  switch (tag_) {
    case Tag::kSuccess:
      return NewSuccess(
          mojo::Clone(data_.success));
    case Tag::kFailure:
      return NewFailure(
          mojo::Clone(data_.failure));
  }
  return nullptr;
}

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

  switch (tag_) {
    case Tag::kSuccess:
      return mojo::Equals(data_.success, other.data_.success);
    case Tag::kFailure:
      return mojo::Equals(data_.failure, other.data_.failure);
  }

  return false;
}
template <typename StructPtrType>
LegacyFieldsPtr LegacyFields::Clone() const {
  return New(
      mojo::Clone(id)
  );
}

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

template <typename T, LegacyFields::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.id < rhs.id)
    return true;
  if (rhs.id < lhs.id)
    return false;
  return false;
}
template <typename StructPtrType>
RootNodePtr RootNode::Clone() const {
  return New(
      mojo::Clone(id),
      mojo::Clone(children)
  );
}

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

template <typename T, RootNode::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.children < rhs.children)
    return true;
  if (rhs.children < lhs.children)
    return false;
  return false;
}
template <typename StructPtrType>
UrlPtr Url::Clone() const {
  return New(
      mojo::Clone(id),
      mojo::Clone(legacy),
      mojo::Clone(title),
      mojo::Clone(url),
      mojo::Clone(favicon_url),
      mojo::Clone(is_synced)
  );
}

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

template <typename T, Url::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.legacy < rhs.legacy)
    return true;
  if (rhs.legacy < lhs.legacy)
    return false;
  if (lhs.title < rhs.title)
    return true;
  if (rhs.title < lhs.title)
    return false;
  if (lhs.url < rhs.url)
    return true;
  if (rhs.url < lhs.url)
    return false;
  if (lhs.favicon_url < rhs.favicon_url)
    return true;
  if (rhs.favicon_url < lhs.favicon_url)
    return false;
  if (lhs.is_synced < rhs.is_synced)
    return true;
  if (rhs.is_synced < lhs.is_synced)
    return false;
  return false;
}
template <typename StructPtrType>
FolderPtr Folder::Clone() const {
  return New(
      mojo::Clone(id),
      mojo::Clone(legacy),
      mojo::Clone(title),
      mojo::Clone(children),
      mojo::Clone(permanent_folder_type),
      mojo::Clone(is_synced)
  );
}

template <typename T, Folder::EnableIfSame<T>*>
bool Folder::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->id, other_struct.id))
    return false;
  if (!mojo::Equals(this->legacy, other_struct.legacy))
    return false;
  if (!mojo::Equals(this->title, other_struct.title))
    return false;
  if (!mojo::Equals(this->children, other_struct.children))
    return false;
  if (!mojo::Equals(this->permanent_folder_type, other_struct.permanent_folder_type))
    return false;
  if (!mojo::Equals(this->is_synced, other_struct.is_synced))
    return false;
  return true;
}

template <typename T, Folder::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.legacy < rhs.legacy)
    return true;
  if (rhs.legacy < lhs.legacy)
    return false;
  if (lhs.title < rhs.title)
    return true;
  if (rhs.title < lhs.title)
    return false;
  if (lhs.children < rhs.children)
    return true;
  if (rhs.children < lhs.children)
    return false;
  if (lhs.permanent_folder_type < rhs.permanent_folder_type)
    return true;
  if (rhs.permanent_folder_type < lhs.permanent_folder_type)
    return false;
  if (lhs.is_synced < rhs.is_synced)
    return true;
  if (rhs.is_synced < lhs.is_synced)
    return false;
  return false;
}
template <typename StructPtrType>
BookmarksSnapshotPtr BookmarksSnapshot::Clone() const {
  return New(
      mojo::Clone(root),
      mojo::Clone(stream)
  );
}

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

template <typename T, BookmarksSnapshot::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.root < rhs.root)
    return true;
  if (rhs.root < lhs.root)
    return false;
  if (lhs.stream < rhs.stream)
    return true;
  if (rhs.stream < lhs.stream)
    return false;
  return false;
}
template <typename StructPtrType>
BookmarkNodeCreatedPtr BookmarkNodeCreated::Clone() const {
  return New(
      mojo::Clone(parent_id),
      mojo::Clone(index),
      mojo::Clone(node)
  );
}

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

template <typename T, BookmarkNodeCreated::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.parent_id < rhs.parent_id)
    return true;
  if (rhs.parent_id < lhs.parent_id)
    return false;
  if (lhs.index < rhs.index)
    return true;
  if (rhs.index < lhs.index)
    return false;
  if (lhs.node < rhs.node)
    return true;
  if (rhs.node < lhs.node)
    return false;
  return false;
}
template <typename StructPtrType>
BookmarkNodeRemovedPtr BookmarkNodeRemoved::Clone() const {
  return New(
      mojo::Clone(id)
  );
}

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

template <typename T, BookmarkNodeRemoved::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.id < rhs.id)
    return true;
  if (rhs.id < lhs.id)
    return false;
  return false;
}
template <typename StructPtrType>
BookmarkNodeMovedPtr BookmarkNodeMoved::Clone() const {
  return New(
      mojo::Clone(old_parent_id),
      mojo::Clone(old_index),
      mojo::Clone(new_parent_id),
      mojo::Clone(new_index)
  );
}

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

template <typename T, BookmarkNodeMoved::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.old_parent_id < rhs.old_parent_id)
    return true;
  if (rhs.old_parent_id < lhs.old_parent_id)
    return false;
  if (lhs.old_index < rhs.old_index)
    return true;
  if (rhs.old_index < lhs.old_index)
    return false;
  if (lhs.new_parent_id < rhs.new_parent_id)
    return true;
  if (rhs.new_parent_id < lhs.new_parent_id)
    return false;
  if (lhs.new_index < rhs.new_index)
    return true;
  if (rhs.new_index < lhs.new_index)
    return false;
  return false;
}
template <typename StructPtrType>
BookmarkNodeChangedPtr BookmarkNodeChanged::Clone() const {
  return New(
      mojo::Clone(node)
  );
}

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

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


}  // bookmarks_api::mojom

namespace mojo {


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

  static decltype(::bookmarks_api::mojom::LegacyFields::id) id(
      const ::bookmarks_api::mojom::LegacyFieldsPtr& input) {
    return input->id;
  }

  static bool Read(::bookmarks_api::mojom::LegacyFields::DataView input, ::bookmarks_api::mojom::LegacyFieldsPtr* output);
};


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

  static const decltype(::bookmarks_api::mojom::RootNode::id)& id(
      const ::bookmarks_api::mojom::RootNodePtr& input) {
    return input->id;
  }

  static const decltype(::bookmarks_api::mojom::RootNode::children)& children(
      const ::bookmarks_api::mojom::RootNodePtr& input) {
    return input->children;
  }

  static bool Read(::bookmarks_api::mojom::RootNode::DataView input, ::bookmarks_api::mojom::RootNodePtr* output);
};


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

  static const decltype(::bookmarks_api::mojom::Url::id)& id(
      const ::bookmarks_api::mojom::UrlPtr& input) {
    return input->id;
  }

  static const decltype(::bookmarks_api::mojom::Url::legacy)& legacy(
      const ::bookmarks_api::mojom::UrlPtr& input) {
    return input->legacy;
  }

  static const decltype(::bookmarks_api::mojom::Url::title)& title(
      const ::bookmarks_api::mojom::UrlPtr& input) {
    return input->title;
  }

  static const decltype(::bookmarks_api::mojom::Url::url)& url(
      const ::bookmarks_api::mojom::UrlPtr& input) {
    return input->url;
  }

  static const decltype(::bookmarks_api::mojom::Url::favicon_url)& favicon_url(
      const ::bookmarks_api::mojom::UrlPtr& input) {
    return input->favicon_url;
  }

  static decltype(::bookmarks_api::mojom::Url::is_synced) is_synced(
      const ::bookmarks_api::mojom::UrlPtr& input) {
    return input->is_synced;
  }

  static bool Read(::bookmarks_api::mojom::Url::DataView input, ::bookmarks_api::mojom::UrlPtr* output);
};


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

  static const decltype(::bookmarks_api::mojom::Folder::id)& id(
      const ::bookmarks_api::mojom::FolderPtr& input) {
    return input->id;
  }

  static const decltype(::bookmarks_api::mojom::Folder::legacy)& legacy(
      const ::bookmarks_api::mojom::FolderPtr& input) {
    return input->legacy;
  }

  static const decltype(::bookmarks_api::mojom::Folder::title)& title(
      const ::bookmarks_api::mojom::FolderPtr& input) {
    return input->title;
  }

  static const decltype(::bookmarks_api::mojom::Folder::children)& children(
      const ::bookmarks_api::mojom::FolderPtr& input) {
    return input->children;
  }

  static decltype(::bookmarks_api::mojom::Folder::permanent_folder_type) permanent_folder_type(
      const ::bookmarks_api::mojom::FolderPtr& input) {
    return input->permanent_folder_type;
  }

  static decltype(::bookmarks_api::mojom::Folder::is_synced) is_synced(
      const ::bookmarks_api::mojom::FolderPtr& input) {
    return input->is_synced;
  }

  static bool Read(::bookmarks_api::mojom::Folder::DataView input, ::bookmarks_api::mojom::FolderPtr* output);
};


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

  static const decltype(::bookmarks_api::mojom::BookmarksSnapshot::root)& root(
      const ::bookmarks_api::mojom::BookmarksSnapshotPtr& input) {
    return input->root;
  }

  static  decltype(::bookmarks_api::mojom::BookmarksSnapshot::stream)& stream(
       ::bookmarks_api::mojom::BookmarksSnapshotPtr& input) {
    return input->stream;
  }

  static bool Read(::bookmarks_api::mojom::BookmarksSnapshot::DataView input, ::bookmarks_api::mojom::BookmarksSnapshotPtr* output);
};


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

  static const decltype(::bookmarks_api::mojom::BookmarkNodeCreated::parent_id)& parent_id(
      const ::bookmarks_api::mojom::BookmarkNodeCreatedPtr& input) {
    return input->parent_id;
  }

  static decltype(::bookmarks_api::mojom::BookmarkNodeCreated::index) index(
      const ::bookmarks_api::mojom::BookmarkNodeCreatedPtr& input) {
    return input->index;
  }

  static const decltype(::bookmarks_api::mojom::BookmarkNodeCreated::node)& node(
      const ::bookmarks_api::mojom::BookmarkNodeCreatedPtr& input) {
    return input->node;
  }

  static bool Read(::bookmarks_api::mojom::BookmarkNodeCreated::DataView input, ::bookmarks_api::mojom::BookmarkNodeCreatedPtr* output);
};


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

  static const decltype(::bookmarks_api::mojom::BookmarkNodeRemoved::id)& id(
      const ::bookmarks_api::mojom::BookmarkNodeRemovedPtr& input) {
    return input->id;
  }

  static bool Read(::bookmarks_api::mojom::BookmarkNodeRemoved::DataView input, ::bookmarks_api::mojom::BookmarkNodeRemovedPtr* output);
};


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

  static const decltype(::bookmarks_api::mojom::BookmarkNodeMoved::old_parent_id)& old_parent_id(
      const ::bookmarks_api::mojom::BookmarkNodeMovedPtr& input) {
    return input->old_parent_id;
  }

  static decltype(::bookmarks_api::mojom::BookmarkNodeMoved::old_index) old_index(
      const ::bookmarks_api::mojom::BookmarkNodeMovedPtr& input) {
    return input->old_index;
  }

  static const decltype(::bookmarks_api::mojom::BookmarkNodeMoved::new_parent_id)& new_parent_id(
      const ::bookmarks_api::mojom::BookmarkNodeMovedPtr& input) {
    return input->new_parent_id;
  }

  static decltype(::bookmarks_api::mojom::BookmarkNodeMoved::new_index) new_index(
      const ::bookmarks_api::mojom::BookmarkNodeMovedPtr& input) {
    return input->new_index;
  }

  static bool Read(::bookmarks_api::mojom::BookmarkNodeMoved::DataView input, ::bookmarks_api::mojom::BookmarkNodeMovedPtr* output);
};


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

  static const decltype(::bookmarks_api::mojom::BookmarkNodeChanged::node)& node(
      const ::bookmarks_api::mojom::BookmarkNodeChangedPtr& input) {
    return input->node;
  }

  static bool Read(::bookmarks_api::mojom::BookmarkNodeChanged::DataView input, ::bookmarks_api::mojom::BookmarkNodeChangedPtr* output);
};


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

  static ::bookmarks_api::mojom::BookmarkNode::Tag GetTag(const ::bookmarks_api::mojom::BookmarkNodePtr& input) {
    return input->which();
  }

  static const ::bookmarks_api::mojom::UrlPtr& url(const ::bookmarks_api::mojom::BookmarkNodePtr& input) {
    return input->get_url();
  }

  static const ::bookmarks_api::mojom::FolderPtr& folder(const ::bookmarks_api::mojom::BookmarkNodePtr& input) {
    return input->get_folder();
  }

  static bool Read(::bookmarks_api::mojom::BookmarkNode::DataView input, ::bookmarks_api::mojom::BookmarkNodePtr* output);
};


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

  static ::bookmarks_api::mojom::BookmarksEvent::Tag GetTag(const ::bookmarks_api::mojom::BookmarksEventPtr& input) {
    return input->which();
  }

  static const ::bookmarks_api::mojom::BookmarkNodeCreatedPtr& added(const ::bookmarks_api::mojom::BookmarksEventPtr& input) {
    return input->get_added();
  }

  static const ::bookmarks_api::mojom::BookmarkNodeRemovedPtr& removed(const ::bookmarks_api::mojom::BookmarksEventPtr& input) {
    return input->get_removed();
  }

  static const ::bookmarks_api::mojom::BookmarkNodeMovedPtr& moved(const ::bookmarks_api::mojom::BookmarksEventPtr& input) {
    return input->get_moved();
  }

  static const ::bookmarks_api::mojom::BookmarkNodeChangedPtr& changed(const ::bookmarks_api::mojom::BookmarksEventPtr& input) {
    return input->get_changed();
  }

  static bool Read(::bookmarks_api::mojom::BookmarksEvent::DataView input, ::bookmarks_api::mojom::BookmarksEventPtr* output);
};


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

  static ::bookmarks_api::mojom::BookmarksService_GetBookmarks_ResponseParam_Result::Tag GetTag(const ::bookmarks_api::mojom::BookmarksService_GetBookmarks_ResponseParam_ResultPtr& input) {
    return input->which();
  }

  static  ::bookmarks_api::mojom::BookmarksSnapshotPtr& success( ::bookmarks_api::mojom::BookmarksService_GetBookmarks_ResponseParam_ResultPtr& input) {
    return input->get_success();
  }

  static const ::mojo_base::mojom::ErrorPtr& failure(const ::bookmarks_api::mojom::BookmarksService_GetBookmarks_ResponseParam_ResultPtr& input) {
    return input->get_failure();
  }

  static bool Read(::bookmarks_api::mojom::BookmarksService_GetBookmarks_ResponseParam_Result::DataView input, ::bookmarks_api::mojom::BookmarksService_GetBookmarks_ResponseParam_ResultPtr* output);
};


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

  static ::bookmarks_api::mojom::BookmarksService_GetBookmark_ResponseParam_Result::Tag GetTag(const ::bookmarks_api::mojom::BookmarksService_GetBookmark_ResponseParam_ResultPtr& input) {
    return input->which();
  }

  static const ::bookmarks_api::mojom::BookmarkNodePtr& success(const ::bookmarks_api::mojom::BookmarksService_GetBookmark_ResponseParam_ResultPtr& input) {
    return input->get_success();
  }

  static const ::mojo_base::mojom::ErrorPtr& failure(const ::bookmarks_api::mojom::BookmarksService_GetBookmark_ResponseParam_ResultPtr& input) {
    return input->get_failure();
  }

  static bool Read(::bookmarks_api::mojom::BookmarksService_GetBookmark_ResponseParam_Result::DataView input, ::bookmarks_api::mojom::BookmarksService_GetBookmark_ResponseParam_ResultPtr* output);
};


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

  static ::bookmarks_api::mojom::BookmarksService_CreateBookmarkNode_ResponseParam_Result::Tag GetTag(const ::bookmarks_api::mojom::BookmarksService_CreateBookmarkNode_ResponseParam_ResultPtr& input) {
    return input->which();
  }

  static const ::bookmarks_api::mojom::BookmarkNodePtr& success(const ::bookmarks_api::mojom::BookmarksService_CreateBookmarkNode_ResponseParam_ResultPtr& input) {
    return input->get_success();
  }

  static const ::mojo_base::mojom::ErrorPtr& failure(const ::bookmarks_api::mojom::BookmarksService_CreateBookmarkNode_ResponseParam_ResultPtr& input) {
    return input->get_failure();
  }

  static bool Read(::bookmarks_api::mojom::BookmarksService_CreateBookmarkNode_ResponseParam_Result::DataView input, ::bookmarks_api::mojom::BookmarksService_CreateBookmarkNode_ResponseParam_ResultPtr* output);
};


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

  static ::bookmarks_api::mojom::BookmarksService_UpdateBookmarkNode_ResponseParam_Result::Tag GetTag(const ::bookmarks_api::mojom::BookmarksService_UpdateBookmarkNode_ResponseParam_ResultPtr& input) {
    return input->which();
  }

  static const ::bookmarks_api::mojom::BookmarkNodePtr& success(const ::bookmarks_api::mojom::BookmarksService_UpdateBookmarkNode_ResponseParam_ResultPtr& input) {
    return input->get_success();
  }

  static const ::mojo_base::mojom::ErrorPtr& failure(const ::bookmarks_api::mojom::BookmarksService_UpdateBookmarkNode_ResponseParam_ResultPtr& input) {
    return input->get_failure();
  }

  static bool Read(::bookmarks_api::mojom::BookmarksService_UpdateBookmarkNode_ResponseParam_Result::DataView input, ::bookmarks_api::mojom::BookmarksService_UpdateBookmarkNode_ResponseParam_ResultPtr* output);
};


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

  static ::bookmarks_api::mojom::BookmarksService_MoveBookmarkNode_ResponseParam_Result::Tag GetTag(const ::bookmarks_api::mojom::BookmarksService_MoveBookmarkNode_ResponseParam_ResultPtr& input) {
    return input->which();
  }

  static const ::std::monostate& success(const ::bookmarks_api::mojom::BookmarksService_MoveBookmarkNode_ResponseParam_ResultPtr& input) {
    return input->get_success();
  }

  static const ::mojo_base::mojom::ErrorPtr& failure(const ::bookmarks_api::mojom::BookmarksService_MoveBookmarkNode_ResponseParam_ResultPtr& input) {
    return input->get_failure();
  }

  static bool Read(::bookmarks_api::mojom::BookmarksService_MoveBookmarkNode_ResponseParam_Result::DataView input, ::bookmarks_api::mojom::BookmarksService_MoveBookmarkNode_ResponseParam_ResultPtr* output);
};


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

  static ::bookmarks_api::mojom::BookmarksService_DeleteBookmarkNodes_ResponseParam_Result::Tag GetTag(const ::bookmarks_api::mojom::BookmarksService_DeleteBookmarkNodes_ResponseParam_ResultPtr& input) {
    return input->which();
  }

  static const ::std::monostate& success(const ::bookmarks_api::mojom::BookmarksService_DeleteBookmarkNodes_ResponseParam_ResultPtr& input) {
    return input->get_success();
  }

  static const ::mojo_base::mojom::ErrorPtr& failure(const ::bookmarks_api::mojom::BookmarksService_DeleteBookmarkNodes_ResponseParam_ResultPtr& input) {
    return input->get_failure();
  }

  static bool Read(::bookmarks_api::mojom::BookmarksService_DeleteBookmarkNodes_ResponseParam_Result::DataView input, ::bookmarks_api::mojom::BookmarksService_DeleteBookmarkNodes_ResponseParam_ResultPtr* output);
};

}  // namespace mojo

#endif  // COMPONENTS_BROWSER_APIS_BOOKMARKS_BOOKMARKS_API_MOJOM_H_