// components/browser_apis/tab_strip/tab_strip_api_events.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_TAB_STRIP_TAB_STRIP_API_EVENTS_MOJOM_H_
#define COMPONENTS_BROWSER_APIS_TAB_STRIP_TAB_STRIP_API_EVENTS_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/tab_strip/tab_strip_api_events.mojom-features.h"  // IWYU pragma: export
#include "components/browser_apis/tab_strip/tab_strip_api_events.mojom-shared.h"  // IWYU pragma: export
#include "components/browser_apis/tab_strip/tab_strip_api_events.mojom-forward.h"  // IWYU pragma: export
#include "components/browser_apis/tab_strip/tab_strip_api_data_model.mojom.h"
#include "components/browser_apis/tab_strip/tab_strip_api_types.mojom.h"
#include <string>
#include <vector>








namespace tabs_api::mojom {












class  OnDataChangedEvent {
 public:
  using DataView = OnDataChangedEventDataView;
  using Data_ = internal::OnDataChangedEvent_Data;
  using Tag = Data_::OnDataChangedEvent_Tag;

  template <typename... Args>
  static OnDataChangedEventPtr 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 |tab|.
  static OnDataChangedEventPtr NewTab(
      TabChangePtr value);
  // Construct an instance holding |tab_group|.
  static OnDataChangedEventPtr NewTabGroup(
      TabGroupChangePtr value);
  // Construct an instance holding |split_tab|.
  static OnDataChangedEventPtr NewSplitTab(
      SplitTabChangePtr value);

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

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

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

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

  Tag which() const {
    return tag_;
  }

  bool is_tab() const { return tag_ == Tag::kTab; }
  const TabChangePtr& get_tab() const {
    CHECK(tag_ == Tag::kTab);
    return data_.tab;
  }
  TabChangePtr& get_tab() {
    CHECK(tag_ == Tag::kTab);
    return data_.tab;
  }
  void set_tab(TabChangePtr tab);

  bool is_tab_group() const { return tag_ == Tag::kTabGroup; }
  const TabGroupChangePtr& get_tab_group() const {
    CHECK(tag_ == Tag::kTabGroup);
    return data_.tab_group;
  }
  TabGroupChangePtr& get_tab_group() {
    CHECK(tag_ == Tag::kTabGroup);
    return data_.tab_group;
  }
  void set_tab_group(TabGroupChangePtr tab_group);

  bool is_split_tab() const { return tag_ == Tag::kSplitTab; }
  const SplitTabChangePtr& get_split_tab() const {
    CHECK(tag_ == Tag::kSplitTab);
    return data_.split_tab;
  }
  SplitTabChangePtr& get_split_tab() {
    CHECK(tag_ == Tag::kSplitTab);
    return data_.split_tab;
  }
  void set_split_tab(SplitTabChangePtr split_tab);

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

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

    TabChangePtr tab;
    TabGroupChangePtr tab_group;
    SplitTabChangePtr split_tab;
  };

  OnDataChangedEvent(
      std::in_place_index_t<static_cast<size_t>(Tag::kTab)>,
      TabChangePtr value);
  OnDataChangedEvent(
      std::in_place_index_t<static_cast<size_t>(Tag::kTabGroup)>,
      TabGroupChangePtr value);
  OnDataChangedEvent(
      std::in_place_index_t<static_cast<size_t>(Tag::kSplitTab)>,
      SplitTabChangePtr value);

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

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





class  OnTabsCreatedEvent {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<OnTabsCreatedEvent, T>::value>;
  using DataView = OnTabsCreatedEventDataView;
  using Data_ = internal::OnTabsCreatedEvent_Data;

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

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

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


  OnTabsCreatedEvent();

  explicit OnTabsCreatedEvent(
      std::vector<::tabs_api::mojom::TabCreatedContainerPtr> tabs);

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

  ~OnTabsCreatedEvent();

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

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

  template <typename T, OnTabsCreatedEvent::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<
        OnTabsCreatedEvent::DataView, std::vector<uint8_t>, send_validation>(input);
  }

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

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

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

  
  std::vector<::tabs_api::mojom::TabCreatedContainerPtr> tabs;

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

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

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

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





class  OnNodesClosedEvent {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<OnNodesClosedEvent, T>::value>;
  using DataView = OnNodesClosedEventDataView;
  using Data_ = internal::OnNodesClosedEvent_Data;

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

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

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


  OnNodesClosedEvent();

  explicit OnNodesClosedEvent(
      std::vector<::tabs_api::NodeId> node_ids);


  ~OnNodesClosedEvent();

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

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

  template <typename T, OnNodesClosedEvent::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<
        OnNodesClosedEvent::DataView, std::vector<uint8_t>, send_validation>(input);
  }

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

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

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

  
  std::vector<::tabs_api::NodeId> node_ids;

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

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

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

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





class  TabChange {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<TabChange, T>::value>;
  using DataView = TabChangeDataView;
  using Data_ = internal::TabChange_Data;

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

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

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


  TabChange();

  TabChange(
      ::tabs_api::mojom::TabPtr data,
      ::tabs_api::mojom::TabFieldMaskPtr mask);

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

  ~TabChange();

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

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

  template <typename T, TabChange::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<
        TabChange::DataView, std::vector<uint8_t>, send_validation>(input);
  }

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

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

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

  
  ::tabs_api::mojom::TabPtr data;
  
  ::tabs_api::mojom::TabFieldMaskPtr mask;

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

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

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

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





class  TabGroupChange {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<TabGroupChange, T>::value>;
  using DataView = TabGroupChangeDataView;
  using Data_ = internal::TabGroupChange_Data;

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

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

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


  TabGroupChange();

  explicit TabGroupChange(
      ::tabs_api::mojom::TabGroupPtr data);

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

  ~TabGroupChange();

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

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

  template <typename T, TabGroupChange::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<
        TabGroupChange::DataView, std::vector<uint8_t>, send_validation>(input);
  }

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

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

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

  
  ::tabs_api::mojom::TabGroupPtr data;

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

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

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

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





class  SplitTabChange {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<SplitTabChange, T>::value>;
  using DataView = SplitTabChangeDataView;
  using Data_ = internal::SplitTabChange_Data;

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

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

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


  SplitTabChange();

  explicit SplitTabChange(
      ::tabs_api::mojom::SplitTabPtr data);

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

  ~SplitTabChange();

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

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

  template <typename T, SplitTabChange::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<
        SplitTabChange::DataView, std::vector<uint8_t>, send_validation>(input);
  }

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

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

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

  
  ::tabs_api::mojom::SplitTabPtr data;

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

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

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

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





class  OnCollectionCreatedEvent {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<OnCollectionCreatedEvent, T>::value>;
  using DataView = OnCollectionCreatedEventDataView;
  using Data_ = internal::OnCollectionCreatedEvent_Data;

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

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

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


  OnCollectionCreatedEvent();

  OnCollectionCreatedEvent(
      const ::tabs_api::Position& position,
      ::tabs_api::mojom::ContainerPtr collection);

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

  ~OnCollectionCreatedEvent();

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

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

  template <typename T, OnCollectionCreatedEvent::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<
        OnCollectionCreatedEvent::DataView, std::vector<uint8_t>, send_validation>(input);
  }

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

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

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

  
  ::tabs_api::Position position;
  
  ::tabs_api::mojom::ContainerPtr collection;

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

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

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

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





class  OnNodeMovedEvent {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<OnNodeMovedEvent, T>::value>;
  using DataView = OnNodeMovedEventDataView;
  using Data_ = internal::OnNodeMovedEvent_Data;

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

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

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


  OnNodeMovedEvent();

  OnNodeMovedEvent(
      const ::tabs_api::NodeId& id,
      const ::tabs_api::Position& from,
      const ::tabs_api::Position& to);


  ~OnNodeMovedEvent();

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

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

  template <typename T, OnNodeMovedEvent::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<
        OnNodeMovedEvent::DataView, std::vector<uint8_t>, send_validation>(input);
  }

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

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

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

  
  ::tabs_api::NodeId id;
  
  ::tabs_api::Position from;
  
  ::tabs_api::Position to;

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

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

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

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

template <typename UnionPtrType>
OnDataChangedEventPtr OnDataChangedEvent::Clone() const {
  switch (tag_) {
    case Tag::kTab:
      return NewTab(
          mojo::Clone(data_.tab));
    case Tag::kTabGroup:
      return NewTabGroup(
          mojo::Clone(data_.tab_group));
    case Tag::kSplitTab:
      return NewSplitTab(
          mojo::Clone(data_.split_tab));
  }
  return nullptr;
}

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

  switch (tag_) {
    case Tag::kTab:
      return mojo::Equals(data_.tab, other.data_.tab);
    case Tag::kTabGroup:
      return mojo::Equals(data_.tab_group, other.data_.tab_group);
    case Tag::kSplitTab:
      return mojo::Equals(data_.split_tab, other.data_.split_tab);
  }

  return false;
}
template <typename StructPtrType>
OnTabsCreatedEventPtr OnTabsCreatedEvent::Clone() const {
  return New(
      mojo::Clone(tabs)
  );
}

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

template <typename T, OnTabsCreatedEvent::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.tabs < rhs.tabs)
    return true;
  if (rhs.tabs < lhs.tabs)
    return false;
  return false;
}
template <typename StructPtrType>
OnNodesClosedEventPtr OnNodesClosedEvent::Clone() const {
  return New(
      mojo::Clone(node_ids)
  );
}

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

template <typename T, OnNodesClosedEvent::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.node_ids < rhs.node_ids)
    return true;
  if (rhs.node_ids < lhs.node_ids)
    return false;
  return false;
}
template <typename StructPtrType>
TabChangePtr TabChange::Clone() const {
  return New(
      mojo::Clone(data),
      mojo::Clone(mask)
  );
}

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

template <typename T, TabChange::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.data < rhs.data)
    return true;
  if (rhs.data < lhs.data)
    return false;
  if (lhs.mask < rhs.mask)
    return true;
  if (rhs.mask < lhs.mask)
    return false;
  return false;
}
template <typename StructPtrType>
TabGroupChangePtr TabGroupChange::Clone() const {
  return New(
      mojo::Clone(data)
  );
}

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

template <typename T, TabGroupChange::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.data < rhs.data)
    return true;
  if (rhs.data < lhs.data)
    return false;
  return false;
}
template <typename StructPtrType>
SplitTabChangePtr SplitTabChange::Clone() const {
  return New(
      mojo::Clone(data)
  );
}

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

template <typename T, SplitTabChange::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.data < rhs.data)
    return true;
  if (rhs.data < lhs.data)
    return false;
  return false;
}
template <typename StructPtrType>
OnCollectionCreatedEventPtr OnCollectionCreatedEvent::Clone() const {
  return New(
      mojo::Clone(position),
      mojo::Clone(collection)
  );
}

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

template <typename T, OnCollectionCreatedEvent::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.position < rhs.position)
    return true;
  if (rhs.position < lhs.position)
    return false;
  if (lhs.collection < rhs.collection)
    return true;
  if (rhs.collection < lhs.collection)
    return false;
  return false;
}
template <typename StructPtrType>
OnNodeMovedEventPtr OnNodeMovedEvent::Clone() const {
  return New(
      mojo::Clone(id),
      mojo::Clone(from),
      mojo::Clone(to)
  );
}

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

template <typename T, OnNodeMovedEvent::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.from < rhs.from)
    return true;
  if (rhs.from < lhs.from)
    return false;
  if (lhs.to < rhs.to)
    return true;
  if (rhs.to < lhs.to)
    return false;
  return false;
}


}  // tabs_api::mojom

namespace mojo {


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

  static const decltype(::tabs_api::mojom::OnTabsCreatedEvent::tabs)& tabs(
      const ::tabs_api::mojom::OnTabsCreatedEventPtr& input) {
    return input->tabs;
  }

  static bool Read(::tabs_api::mojom::OnTabsCreatedEvent::DataView input, ::tabs_api::mojom::OnTabsCreatedEventPtr* output);
};


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

  static const decltype(::tabs_api::mojom::OnNodesClosedEvent::node_ids)& node_ids(
      const ::tabs_api::mojom::OnNodesClosedEventPtr& input) {
    return input->node_ids;
  }

  static bool Read(::tabs_api::mojom::OnNodesClosedEvent::DataView input, ::tabs_api::mojom::OnNodesClosedEventPtr* output);
};


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

  static const decltype(::tabs_api::mojom::TabChange::data)& data(
      const ::tabs_api::mojom::TabChangePtr& input) {
    return input->data;
  }

  static const decltype(::tabs_api::mojom::TabChange::mask)& mask(
      const ::tabs_api::mojom::TabChangePtr& input) {
    return input->mask;
  }

  static bool Read(::tabs_api::mojom::TabChange::DataView input, ::tabs_api::mojom::TabChangePtr* output);
};


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

  static const decltype(::tabs_api::mojom::TabGroupChange::data)& data(
      const ::tabs_api::mojom::TabGroupChangePtr& input) {
    return input->data;
  }

  static bool Read(::tabs_api::mojom::TabGroupChange::DataView input, ::tabs_api::mojom::TabGroupChangePtr* output);
};


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

  static const decltype(::tabs_api::mojom::SplitTabChange::data)& data(
      const ::tabs_api::mojom::SplitTabChangePtr& input) {
    return input->data;
  }

  static bool Read(::tabs_api::mojom::SplitTabChange::DataView input, ::tabs_api::mojom::SplitTabChangePtr* output);
};


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

  static const decltype(::tabs_api::mojom::OnCollectionCreatedEvent::position)& position(
      const ::tabs_api::mojom::OnCollectionCreatedEventPtr& input) {
    return input->position;
  }

  static const decltype(::tabs_api::mojom::OnCollectionCreatedEvent::collection)& collection(
      const ::tabs_api::mojom::OnCollectionCreatedEventPtr& input) {
    return input->collection;
  }

  static bool Read(::tabs_api::mojom::OnCollectionCreatedEvent::DataView input, ::tabs_api::mojom::OnCollectionCreatedEventPtr* output);
};


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

  static const decltype(::tabs_api::mojom::OnNodeMovedEvent::id)& id(
      const ::tabs_api::mojom::OnNodeMovedEventPtr& input) {
    return input->id;
  }

  static const decltype(::tabs_api::mojom::OnNodeMovedEvent::from)& from(
      const ::tabs_api::mojom::OnNodeMovedEventPtr& input) {
    return input->from;
  }

  static const decltype(::tabs_api::mojom::OnNodeMovedEvent::to)& to(
      const ::tabs_api::mojom::OnNodeMovedEventPtr& input) {
    return input->to;
  }

  static bool Read(::tabs_api::mojom::OnNodeMovedEvent::DataView input, ::tabs_api::mojom::OnNodeMovedEventPtr* output);
};


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

  static ::tabs_api::mojom::OnDataChangedEvent::Tag GetTag(const ::tabs_api::mojom::OnDataChangedEventPtr& input) {
    return input->which();
  }

  static const ::tabs_api::mojom::TabChangePtr& tab(const ::tabs_api::mojom::OnDataChangedEventPtr& input) {
    return input->get_tab();
  }

  static const ::tabs_api::mojom::TabGroupChangePtr& tab_group(const ::tabs_api::mojom::OnDataChangedEventPtr& input) {
    return input->get_tab_group();
  }

  static const ::tabs_api::mojom::SplitTabChangePtr& split_tab(const ::tabs_api::mojom::OnDataChangedEventPtr& input) {
    return input->get_split_tab();
  }

  static bool Read(::tabs_api::mojom::OnDataChangedEvent::DataView input, ::tabs_api::mojom::OnDataChangedEventPtr* output);
};

}  // namespace mojo

#endif  // COMPONENTS_BROWSER_APIS_TAB_STRIP_TAB_STRIP_API_EVENTS_MOJOM_H_