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

// Copyright 2016 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_SHARED_H_
#define COMPONENTS_BROWSER_APIS_BOOKMARKS_BOOKMARKS_API_MOJOM_SHARED_H_

#include <stdint.h>

#include <functional>
#include <iosfwd>
#include <type_traits>
#include <utility>
#include "mojo/public/cpp/bindings/array_data_view.h"
#include "mojo/public/cpp/bindings/map_data_view.h"
#include "mojo/public/cpp/bindings/string_data_view.h"
#include "mojo/public/cpp/system/message_pipe.h"

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

#include "components/browser_apis/bookmarks/bookmarks_api.mojom-shared-internal.h"
#include "mojo/public/mojom/base/empty.mojom-shared.h"
#include "mojo/public/mojom/base/error.mojom-shared.h"
#include "mojo/public/mojom/base/uuid.mojom-shared.h"
#include "url/mojom/url.mojom-shared.h"
#include "mojo/public/cpp/bindings/lib/interface_serialization.h"
#include "mojo/public/cpp/system/data_pipe.h"



#include "components/browser_apis/bookmarks/bookmarks_api.mojom-data-view.h"  // IWYU pragma: export




namespace std {

template <>
struct hash<::bookmarks_api::mojom::PermanentFolderType>
    : public mojo::internal::EnumHashImpl<::bookmarks_api::mojom::PermanentFolderType> {};

}  // namespace std

namespace mojo {


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::bookmarks_api::mojom::PermanentFolderType, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = EnumTraits<::bookmarks_api::mojom::PermanentFolderType, UserType>;

  static void Serialize(UserType input, int32_t* output) {
    *output = static_cast<int32_t>(Traits::ToMojom(input));
  }

  static bool Deserialize(int32_t input, UserType* output) {
    auto known_value = ::mojo::internal::ToKnownEnumValueHelper(
        static_cast<::bookmarks_api::mojom::PermanentFolderType>(input));
    if constexpr (requires {
                    {
                      Traits::FromMojom(known_value)
                    } -> std::same_as<UserType>;
                  }) {
      static_assert(std::same_as<::bookmarks_api::mojom::PermanentFolderType, UserType> ||
                        HasInfallibleConversion(::bookmarks_api::mojom::PermanentFolderType()),
                    "::bookmarks_api::mojom::PermanentFolderType does not have an infallible conversion, "
                    "use an optional return type.");
      *output = Traits::FromMojom(known_value);
      return true;
    } else {
      static_assert(
          requires {
            {
              Traits::FromMojom(known_value)
            } -> std::same_as<std::optional<UserType>>;
          }, "FromMojom must return by value or optional.");
      std::optional<UserType> from_mojom = Traits::FromMojom(known_value);
      if (from_mojom) {
        *output = *from_mojom;
      }
      return from_mojom.has_value();
    }
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::bookmarks_api::mojom::LegacyFieldsDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::bookmarks_api::mojom::LegacyFieldsDataView, UserType>;

  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::bookmarks_api::mojom::internal::LegacyFields_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();
    fragment->id_$flag = Traits::id(input).has_value();
    if (Traits::id(input).has_value()) {
      fragment->id_$value = Traits::id(input).value();
    }
  }

  static bool Deserialize(::bookmarks_api::mojom::internal::LegacyFields_Data* input,
                          UserType* output,
                          Message* message) {
    if (!input)
      return CallSetToNullIfExists<Traits>(output);

    ::bookmarks_api::mojom::LegacyFieldsDataView data_view(input, message);
    return CallTraitsRead<Traits>(data_view, output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::bookmarks_api::mojom::RootNodeDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::bookmarks_api::mojom::RootNodeDataView, UserType>;

  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::bookmarks_api::mojom::internal::RootNode_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

    decltype(Traits::id(input)) in_id = Traits::id(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->id)::BaseType> id_fragment(
            fragment.message());
    
    mojo::internal::Serialize<::mojo_base::mojom::UuidDataView>(
      in_id,
      id_fragment);

    fragment->id.Set(
        id_fragment.is_null() ? nullptr : id_fragment.data());

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(fragment->id.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null id in RootNode struct");

    decltype(Traits::children(input)) in_children = Traits::children(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->children)::BaseType>
        children_fragment(fragment.message());
    constexpr const mojo::internal::ContainerValidateParams& children_validate_params =
        mojo::internal::GetArrayValidator<0, false, nullptr>();
    
    mojo::internal::Serialize<mojo::ArrayDataView<::bookmarks_api::mojom::FolderDataView>>(
      in_children,
      children_fragment,
      &children_validate_params);

    fragment->children.Set(
        children_fragment.is_null() ? nullptr : children_fragment.data());

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(fragment->children.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null children in RootNode struct");
  }

  static bool Deserialize(::bookmarks_api::mojom::internal::RootNode_Data* input,
                          UserType* output,
                          Message* message) {
    if (!input)
      return CallSetToNullIfExists<Traits>(output);

    ::bookmarks_api::mojom::RootNodeDataView data_view(input, message);
    return CallTraitsRead<Traits>(data_view, output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::bookmarks_api::mojom::UrlDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::bookmarks_api::mojom::UrlDataView, UserType>;

  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::bookmarks_api::mojom::internal::Url_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

    decltype(Traits::id(input)) in_id = Traits::id(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->id)::BaseType> id_fragment(
            fragment.message());
    
    mojo::internal::Serialize<::mojo_base::mojom::UuidDataView>(
      in_id,
      id_fragment);

    fragment->id.Set(
        id_fragment.is_null() ? nullptr : id_fragment.data());

    decltype(Traits::legacy(input)) in_legacy = Traits::legacy(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->legacy)::BaseType> legacy_fragment(
            fragment.message());
    
    mojo::internal::Serialize<::bookmarks_api::mojom::LegacyFieldsDataView>(
      in_legacy,
      legacy_fragment);

    fragment->legacy.Set(
        legacy_fragment.is_null() ? nullptr : legacy_fragment.data());

    decltype(Traits::title(input)) in_title = Traits::title(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->title)::BaseType> title_fragment(
            fragment.message());
    
    mojo::internal::Serialize<mojo::StringDataView>(
      in_title,
      title_fragment);

    fragment->title.Set(
        title_fragment.is_null() ? nullptr : title_fragment.data());

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(fragment->title.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null title in Url struct");

    decltype(Traits::url(input)) in_url = Traits::url(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->url)::BaseType> url_fragment(
            fragment.message());
    
    mojo::internal::Serialize<::url::mojom::UrlDataView>(
      in_url,
      url_fragment);

    fragment->url.Set(
        url_fragment.is_null() ? nullptr : url_fragment.data());

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(fragment->url.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null url in Url struct");

    decltype(Traits::favicon_url(input)) in_favicon_url = Traits::favicon_url(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->favicon_url)::BaseType> favicon_url_fragment(
            fragment.message());
    
    mojo::internal::Serialize<::url::mojom::UrlDataView>(
      in_favicon_url,
      favicon_url_fragment);

    fragment->favicon_url.Set(
        favicon_url_fragment.is_null() ? nullptr : favicon_url_fragment.data());

    fragment->is_synced = Traits::is_synced(input);
  }

  static bool Deserialize(::bookmarks_api::mojom::internal::Url_Data* input,
                          UserType* output,
                          Message* message) {
    if (!input)
      return CallSetToNullIfExists<Traits>(output);

    ::bookmarks_api::mojom::UrlDataView data_view(input, message);
    return CallTraitsRead<Traits>(data_view, output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::bookmarks_api::mojom::FolderDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::bookmarks_api::mojom::FolderDataView, UserType>;

  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::bookmarks_api::mojom::internal::Folder_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

    decltype(Traits::id(input)) in_id = Traits::id(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->id)::BaseType> id_fragment(
            fragment.message());
    
    mojo::internal::Serialize<::mojo_base::mojom::UuidDataView>(
      in_id,
      id_fragment);

    fragment->id.Set(
        id_fragment.is_null() ? nullptr : id_fragment.data());

    decltype(Traits::legacy(input)) in_legacy = Traits::legacy(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->legacy)::BaseType> legacy_fragment(
            fragment.message());
    
    mojo::internal::Serialize<::bookmarks_api::mojom::LegacyFieldsDataView>(
      in_legacy,
      legacy_fragment);

    fragment->legacy.Set(
        legacy_fragment.is_null() ? nullptr : legacy_fragment.data());

    decltype(Traits::title(input)) in_title = Traits::title(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->title)::BaseType> title_fragment(
            fragment.message());
    
    mojo::internal::Serialize<mojo::StringDataView>(
      in_title,
      title_fragment);

    fragment->title.Set(
        title_fragment.is_null() ? nullptr : title_fragment.data());

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(fragment->title.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null title in Folder struct");

    decltype(Traits::children(input)) in_children = Traits::children(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->children)::BaseType>
        children_fragment(fragment.message());
    constexpr const mojo::internal::ContainerValidateParams& children_validate_params =
        mojo::internal::GetArrayValidator<0, false, nullptr>();
    
    mojo::internal::Serialize<mojo::ArrayDataView<::bookmarks_api::mojom::BookmarkNodeDataView>>(
      in_children,
      children_fragment,
      &children_validate_params);

    fragment->children.Set(
        children_fragment.is_null() ? nullptr : children_fragment.data());

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(fragment->children.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null children in Folder struct");
    fragment->permanent_folder_type_$flag = Traits::permanent_folder_type(input).has_value();
    if (Traits::permanent_folder_type(input).has_value()) {
      
      mojo::internal::Serialize<::bookmarks_api::mojom::PermanentFolderType>(
        Traits::permanent_folder_type(input).value(),
        &fragment->permanent_folder_type_$value);
    } else {
      fragment->permanent_folder_type_$value =
          static_cast<int32_t>(::bookmarks_api::mojom::PermanentFolderType::kMinValue);
    }

    fragment->is_synced = Traits::is_synced(input);
  }

  static bool Deserialize(::bookmarks_api::mojom::internal::Folder_Data* input,
                          UserType* output,
                          Message* message) {
    if (!input)
      return CallSetToNullIfExists<Traits>(output);

    ::bookmarks_api::mojom::FolderDataView data_view(input, message);
    return CallTraitsRead<Traits>(data_view, output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::bookmarks_api::mojom::BookmarksSnapshotDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::bookmarks_api::mojom::BookmarksSnapshotDataView, UserType>;

  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::bookmarks_api::mojom::internal::BookmarksSnapshot_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

    decltype(Traits::root(input)) in_root = Traits::root(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->root)::BaseType> root_fragment(
            fragment.message());
    
    mojo::internal::Serialize<::bookmarks_api::mojom::RootNodeDataView>(
      in_root,
      root_fragment);

    fragment->root.Set(
        root_fragment.is_null() ? nullptr : root_fragment.data());

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(fragment->root.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null root in BookmarksSnapshot struct");

    decltype(Traits::stream(input)) in_stream = Traits::stream(input);

    
    mojo::internal::Serialize<::bookmarks_api::mojom::BookmarksObserverAssociatedRequestDataView>(
      in_stream,
      &fragment->stream,
      &fragment.message());

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(!mojo::internal::IsHandleOrInterfaceValid(fragment->stream)),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_INVALID_INTERFACE_ID,
      "invalid stream in BookmarksSnapshot struct");
  }

  static bool Deserialize(::bookmarks_api::mojom::internal::BookmarksSnapshot_Data* input,
                          UserType* output,
                          Message* message) {
    if (!input)
      return CallSetToNullIfExists<Traits>(output);

    ::bookmarks_api::mojom::BookmarksSnapshotDataView data_view(input, message);
    return CallTraitsRead<Traits>(data_view, output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::bookmarks_api::mojom::BookmarkNodeCreatedDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::bookmarks_api::mojom::BookmarkNodeCreatedDataView, UserType>;

  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::bookmarks_api::mojom::internal::BookmarkNodeCreated_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

    decltype(Traits::parent_id(input)) in_parent_id = Traits::parent_id(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->parent_id)::BaseType> parent_id_fragment(
            fragment.message());
    
    mojo::internal::Serialize<::mojo_base::mojom::UuidDataView>(
      in_parent_id,
      parent_id_fragment);

    fragment->parent_id.Set(
        parent_id_fragment.is_null() ? nullptr : parent_id_fragment.data());

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(fragment->parent_id.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null parent_id in BookmarkNodeCreated struct");

    fragment->index = Traits::index(input);

    decltype(Traits::node(input)) in_node = Traits::node(input);
    mojo::internal::MessageFragment<decltype(fragment->node)>
        node_fragment(fragment.message());
    node_fragment.Claim(&fragment->node);
    
    mojo::internal::Serialize<::bookmarks_api::mojom::BookmarkNodeDataView>(
      in_node,
      node_fragment,
      true);

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(fragment->node.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null node in BookmarkNodeCreated struct");
  }

  static bool Deserialize(::bookmarks_api::mojom::internal::BookmarkNodeCreated_Data* input,
                          UserType* output,
                          Message* message) {
    if (!input)
      return CallSetToNullIfExists<Traits>(output);

    ::bookmarks_api::mojom::BookmarkNodeCreatedDataView data_view(input, message);
    return CallTraitsRead<Traits>(data_view, output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::bookmarks_api::mojom::BookmarkNodeRemovedDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::bookmarks_api::mojom::BookmarkNodeRemovedDataView, UserType>;

  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::bookmarks_api::mojom::internal::BookmarkNodeRemoved_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

    decltype(Traits::id(input)) in_id = Traits::id(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->id)::BaseType> id_fragment(
            fragment.message());
    
    mojo::internal::Serialize<::mojo_base::mojom::UuidDataView>(
      in_id,
      id_fragment);

    fragment->id.Set(
        id_fragment.is_null() ? nullptr : id_fragment.data());

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(fragment->id.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null id in BookmarkNodeRemoved struct");
  }

  static bool Deserialize(::bookmarks_api::mojom::internal::BookmarkNodeRemoved_Data* input,
                          UserType* output,
                          Message* message) {
    if (!input)
      return CallSetToNullIfExists<Traits>(output);

    ::bookmarks_api::mojom::BookmarkNodeRemovedDataView data_view(input, message);
    return CallTraitsRead<Traits>(data_view, output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::bookmarks_api::mojom::BookmarkNodeMovedDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::bookmarks_api::mojom::BookmarkNodeMovedDataView, UserType>;

  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::bookmarks_api::mojom::internal::BookmarkNodeMoved_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

    decltype(Traits::old_parent_id(input)) in_old_parent_id = Traits::old_parent_id(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->old_parent_id)::BaseType> old_parent_id_fragment(
            fragment.message());
    
    mojo::internal::Serialize<::mojo_base::mojom::UuidDataView>(
      in_old_parent_id,
      old_parent_id_fragment);

    fragment->old_parent_id.Set(
        old_parent_id_fragment.is_null() ? nullptr : old_parent_id_fragment.data());

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(fragment->old_parent_id.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null old_parent_id in BookmarkNodeMoved struct");

    fragment->old_index = Traits::old_index(input);

    decltype(Traits::new_parent_id(input)) in_new_parent_id = Traits::new_parent_id(input);
    mojo::internal::MessageFragment<
        typename decltype(fragment->new_parent_id)::BaseType> new_parent_id_fragment(
            fragment.message());
    
    mojo::internal::Serialize<::mojo_base::mojom::UuidDataView>(
      in_new_parent_id,
      new_parent_id_fragment);

    fragment->new_parent_id.Set(
        new_parent_id_fragment.is_null() ? nullptr : new_parent_id_fragment.data());

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(fragment->new_parent_id.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null new_parent_id in BookmarkNodeMoved struct");

    fragment->new_index = Traits::new_index(input);
  }

  static bool Deserialize(::bookmarks_api::mojom::internal::BookmarkNodeMoved_Data* input,
                          UserType* output,
                          Message* message) {
    if (!input)
      return CallSetToNullIfExists<Traits>(output);

    ::bookmarks_api::mojom::BookmarkNodeMovedDataView data_view(input, message);
    return CallTraitsRead<Traits>(data_view, output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::bookmarks_api::mojom::BookmarkNodeChangedDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::bookmarks_api::mojom::BookmarkNodeChangedDataView, UserType>;

  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::bookmarks_api::mojom::internal::BookmarkNodeChanged_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

    decltype(Traits::node(input)) in_node = Traits::node(input);
    mojo::internal::MessageFragment<decltype(fragment->node)>
        node_fragment(fragment.message());
    node_fragment.Claim(&fragment->node);
    
    mojo::internal::Serialize<::bookmarks_api::mojom::BookmarkNodeDataView>(
      in_node,
      node_fragment,
      true);

    
    MOJO_INTERNAL_CHECK_SERIALIZATION(
      mojo::internal::SendValidation::kDefault,
      !(fragment->node.is_null()),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null node in BookmarkNodeChanged struct");
  }

  static bool Deserialize(::bookmarks_api::mojom::internal::BookmarkNodeChanged_Data* input,
                          UserType* output,
                          Message* message) {
    if (!input)
      return CallSetToNullIfExists<Traits>(output);

    ::bookmarks_api::mojom::BookmarkNodeChangedDataView data_view(input, message);
    return CallTraitsRead<Traits>(data_view, output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::bookmarks_api::mojom::BookmarkNodeDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = UnionTraits<::bookmarks_api::mojom::BookmarkNodeDataView, UserType>;

  static void Serialize(MaybeConstUserType& input,
                        MessageFragment<::bookmarks_api::mojom::internal::BookmarkNode_Data>& fragment,
                        bool inlined) {
    
    if (CallIsNullIfExists<Traits>(input)) {
       if (inlined)
        fragment->set_null();
      return;
    }

if (!inlined)
  fragment.Allocate();

    // TODO(azani): Handle unknown and objects.
    // Set the not-null flag.
fragment->size = kUnionDataSize;
fragment->tag = Traits::GetTag(input);
switch (fragment->tag) {
  case ::bookmarks_api::mojom::BookmarkNodeDataView::Tag::kUrl: {
    decltype(Traits::url(input))
    in_url = Traits::url(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_url)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<::bookmarks_api::mojom::UrlDataView>(
  in_url,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  mojo::internal::SendValidation::kDefault,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null url in BookmarkNode union");
    fragment->data.f_url.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
  case ::bookmarks_api::mojom::BookmarkNodeDataView::Tag::kFolder: {
    decltype(Traits::folder(input))
    in_folder = Traits::folder(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_folder)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<::bookmarks_api::mojom::FolderDataView>(
  in_folder,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  mojo::internal::SendValidation::kDefault,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null folder in BookmarkNode union");
    fragment->data.f_folder.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
}
  }

  static bool Deserialize(::bookmarks_api::mojom::internal::BookmarkNode_Data* input,
                          UserType* output,
                          Message* message) {
    if (!input || input->is_null())
      return CallSetToNullIfExists<Traits>(output);

    ::bookmarks_api::mojom::BookmarkNodeDataView data_view(input, message);
    return CallTraitsRead<Traits>(data_view, output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::bookmarks_api::mojom::BookmarksEventDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = UnionTraits<::bookmarks_api::mojom::BookmarksEventDataView, UserType>;

  static void Serialize(MaybeConstUserType& input,
                        MessageFragment<::bookmarks_api::mojom::internal::BookmarksEvent_Data>& fragment,
                        bool inlined) {
    
    if (CallIsNullIfExists<Traits>(input)) {
       if (inlined)
        fragment->set_null();
      return;
    }

if (!inlined)
  fragment.Allocate();

    // TODO(azani): Handle unknown and objects.
    // Set the not-null flag.
fragment->size = kUnionDataSize;
fragment->tag = Traits::GetTag(input);
switch (fragment->tag) {
  case ::bookmarks_api::mojom::BookmarksEventDataView::Tag::kAdded: {
    decltype(Traits::added(input))
    in_added = Traits::added(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_added)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<::bookmarks_api::mojom::BookmarkNodeCreatedDataView>(
  in_added,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  mojo::internal::SendValidation::kDefault,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null added in BookmarksEvent union");
    fragment->data.f_added.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
  case ::bookmarks_api::mojom::BookmarksEventDataView::Tag::kRemoved: {
    decltype(Traits::removed(input))
    in_removed = Traits::removed(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_removed)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<::bookmarks_api::mojom::BookmarkNodeRemovedDataView>(
  in_removed,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  mojo::internal::SendValidation::kDefault,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null removed in BookmarksEvent union");
    fragment->data.f_removed.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
  case ::bookmarks_api::mojom::BookmarksEventDataView::Tag::kMoved: {
    decltype(Traits::moved(input))
    in_moved = Traits::moved(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_moved)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<::bookmarks_api::mojom::BookmarkNodeMovedDataView>(
  in_moved,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  mojo::internal::SendValidation::kDefault,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null moved in BookmarksEvent union");
    fragment->data.f_moved.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
  case ::bookmarks_api::mojom::BookmarksEventDataView::Tag::kChanged: {
    decltype(Traits::changed(input))
    in_changed = Traits::changed(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_changed)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<::bookmarks_api::mojom::BookmarkNodeChangedDataView>(
  in_changed,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  mojo::internal::SendValidation::kDefault,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null changed in BookmarksEvent union");
    fragment->data.f_changed.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
}
  }

  static bool Deserialize(::bookmarks_api::mojom::internal::BookmarksEvent_Data* input,
                          UserType* output,
                          Message* message) {
    if (!input || input->is_null())
      return CallSetToNullIfExists<Traits>(output);

    ::bookmarks_api::mojom::BookmarksEventDataView data_view(input, message);
    return CallTraitsRead<Traits>(data_view, output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::bookmarks_api::mojom::BookmarksService_GetBookmarks_ResponseParam_ResultDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = UnionTraits<::bookmarks_api::mojom::BookmarksService_GetBookmarks_ResponseParam_ResultDataView, UserType>;

  static void Serialize(MaybeConstUserType& input,
                        MessageFragment<::bookmarks_api::mojom::internal::BookmarksService_GetBookmarks_ResponseParam_Result_Data>& fragment,
                        bool inlined) {
    
    if (CallIsNullIfExists<Traits>(input)) {
       if (inlined)
        fragment->set_null();
      return;
    }

if (!inlined)
  fragment.Allocate();

    // TODO(azani): Handle unknown and objects.
    // Set the not-null flag.
fragment->size = kUnionDataSize;
fragment->tag = Traits::GetTag(input);
switch (fragment->tag) {
  case ::bookmarks_api::mojom::BookmarksService_GetBookmarks_ResponseParam_ResultDataView::Tag::kSuccess: {
    decltype(Traits::success(input))
    in_success = Traits::success(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_success)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<::bookmarks_api::mojom::BookmarksSnapshotDataView>(
  in_success,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  mojo::internal::SendValidation::kDefault,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null success in BookmarksService_GetBookmarks_ResponseParam_Result union");
    fragment->data.f_success.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
  case ::bookmarks_api::mojom::BookmarksService_GetBookmarks_ResponseParam_ResultDataView::Tag::kFailure: {
    decltype(Traits::failure(input))
    in_failure = Traits::failure(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_failure)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<::mojo_base::mojom::ErrorDataView>(
  in_failure,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  mojo::internal::SendValidation::kDefault,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null failure in BookmarksService_GetBookmarks_ResponseParam_Result union");
    fragment->data.f_failure.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
}
  }

  static bool Deserialize(::bookmarks_api::mojom::internal::BookmarksService_GetBookmarks_ResponseParam_Result_Data* input,
                          UserType* output,
                          Message* message) {
    if (!input || input->is_null())
      return CallSetToNullIfExists<Traits>(output);

    ::bookmarks_api::mojom::BookmarksService_GetBookmarks_ResponseParam_ResultDataView data_view(input, message);
    return CallTraitsRead<Traits>(data_view, output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::bookmarks_api::mojom::BookmarksService_GetBookmark_ResponseParam_ResultDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = UnionTraits<::bookmarks_api::mojom::BookmarksService_GetBookmark_ResponseParam_ResultDataView, UserType>;

  static void Serialize(MaybeConstUserType& input,
                        MessageFragment<::bookmarks_api::mojom::internal::BookmarksService_GetBookmark_ResponseParam_Result_Data>& fragment,
                        bool inlined) {
    
    if (CallIsNullIfExists<Traits>(input)) {
       if (inlined)
        fragment->set_null();
      return;
    }

if (!inlined)
  fragment.Allocate();

    // TODO(azani): Handle unknown and objects.
    // Set the not-null flag.
fragment->size = kUnionDataSize;
fragment->tag = Traits::GetTag(input);
switch (fragment->tag) {
  case ::bookmarks_api::mojom::BookmarksService_GetBookmark_ResponseParam_ResultDataView::Tag::kSuccess: {
    decltype(Traits::success(input))
    in_success = Traits::success(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_success)::BaseType>
    value_fragment(fragment.message());
  
mojo::internal::Serialize<::bookmarks_api::mojom::BookmarkNodeDataView>(
  in_success,
  value_fragment,
  false);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  mojo::internal::SendValidation::kDefault,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null success in BookmarksService_GetBookmark_ResponseParam_Result union");
    fragment->data.f_success.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
  case ::bookmarks_api::mojom::BookmarksService_GetBookmark_ResponseParam_ResultDataView::Tag::kFailure: {
    decltype(Traits::failure(input))
    in_failure = Traits::failure(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_failure)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<::mojo_base::mojom::ErrorDataView>(
  in_failure,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  mojo::internal::SendValidation::kDefault,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null failure in BookmarksService_GetBookmark_ResponseParam_Result union");
    fragment->data.f_failure.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
}
  }

  static bool Deserialize(::bookmarks_api::mojom::internal::BookmarksService_GetBookmark_ResponseParam_Result_Data* input,
                          UserType* output,
                          Message* message) {
    if (!input || input->is_null())
      return CallSetToNullIfExists<Traits>(output);

    ::bookmarks_api::mojom::BookmarksService_GetBookmark_ResponseParam_ResultDataView data_view(input, message);
    return CallTraitsRead<Traits>(data_view, output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::bookmarks_api::mojom::BookmarksService_CreateBookmarkNode_ResponseParam_ResultDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = UnionTraits<::bookmarks_api::mojom::BookmarksService_CreateBookmarkNode_ResponseParam_ResultDataView, UserType>;

  static void Serialize(MaybeConstUserType& input,
                        MessageFragment<::bookmarks_api::mojom::internal::BookmarksService_CreateBookmarkNode_ResponseParam_Result_Data>& fragment,
                        bool inlined) {
    
    if (CallIsNullIfExists<Traits>(input)) {
       if (inlined)
        fragment->set_null();
      return;
    }

if (!inlined)
  fragment.Allocate();

    // TODO(azani): Handle unknown and objects.
    // Set the not-null flag.
fragment->size = kUnionDataSize;
fragment->tag = Traits::GetTag(input);
switch (fragment->tag) {
  case ::bookmarks_api::mojom::BookmarksService_CreateBookmarkNode_ResponseParam_ResultDataView::Tag::kSuccess: {
    decltype(Traits::success(input))
    in_success = Traits::success(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_success)::BaseType>
    value_fragment(fragment.message());
  
mojo::internal::Serialize<::bookmarks_api::mojom::BookmarkNodeDataView>(
  in_success,
  value_fragment,
  false);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  mojo::internal::SendValidation::kDefault,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null success in BookmarksService_CreateBookmarkNode_ResponseParam_Result union");
    fragment->data.f_success.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
  case ::bookmarks_api::mojom::BookmarksService_CreateBookmarkNode_ResponseParam_ResultDataView::Tag::kFailure: {
    decltype(Traits::failure(input))
    in_failure = Traits::failure(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_failure)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<::mojo_base::mojom::ErrorDataView>(
  in_failure,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  mojo::internal::SendValidation::kDefault,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null failure in BookmarksService_CreateBookmarkNode_ResponseParam_Result union");
    fragment->data.f_failure.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
}
  }

  static bool Deserialize(::bookmarks_api::mojom::internal::BookmarksService_CreateBookmarkNode_ResponseParam_Result_Data* input,
                          UserType* output,
                          Message* message) {
    if (!input || input->is_null())
      return CallSetToNullIfExists<Traits>(output);

    ::bookmarks_api::mojom::BookmarksService_CreateBookmarkNode_ResponseParam_ResultDataView data_view(input, message);
    return CallTraitsRead<Traits>(data_view, output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::bookmarks_api::mojom::BookmarksService_UpdateBookmarkNode_ResponseParam_ResultDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = UnionTraits<::bookmarks_api::mojom::BookmarksService_UpdateBookmarkNode_ResponseParam_ResultDataView, UserType>;

  static void Serialize(MaybeConstUserType& input,
                        MessageFragment<::bookmarks_api::mojom::internal::BookmarksService_UpdateBookmarkNode_ResponseParam_Result_Data>& fragment,
                        bool inlined) {
    
    if (CallIsNullIfExists<Traits>(input)) {
       if (inlined)
        fragment->set_null();
      return;
    }

if (!inlined)
  fragment.Allocate();

    // TODO(azani): Handle unknown and objects.
    // Set the not-null flag.
fragment->size = kUnionDataSize;
fragment->tag = Traits::GetTag(input);
switch (fragment->tag) {
  case ::bookmarks_api::mojom::BookmarksService_UpdateBookmarkNode_ResponseParam_ResultDataView::Tag::kSuccess: {
    decltype(Traits::success(input))
    in_success = Traits::success(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_success)::BaseType>
    value_fragment(fragment.message());
  
mojo::internal::Serialize<::bookmarks_api::mojom::BookmarkNodeDataView>(
  in_success,
  value_fragment,
  false);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  mojo::internal::SendValidation::kDefault,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null success in BookmarksService_UpdateBookmarkNode_ResponseParam_Result union");
    fragment->data.f_success.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
  case ::bookmarks_api::mojom::BookmarksService_UpdateBookmarkNode_ResponseParam_ResultDataView::Tag::kFailure: {
    decltype(Traits::failure(input))
    in_failure = Traits::failure(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_failure)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<::mojo_base::mojom::ErrorDataView>(
  in_failure,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  mojo::internal::SendValidation::kDefault,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null failure in BookmarksService_UpdateBookmarkNode_ResponseParam_Result union");
    fragment->data.f_failure.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
}
  }

  static bool Deserialize(::bookmarks_api::mojom::internal::BookmarksService_UpdateBookmarkNode_ResponseParam_Result_Data* input,
                          UserType* output,
                          Message* message) {
    if (!input || input->is_null())
      return CallSetToNullIfExists<Traits>(output);

    ::bookmarks_api::mojom::BookmarksService_UpdateBookmarkNode_ResponseParam_ResultDataView data_view(input, message);
    return CallTraitsRead<Traits>(data_view, output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::bookmarks_api::mojom::BookmarksService_MoveBookmarkNode_ResponseParam_ResultDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = UnionTraits<::bookmarks_api::mojom::BookmarksService_MoveBookmarkNode_ResponseParam_ResultDataView, UserType>;

  static void Serialize(MaybeConstUserType& input,
                        MessageFragment<::bookmarks_api::mojom::internal::BookmarksService_MoveBookmarkNode_ResponseParam_Result_Data>& fragment,
                        bool inlined) {
    
    if (CallIsNullIfExists<Traits>(input)) {
       if (inlined)
        fragment->set_null();
      return;
    }

if (!inlined)
  fragment.Allocate();

    // TODO(azani): Handle unknown and objects.
    // Set the not-null flag.
fragment->size = kUnionDataSize;
fragment->tag = Traits::GetTag(input);
switch (fragment->tag) {
  case ::bookmarks_api::mojom::BookmarksService_MoveBookmarkNode_ResponseParam_ResultDataView::Tag::kSuccess: {
    decltype(Traits::success(input))
    in_success = Traits::success(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_success)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<::mojo_base::mojom::EmptyDataView>(
  in_success,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  mojo::internal::SendValidation::kDefault,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null success in BookmarksService_MoveBookmarkNode_ResponseParam_Result union");
    fragment->data.f_success.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
  case ::bookmarks_api::mojom::BookmarksService_MoveBookmarkNode_ResponseParam_ResultDataView::Tag::kFailure: {
    decltype(Traits::failure(input))
    in_failure = Traits::failure(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_failure)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<::mojo_base::mojom::ErrorDataView>(
  in_failure,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  mojo::internal::SendValidation::kDefault,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null failure in BookmarksService_MoveBookmarkNode_ResponseParam_Result union");
    fragment->data.f_failure.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
}
  }

  static bool Deserialize(::bookmarks_api::mojom::internal::BookmarksService_MoveBookmarkNode_ResponseParam_Result_Data* input,
                          UserType* output,
                          Message* message) {
    if (!input || input->is_null())
      return CallSetToNullIfExists<Traits>(output);

    ::bookmarks_api::mojom::BookmarksService_MoveBookmarkNode_ResponseParam_ResultDataView data_view(input, message);
    return CallTraitsRead<Traits>(data_view, output);
  }
};

}  // namespace internal


namespace internal {

template <typename MaybeConstUserType>
struct Serializer<::bookmarks_api::mojom::BookmarksService_DeleteBookmarkNodes_ResponseParam_ResultDataView, MaybeConstUserType> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = UnionTraits<::bookmarks_api::mojom::BookmarksService_DeleteBookmarkNodes_ResponseParam_ResultDataView, UserType>;

  static void Serialize(MaybeConstUserType& input,
                        MessageFragment<::bookmarks_api::mojom::internal::BookmarksService_DeleteBookmarkNodes_ResponseParam_Result_Data>& fragment,
                        bool inlined) {
    
    if (CallIsNullIfExists<Traits>(input)) {
       if (inlined)
        fragment->set_null();
      return;
    }

if (!inlined)
  fragment.Allocate();

    // TODO(azani): Handle unknown and objects.
    // Set the not-null flag.
fragment->size = kUnionDataSize;
fragment->tag = Traits::GetTag(input);
switch (fragment->tag) {
  case ::bookmarks_api::mojom::BookmarksService_DeleteBookmarkNodes_ResponseParam_ResultDataView::Tag::kSuccess: {
    decltype(Traits::success(input))
    in_success = Traits::success(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_success)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<::mojo_base::mojom::EmptyDataView>(
  in_success,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  mojo::internal::SendValidation::kDefault,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null success in BookmarksService_DeleteBookmarkNodes_ResponseParam_Result union");
    fragment->data.f_success.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
  case ::bookmarks_api::mojom::BookmarksService_DeleteBookmarkNodes_ResponseParam_ResultDataView::Tag::kFailure: {
    decltype(Traits::failure(input))
    in_failure = Traits::failure(input);
    mojo::internal::MessageFragment<
      typename decltype(fragment->data.f_failure)::BaseType>
    value_fragment(fragment.message());
        
mojo::internal::Serialize<::mojo_base::mojom::ErrorDataView>(
  in_failure,
  value_fragment);
  
MOJO_INTERNAL_CHECK_SERIALIZATION(
  mojo::internal::SendValidation::kDefault,
  !(value_fragment.is_null()),
  mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
  "null failure in BookmarksService_DeleteBookmarkNodes_ResponseParam_Result union");
    fragment->data.f_failure.Set(
      value_fragment.is_null() ? nullptr : value_fragment.data());
    break;
  }
}
  }

  static bool Deserialize(::bookmarks_api::mojom::internal::BookmarksService_DeleteBookmarkNodes_ResponseParam_Result_Data* input,
                          UserType* output,
                          Message* message) {
    if (!input || input->is_null())
      return CallSetToNullIfExists<Traits>(output);

    ::bookmarks_api::mojom::BookmarksService_DeleteBookmarkNodes_ResponseParam_ResultDataView data_view(input, message);
    return CallTraitsRead<Traits>(data_view, output);
  }
};

}  // namespace internal

}  // namespace mojo


namespace bookmarks_api::mojom {



inline void RootNodeDataView::GetIdDataView(
    ::mojo_base::mojom::UuidDataView* output) {
  auto pointer = data_->id.Get();
  *output = ::mojo_base::mojom::UuidDataView(pointer, message_);
}
inline void RootNodeDataView::GetChildrenDataView(
    mojo::ArrayDataView<FolderDataView>* output) {
  auto pointer = data_->children.Get();
  *output = mojo::ArrayDataView<FolderDataView>(pointer, message_);
}


inline void UrlDataView::GetIdDataView(
    ::mojo_base::mojom::UuidDataView* output) {
  auto pointer = data_->id.Get();
  *output = ::mojo_base::mojom::UuidDataView(pointer, message_);
}
inline void UrlDataView::GetLegacyDataView(
    LegacyFieldsDataView* output) {
  auto pointer = data_->legacy.Get();
  *output = LegacyFieldsDataView(pointer, message_);
}
inline void UrlDataView::GetTitleDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->title.Get();
  *output = mojo::StringDataView(pointer, message_);
}
inline void UrlDataView::GetUrlDataView(
    ::url::mojom::UrlDataView* output) {
  auto pointer = data_->url.Get();
  *output = ::url::mojom::UrlDataView(pointer, message_);
}
inline void UrlDataView::GetFaviconUrlDataView(
    ::url::mojom::UrlDataView* output) {
  auto pointer = data_->favicon_url.Get();
  *output = ::url::mojom::UrlDataView(pointer, message_);
}


inline void FolderDataView::GetIdDataView(
    ::mojo_base::mojom::UuidDataView* output) {
  auto pointer = data_->id.Get();
  *output = ::mojo_base::mojom::UuidDataView(pointer, message_);
}
inline void FolderDataView::GetLegacyDataView(
    LegacyFieldsDataView* output) {
  auto pointer = data_->legacy.Get();
  *output = LegacyFieldsDataView(pointer, message_);
}
inline void FolderDataView::GetTitleDataView(
    mojo::StringDataView* output) {
  auto pointer = data_->title.Get();
  *output = mojo::StringDataView(pointer, message_);
}
inline void FolderDataView::GetChildrenDataView(
    mojo::ArrayDataView<BookmarkNodeDataView>* output) {
  auto pointer = data_->children.Get();
  *output = mojo::ArrayDataView<BookmarkNodeDataView>(pointer, message_);
}


inline void BookmarksSnapshotDataView::GetRootDataView(
    RootNodeDataView* output) {
  auto pointer = data_->root.Get();
  *output = RootNodeDataView(pointer, message_);
}


inline void BookmarkNodeCreatedDataView::GetParentIdDataView(
    ::mojo_base::mojom::UuidDataView* output) {
  auto pointer = data_->parent_id.Get();
  *output = ::mojo_base::mojom::UuidDataView(pointer, message_);
}
inline void BookmarkNodeCreatedDataView::GetNodeDataView(
    BookmarkNodeDataView* output) {
  auto pointer = &data_->node;
  *output = BookmarkNodeDataView(pointer, message_);
}


inline void BookmarkNodeRemovedDataView::GetIdDataView(
    ::mojo_base::mojom::UuidDataView* output) {
  auto pointer = data_->id.Get();
  *output = ::mojo_base::mojom::UuidDataView(pointer, message_);
}


inline void BookmarkNodeMovedDataView::GetOldParentIdDataView(
    ::mojo_base::mojom::UuidDataView* output) {
  auto pointer = data_->old_parent_id.Get();
  *output = ::mojo_base::mojom::UuidDataView(pointer, message_);
}
inline void BookmarkNodeMovedDataView::GetNewParentIdDataView(
    ::mojo_base::mojom::UuidDataView* output) {
  auto pointer = data_->new_parent_id.Get();
  *output = ::mojo_base::mojom::UuidDataView(pointer, message_);
}


inline void BookmarkNodeChangedDataView::GetNodeDataView(
    BookmarkNodeDataView* output) {
  auto pointer = &data_->node;
  *output = BookmarkNodeDataView(pointer, message_);
}


inline void BookmarkNodeDataView::GetUrlDataView(
    UrlDataView* output) const {
  CHECK(is_url());
  *output = UrlDataView(data_->data.f_url.Get(), message_);
}
inline void BookmarkNodeDataView::GetFolderDataView(
    FolderDataView* output) const {
  CHECK(is_folder());
  *output = FolderDataView(data_->data.f_folder.Get(), message_);
}

inline void BookmarksEventDataView::GetAddedDataView(
    BookmarkNodeCreatedDataView* output) const {
  CHECK(is_added());
  *output = BookmarkNodeCreatedDataView(data_->data.f_added.Get(), message_);
}
inline void BookmarksEventDataView::GetRemovedDataView(
    BookmarkNodeRemovedDataView* output) const {
  CHECK(is_removed());
  *output = BookmarkNodeRemovedDataView(data_->data.f_removed.Get(), message_);
}
inline void BookmarksEventDataView::GetMovedDataView(
    BookmarkNodeMovedDataView* output) const {
  CHECK(is_moved());
  *output = BookmarkNodeMovedDataView(data_->data.f_moved.Get(), message_);
}
inline void BookmarksEventDataView::GetChangedDataView(
    BookmarkNodeChangedDataView* output) const {
  CHECK(is_changed());
  *output = BookmarkNodeChangedDataView(data_->data.f_changed.Get(), message_);
}

inline void BookmarksService_GetBookmarks_ResponseParam_ResultDataView::GetSuccessDataView(
    BookmarksSnapshotDataView* output) const {
  CHECK(is_success());
  *output = BookmarksSnapshotDataView(data_->data.f_success.Get(), message_);
}
inline void BookmarksService_GetBookmarks_ResponseParam_ResultDataView::GetFailureDataView(
    ::mojo_base::mojom::ErrorDataView* output) const {
  CHECK(is_failure());
  *output = ::mojo_base::mojom::ErrorDataView(data_->data.f_failure.Get(), message_);
}

inline void BookmarksService_GetBookmark_ResponseParam_ResultDataView::GetSuccessDataView(
    BookmarkNodeDataView* output) const {
  CHECK(is_success());
  *output = BookmarkNodeDataView(data_->data.f_success.Get(), message_);
}
inline void BookmarksService_GetBookmark_ResponseParam_ResultDataView::GetFailureDataView(
    ::mojo_base::mojom::ErrorDataView* output) const {
  CHECK(is_failure());
  *output = ::mojo_base::mojom::ErrorDataView(data_->data.f_failure.Get(), message_);
}

inline void BookmarksService_CreateBookmarkNode_ResponseParam_ResultDataView::GetSuccessDataView(
    BookmarkNodeDataView* output) const {
  CHECK(is_success());
  *output = BookmarkNodeDataView(data_->data.f_success.Get(), message_);
}
inline void BookmarksService_CreateBookmarkNode_ResponseParam_ResultDataView::GetFailureDataView(
    ::mojo_base::mojom::ErrorDataView* output) const {
  CHECK(is_failure());
  *output = ::mojo_base::mojom::ErrorDataView(data_->data.f_failure.Get(), message_);
}

inline void BookmarksService_UpdateBookmarkNode_ResponseParam_ResultDataView::GetSuccessDataView(
    BookmarkNodeDataView* output) const {
  CHECK(is_success());
  *output = BookmarkNodeDataView(data_->data.f_success.Get(), message_);
}
inline void BookmarksService_UpdateBookmarkNode_ResponseParam_ResultDataView::GetFailureDataView(
    ::mojo_base::mojom::ErrorDataView* output) const {
  CHECK(is_failure());
  *output = ::mojo_base::mojom::ErrorDataView(data_->data.f_failure.Get(), message_);
}

inline void BookmarksService_MoveBookmarkNode_ResponseParam_ResultDataView::GetSuccessDataView(
    ::mojo_base::mojom::EmptyDataView* output) const {
  CHECK(is_success());
  *output = ::mojo_base::mojom::EmptyDataView(data_->data.f_success.Get(), message_);
}
inline void BookmarksService_MoveBookmarkNode_ResponseParam_ResultDataView::GetFailureDataView(
    ::mojo_base::mojom::ErrorDataView* output) const {
  CHECK(is_failure());
  *output = ::mojo_base::mojom::ErrorDataView(data_->data.f_failure.Get(), message_);
}

inline void BookmarksService_DeleteBookmarkNodes_ResponseParam_ResultDataView::GetSuccessDataView(
    ::mojo_base::mojom::EmptyDataView* output) const {
  CHECK(is_success());
  *output = ::mojo_base::mojom::EmptyDataView(data_->data.f_success.Get(), message_);
}
inline void BookmarksService_DeleteBookmarkNodes_ResponseParam_ResultDataView::GetFailureDataView(
    ::mojo_base::mojom::ErrorDataView* output) const {
  CHECK(is_failure());
  *output = ::mojo_base::mojom::ErrorDataView(data_->data.f_failure.Get(), message_);
}


}  // bookmarks_api::mojom

// Declare TraceFormatTraits for enums, which should be defined in ::perfetto
// namespace.

namespace perfetto {

template <>
struct  TraceFormatTraits<::bookmarks_api::mojom::PermanentFolderType> {
 static void WriteIntoTrace(perfetto::TracedValue context, ::bookmarks_api::mojom::PermanentFolderType value);
};

} // namespace perfetto

#endif  // COMPONENTS_BROWSER_APIS_BOOKMARKS_BOOKMARKS_API_MOJOM_SHARED_H_