// chrome/browser/glic/host/glic.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 CHROME_BROWSER_GLIC_HOST_GLIC_MOJOM_H_
#define CHROME_BROWSER_GLIC_HOST_GLIC_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 "chrome/browser/glic/host/glic.mojom-features.h"  // IWYU pragma: export
#include "chrome/browser/glic/host/glic.mojom-shared.h"  // IWYU pragma: export
#include "chrome/browser/glic/host/glic.mojom-forward.h"  // IWYU pragma: export
#include "chrome/browser/glic/host/glic_features.mojom-forward.h"
#include "chrome/common/actor_webui.mojom-forward.h"
#include "chrome/common/glic_enums.mojom-forward.h"
#include "components/content_settings/core/common/content_settings_types.mojom-forward.h"
#include "mojo/public/mojom/base/absl_status.mojom-forward.h"
#include "mojo/public/mojom/base/big_buffer.mojom.h"
#include "mojo/public/mojom/base/byte_string.mojom.h"
#include "mojo/public/mojom/base/proto_wrapper.mojom.h"
#include "mojo/public/mojom/base/string16.mojom-forward.h"
#include "mojo/public/mojom/base/time.mojom.h"
#include "mojo/public/mojom/base/unguessable_token.mojom.h"
#include "mojo/public/mojom/base/values.mojom-forward.h"
#include "mojo/public/mojom/base/version.mojom.h"
#include "skia/public/mojom/bitmap.mojom.h"
#include "third_party/blink/public/mojom/content_extraction/ai_page_content_metadata.mojom.h"
#include "ui/gfx/geometry/mojom/geometry.mojom.h"
#include "url/mojom/origin.mojom.h"
#include "url/mojom/url.mojom.h"
#include <string>
#include <vector>

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


#include "base/types/expected.h"
#include "chrome/browser/glic/host/glic_mojom_traits.h"
#include "components/page_content_annotations/content/page_context_fetcher.h"




namespace glic::mojom {

class PinCandidatesObserverProxy;

template <typename ImplRefTraits>
class PinCandidatesObserverStub;

class PinCandidatesObserverRequestValidator;


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

  using Base_ = PinCandidatesObserverInterfaceBase;
  using Proxy_ = PinCandidatesObserverProxy;

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

  using RequestValidator_ = PinCandidatesObserverRequestValidator;
  using ResponseValidator_ = mojo::PassThroughFilter;
  enum MethodMinVersions : uint32_t {
    kOnPinCandidatesChangedMinVersion = 0,
  };

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

  virtual void OnPinCandidatesChanged(std::vector<PinCandidatePtr> candidates) = 0;
};

class ActorClientProxy;

template <typename ImplRefTraits>
class ActorClientStub;

class ActorClientRequestValidator;
class ActorClientResponseValidator;


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

  using Base_ = ActorClientInterfaceBase;
  using Proxy_ = ActorClientProxy;

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

  using RequestValidator_ = ActorClientRequestValidator;
  using ResponseValidator_ = ActorClientResponseValidator;
  enum MethodMinVersions : uint32_t {
    kRequestToShowCredentialSelectionDialogMinVersion = 0,
    kRequestToShowAutofillSuggestionsDialogMinVersion = 0,
    kRequestToShowUserConfirmationDialogMinVersion = 0,
    kRequestToConfirmNavigationMinVersion = 0,
    kNotifyActorTaskStateChangedMinVersion = 0,
    kRequestToShowGmailOtpOptInDialogMinVersion = 0,
    kRequestToShowGmailOtpConfirmationDialogMinVersion = 0,
  };

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

  using RequestToShowCredentialSelectionDialogCallback = base::OnceCallback<void(::actor::webui::mojom::SelectCredentialDialogResponsePtr)>;
  using RequestToShowCredentialSelectionDialogMojoCallback = base::OnceCallback<void(::actor::webui::mojom::SelectCredentialDialogResponsePtr)>;

  virtual void RequestToShowCredentialSelectionDialog(::actor::webui::mojom::SelectCredentialDialogRequestPtr request, RequestToShowCredentialSelectionDialogCallback callback) = 0;

  using RequestToShowAutofillSuggestionsDialogCallback = base::OnceCallback<void(::actor::webui::mojom::SelectAutofillSuggestionsDialogResponsePtr)>;
  using RequestToShowAutofillSuggestionsDialogMojoCallback = base::OnceCallback<void(::actor::webui::mojom::SelectAutofillSuggestionsDialogResponsePtr)>;

  virtual void RequestToShowAutofillSuggestionsDialog(::actor::webui::mojom::SelectAutofillSuggestionsDialogRequestPtr request, RequestToShowAutofillSuggestionsDialogCallback callback) = 0;

  using RequestToShowUserConfirmationDialogCallback = base::OnceCallback<void(::actor::webui::mojom::UserConfirmationDialogResponsePtr)>;
  using RequestToShowUserConfirmationDialogMojoCallback = base::OnceCallback<void(::actor::webui::mojom::UserConfirmationDialogResponsePtr)>;

  virtual void RequestToShowUserConfirmationDialog(::actor::webui::mojom::UserConfirmationDialogRequestPtr request, RequestToShowUserConfirmationDialogCallback callback) = 0;

  using RequestToConfirmNavigationCallback = base::OnceCallback<void(::actor::webui::mojom::NavigationConfirmationResponsePtr)>;
  using RequestToConfirmNavigationMojoCallback = base::OnceCallback<void(::actor::webui::mojom::NavigationConfirmationResponsePtr)>;

  virtual void RequestToConfirmNavigation(::actor::webui::mojom::NavigationConfirmationRequestPtr request, RequestToConfirmNavigationCallback callback) = 0;

  virtual void NotifyActorTaskStateChanged(int32_t task_id, ActorTaskState state) = 0;

  using RequestToShowGmailOtpOptInDialogCallback = base::OnceCallback<void(::actor::webui::mojom::GmailOtpOptInResultPtr)>;
  using RequestToShowGmailOtpOptInDialogMojoCallback = base::OnceCallback<void(::actor::webui::mojom::GmailOtpOptInResultPtr)>;

  virtual void RequestToShowGmailOtpOptInDialog(::actor::webui::mojom::GmailOtpOptInRequestPtr request, RequestToShowGmailOtpOptInDialogCallback callback) = 0;

  using RequestToShowGmailOtpConfirmationDialogCallback = base::OnceCallback<void(::actor::webui::mojom::GmailOtpConfirmationResultPtr)>;
  using RequestToShowGmailOtpConfirmationDialogMojoCallback = base::OnceCallback<void(::actor::webui::mojom::GmailOtpConfirmationResultPtr)>;

  virtual void RequestToShowGmailOtpConfirmationDialog(::actor::webui::mojom::GmailOtpConfirmationRequestPtr request, RequestToShowGmailOtpConfirmationDialogCallback callback) = 0;
};

class ActorHandlerProxy;

template <typename ImplRefTraits>
class ActorHandlerStub;

class ActorHandlerRequestValidator;
class ActorHandlerResponseValidator;


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

  using Base_ = ActorHandlerInterfaceBase;
  using Proxy_ = ActorHandlerProxy;

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

  using RequestValidator_ = ActorHandlerRequestValidator;
  using ResponseValidator_ = ActorHandlerResponseValidator;
  enum MethodMinVersions : uint32_t {
    kAutofillSuggestionDialogOnFormPresentedMinVersion = 0,
    kAutofillSuggestionDialogOnFormPreviewChangedMinVersion = 0,
    kAutofillSuggestionDialogOnFormConfirmedMinVersion = 0,
    kGetContextForActorFromTabMinVersion = 0,
    kCreateTaskMinVersion = 0,
    kPerformActionsMinVersion = 0,
    kCancelActionsMinVersion = 0,
    kStopActorTaskMinVersion = 0,
    kPauseActorTaskMinVersion = 0,
    kResumeActorTaskMinVersion = 0,
    kInterruptActorTaskMinVersion = 0,
    kUninterruptActorTaskMinVersion = 0,
    kUpdateActorTaskStepProgressMinVersion = 0,
    kCreateActorTabMinVersion = 0,
    kLogBeginAsyncEventMinVersion = 0,
    kLogEndAsyncEventMinVersion = 0,
    kLogInstantEventMinVersion = 0,
    kJournalClearMinVersion = 0,
    kJournalSnapshotMinVersion = 0,
    kJournalStartMinVersion = 0,
    kJournalStopMinVersion = 0,
    kJournalRecordFeedbackMinVersion = 0,
  };

// crbug.com/1340245 - this causes binary size bloat on Fuchsia, and we're OK
// with not having this data in traces there.
#if !BUILDFLAG(IS_FUCHSIA)
  struct AutofillSuggestionDialogOnFormPresented_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct AutofillSuggestionDialogOnFormPreviewChanged_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct AutofillSuggestionDialogOnFormConfirmed_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct GetContextForActorFromTab_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct CreateTask_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct PerformActions_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct CancelActions_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct StopActorTask_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct PauseActorTask_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct ResumeActorTask_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct InterruptActorTask_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct UninterruptActorTask_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct UpdateActorTaskStepProgress_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct CreateActorTab_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct LogBeginAsyncEvent_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct LogEndAsyncEvent_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct LogInstantEvent_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct JournalClear_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct JournalSnapshot_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct JournalStart_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct JournalStop_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct JournalRecordFeedback_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
#endif // !BUILDFLAG(IS_FUCHSIA)
  virtual ~ActorHandler() = default;

  virtual void AutofillSuggestionDialogOnFormPresented(int32_t task_id, ::actor::webui::mojom::AutofillSuggestionDialogOnFormPresentedParamsPtr params) = 0;

  virtual void AutofillSuggestionDialogOnFormPreviewChanged(int32_t task_id, ::actor::webui::mojom::AutofillSuggestionDialogOnFormPreviewChangedParamsPtr params) = 0;

  virtual void AutofillSuggestionDialogOnFormConfirmed(int32_t task_id, ::actor::webui::mojom::AutofillSuggestionDialogOnFormConfirmedParamsPtr params) = 0;

  using GetContextForActorFromTabCallback = base::OnceCallback<void(GetContextResultPtr)>;
  using GetContextForActorFromTabMojoCallback = base::OnceCallback<void(GetContextResultPtr)>;

  virtual void GetContextForActorFromTab(int32_t tab_id, TabContextOptionsPtr options, GetContextForActorFromTabCallback callback) = 0;

  using CreateTaskCallback = base::OnceCallback<void(base::expected<
  int32_t,
  CreateTaskErrorReason>)>;
  using CreateTaskResult = base::expected<
  int32_t,
  CreateTaskErrorReason>;
  using CreateTaskMojoCallback = base::OnceCallback<void(ActorHandler_CreateTask_ResponseParam_ResultPtr)>;

  virtual void CreateTask(::actor::webui::mojom::TaskOptionsPtr task_options, CreateTaskCallback callback) = 0;

  using PerformActionsCallback = base::OnceCallback<void(base::expected<
  ::mojo_base::ProtoWrapper,
  PerformActionsErrorReason>)>;
  using PerformActionsResult = base::expected<
  ::mojo_base::ProtoWrapper,
  PerformActionsErrorReason>;
  using PerformActionsMojoCallback = base::OnceCallback<void(ActorHandler_PerformActions_ResponseParam_ResultPtr)>;

  virtual void PerformActions(const std::vector<uint8_t>& actions_proto, PerformActionsCallback callback) = 0;

  using CancelActionsCallback = base::OnceCallback<void(CancelActionsResult)>;
  using CancelActionsMojoCallback = base::OnceCallback<void(CancelActionsResult)>;

  virtual void CancelActions(int32_t task_id, CancelActionsCallback callback) = 0;

  virtual void StopActorTask(int32_t task_id, ActorTaskStopReason stop_reason) = 0;

  virtual void PauseActorTask(int32_t task_id, ActorTaskPauseReason pause_reason, std::optional<int32_t> tab_id) = 0;

  using ResumeActorTaskCallback = base::OnceCallback<void(GetContextResultWithActionResultCodePtr)>;
  using ResumeActorTaskMojoCallback = base::OnceCallback<void(GetContextResultWithActionResultCodePtr)>;

  virtual void ResumeActorTask(int32_t task_id, TabContextOptionsPtr context_options, ResumeActorTaskCallback callback) = 0;

  virtual void InterruptActorTask(int32_t task_id, std::optional<ActorTaskInterruptReason> interrupt_reason) = 0;

  virtual void UninterruptActorTask(int32_t task_id) = 0;

  virtual void UpdateActorTaskStepProgress(int32_t task_id, const std::string& step_progress) = 0;

  using CreateActorTabCallback = base::OnceCallback<void(TabDataPtr)>;
  using CreateActorTabMojoCallback = base::OnceCallback<void(TabDataPtr)>;

  virtual void CreateActorTab(int32_t task_id, CreateActorTabOptionsPtr options, CreateActorTabCallback callback) = 0;

  virtual void LogBeginAsyncEvent(uint64_t event_async_id, int32_t task_id, const std::string& event, const std::string& details) = 0;

  virtual void LogEndAsyncEvent(uint64_t event_async_id, const std::string& details) = 0;

  virtual void LogInstantEvent(int32_t task_id, const std::string& event, const std::string& details) = 0;

  virtual void JournalClear() = 0;

  using JournalSnapshotCallback = base::OnceCallback<void(JournalPtr)>;
  using JournalSnapshotMojoCallback = base::OnceCallback<void(JournalPtr)>;

  virtual void JournalSnapshot(bool clear_journal, JournalSnapshotCallback callback) = 0;

  virtual void JournalStart(uint64_t max_bytes, bool capture_screenshots) = 0;

  virtual void JournalStop() = 0;

  virtual void JournalRecordFeedback(bool positive, const std::string& reason) = 0;
};

class AnnotationHandlerProxy;

template <typename ImplRefTraits>
class AnnotationHandlerStub;

class AnnotationHandlerRequestValidator;
class AnnotationHandlerResponseValidator;


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

  using Base_ = AnnotationHandlerInterfaceBase;
  using Proxy_ = AnnotationHandlerProxy;

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

  using RequestValidator_ = AnnotationHandlerRequestValidator;
  using ResponseValidator_ = AnnotationHandlerResponseValidator;
  enum MethodMinVersions : uint32_t {
    kScrollToMinVersion = 0,
    kDropScrollToHighlightMinVersion = 0,
  };

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

  using ScrollToCallback = base::OnceCallback<void(std::optional<ScrollToErrorReason>)>;
  using ScrollToMojoCallback = base::OnceCallback<void(std::optional<ScrollToErrorReason>)>;

  virtual void ScrollTo(ScrollToParamsPtr params, ScrollToCallback callback) = 0;

  virtual void DropScrollToHighlight() = 0;
};

class SkillsHandlerProxy;

template <typename ImplRefTraits>
class SkillsHandlerStub;

class SkillsHandlerRequestValidator;
class SkillsHandlerResponseValidator;


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

  using Base_ = SkillsHandlerInterfaceBase;
  using Proxy_ = SkillsHandlerProxy;

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

  using RequestValidator_ = SkillsHandlerRequestValidator;
  using ResponseValidator_ = SkillsHandlerResponseValidator;
  enum MethodMinVersions : uint32_t {
    kCreateSkillMinVersion = 0,
    kUpdateSkillMinVersion = 0,
    kShowManageSkillsUiMinVersion = 0,
    kShowBrowseSkillsUiMinVersion = 0,
    kGetSkillMinVersion = 0,
    kRecordSkillsWebClientEventMinVersion = 0,
  };

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

  using CreateSkillCallback = base::OnceCallback<void(bool)>;
  using CreateSkillMojoCallback = base::OnceCallback<void(bool)>;

  virtual void CreateSkill(CreateSkillRequestPtr request, CreateSkillCallback callback) = 0;

  using UpdateSkillCallback = base::OnceCallback<void(bool)>;
  using UpdateSkillMojoCallback = base::OnceCallback<void(bool)>;

  virtual void UpdateSkill(UpdateSkillRequestPtr request, UpdateSkillCallback callback) = 0;

  virtual void ShowManageSkillsUi() = 0;

  virtual void ShowBrowseSkillsUi() = 0;

  using GetSkillCallback = base::OnceCallback<void(SkillPtr)>;
  using GetSkillMojoCallback = base::OnceCallback<void(SkillPtr)>;

  virtual void GetSkill(const std::string& id, GetSkillCallback callback) = 0;

  virtual void RecordSkillsWebClientEvent(SkillsWebClientEvent event) = 0;
};

class SkillsClientProxy;

template <typename ImplRefTraits>
class SkillsClientStub;

class SkillsClientRequestValidator;


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

  using Base_ = SkillsClientInterfaceBase;
  using Proxy_ = SkillsClientProxy;

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

  using RequestValidator_ = SkillsClientRequestValidator;
  using ResponseValidator_ = mojo::PassThroughFilter;
  enum MethodMinVersions : uint32_t {
    kNotifySkillPreviewsChangedMinVersion = 0,
    kNotifyContextualSkillPreviewsChangedMinVersion = 0,
    kNotifySkillPreviewChangedMinVersion = 0,
    kNotifySkillDeletedMinVersion = 0,
    kNotifySkillsEnabledChangedMinVersion = 0,
  };

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

  virtual void NotifySkillPreviewsChanged(std::vector<SkillPreviewPtr> skill_previews) = 0;

  virtual void NotifyContextualSkillPreviewsChanged(std::vector<SkillPreviewPtr> skill_previews) = 0;

  virtual void NotifySkillPreviewChanged(SkillPreviewPtr skill_preview) = 0;

  virtual void NotifySkillDeleted(const std::string& skill_id) = 0;

  virtual void NotifySkillsEnabledChanged(bool enabled) = 0;
};

class WebClientHandlerProxy;

template <typename ImplRefTraits>
class WebClientHandlerStub;

class WebClientHandlerRequestValidator;
class WebClientHandlerResponseValidator;


class WebClientHandler
    : public WebClientHandlerInterfaceBase {
 public:
  using IPCStableHashFunction = uint32_t(*)();
  static constexpr const char* Name_ = "glic.mojom.WebClientHandler";
  static IPCStableHashFunction MessageToMethodInfo_(mojo::Message& message);
  static const char* MessageToMethodName_(mojo::Message& message);
  static constexpr uint32_t Version_ = 1;
  static constexpr bool PassesAssociatedKinds_ = false;
  static constexpr bool HasUninterruptableMethods_ = false;

  using Base_ = WebClientHandlerInterfaceBase;
  using Proxy_ = WebClientHandlerProxy;

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

  using RequestValidator_ = WebClientHandlerRequestValidator;
  using ResponseValidator_ = WebClientHandlerResponseValidator;
  enum MethodMinVersions : uint32_t {
    kWebClientCreatedMinVersion = 0,
    kWebClientInitializedMinVersion = 0,
    kWebClientInitializeFailedMinVersion = 0,
    kCreateActorHandlerMinVersion = 0,
    kCreateExperimentalTriggeringClientMinVersion = 0,
    kCreateAnnotationHandlerMinVersion = 0,
    kCreateSkillsHandlerMinVersion = 0,
    kCreateZeroStateSuggestionsHandlerMinVersion = 0,
    kCreateTabMinVersion = 0,
    kActivateTabWithUrlMinVersion = 0,
    kOpenLinkInPopupMinVersion = 0,
    kOpenGlicSettingsPageMinVersion = 0,
    kOpenPasswordManagerSettingsPageMinVersion = 0,
    kEnableDragResizeMinVersion = 0,
    kClosePanelMinVersion = 0,
    kClosePanelAndShutdownMinVersion = 0,
    kAttachPanelMinVersion = 0,
    kDetachPanelMinVersion = 0,
    kOnModeChangeMinVersion = 0,
    kOnMicrophoneStatusChangeMinVersion = 0,
    kShowProfilePickerMinVersion = 0,
    kGetModelQualityClientIdMinVersion = 0,
    kGetContextFromFocusedTabMinVersion = 0,
    kGetContextFromTabMinVersion = 0,
    kGetImageBytesFromTabMinVersion = 0,
    kSetMaximumNumberOfPinnedTabsMinVersion = 0,
    kPinTabsMinVersion = 0,
    kUnpinTabsMinVersion = 0,
    kUnpinAllTabsMinVersion = 0,
    kSubscribeToPinCandidatesMinVersion = 0,
    kOpenPinnedTabPickerMinVersion = 0,
    kActivateTabMinVersion = 0,
    kResizeWidgetMinVersion = 0,
    kCaptureScreenshotMinVersion = 0,
    kCaptureRegionMinVersion = 0,
    kDeleteCapturedRegionMinVersion = 0,
    kSetAudioDuckingMinVersion = 0,
    kSetMinimumPanelSizeMinVersion = 0,
    kSetMicrophonePermissionStateMinVersion = 0,
    kSetLocationPermissionStateMinVersion = 0,
    kSetTabContextPermissionStateMinVersion = 0,
    kSetClosedCaptioningSettingMinVersion = 0,
    kSetActuationOnWebSettingMinVersion = 0,
    kShouldAllowMediaPermissionRequestMinVersion = 0,
    kShouldAllowGeolocationPermissionRequestMinVersion = 0,
    kSetContextAccessIndicatorMinVersion = 0,
    kGetUserProfileInfoMinVersion = 0,
    kSyncCookiesMinVersion = 0,
    kClientErrorDialogStateChangedMinVersion = 0,
    kReportClientTransientErrorMinVersion = 0,
    kProcessCounterAbuseVerdictMinVersion = 0,
    kOnOptinImpressionMinVersion = 0,
    kOnUserInputSubmittedMinVersion = 0,
    kOnContextUploadStartedMinVersion = 0,
    kOnContextUploadCompletedMinVersion = 0,
    kOnReactionMinVersion = 0,
    kOnResponseStartedMinVersion = 0,
    kOnResponseStoppedMinVersion = 0,
    kOnSessionTerminatedMinVersion = 0,
    kOnTurnCompletedMinVersion = 0,
    kOnResponseRatedMinVersion = 0,
    kOnClosedCaptionsShownMinVersion = 0,
    kOnActionSubmittedMinVersion = 0,
    kSetSyntheticExperimentStateMinVersion = 0,
    kOpenOsPermissionSettingsMenuMinVersion = 0,
    kGetOsMicrophonePermissionStatusMinVersion = 0,
    kGetZeroStateSuggestionsForFocusedTabMinVersion = 0,
    kMaybeRefreshUserStatusMinVersion = 0,
    kIsDebuggerAttachedMinVersion = 0,
    kSubscribeToPageMetadataMinVersion = 0,
    kSwitchConversationMinVersion = 0,
    kRegisterConversationMinVersion = 0,
    kSetOnboardingCompletedMinVersion = 0,
    kSubscribeToTabDataMinVersion = 0,
    kSubscribeToTabFaviconMinVersion = 0,
  };

// crbug.com/1340245 - this causes binary size bloat on Fuchsia, and we're OK
// with not having this data in traces there.
#if !BUILDFLAG(IS_FUCHSIA)
  struct WebClientCreated_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct WebClientInitialized_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct WebClientInitializeFailed_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct CreateActorHandler_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct CreateExperimentalTriggeringClient_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct CreateAnnotationHandler_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct CreateSkillsHandler_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct CreateZeroStateSuggestionsHandler_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct CreateTab_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct ActivateTabWithUrl_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct OpenLinkInPopup_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct OpenGlicSettingsPage_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct OpenPasswordManagerSettingsPage_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct EnableDragResize_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct ClosePanel_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct ClosePanelAndShutdown_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct AttachPanel_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct DetachPanel_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct OnModeChange_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct OnMicrophoneStatusChange_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct ShowProfilePicker_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct GetModelQualityClientId_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct GetContextFromFocusedTab_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct GetContextFromTab_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct GetImageBytesFromTab_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct SetMaximumNumberOfPinnedTabs_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct PinTabs_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct UnpinTabs_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct UnpinAllTabs_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct SubscribeToPinCandidates_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct OpenPinnedTabPicker_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct ActivateTab_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct ResizeWidget_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct CaptureScreenshot_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct CaptureRegion_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct DeleteCapturedRegion_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct SetAudioDucking_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct SetMinimumPanelSize_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct SetMicrophonePermissionState_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct SetLocationPermissionState_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct SetTabContextPermissionState_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct SetClosedCaptioningSetting_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct SetActuationOnWebSetting_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct ShouldAllowMediaPermissionRequest_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct ShouldAllowGeolocationPermissionRequest_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct SetContextAccessIndicator_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct GetUserProfileInfo_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct SyncCookies_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct ClientErrorDialogStateChanged_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct ReportClientTransientError_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct ProcessCounterAbuseVerdict_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct OnOptinImpression_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct OnUserInputSubmitted_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct OnContextUploadStarted_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct OnContextUploadCompleted_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct OnReaction_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct OnResponseStarted_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct OnResponseStopped_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct OnSessionTerminated_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct OnTurnCompleted_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct OnResponseRated_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct OnClosedCaptionsShown_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct OnActionSubmitted_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct SetSyntheticExperimentState_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct OpenOsPermissionSettingsMenu_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct GetOsMicrophonePermissionStatus_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct GetZeroStateSuggestionsForFocusedTab_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct MaybeRefreshUserStatus_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct IsDebuggerAttached_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct SubscribeToPageMetadata_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct SwitchConversation_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct RegisterConversation_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct SetOnboardingCompleted_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct SubscribeToTabData_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct SubscribeToTabFavicon_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
#endif // !BUILDFLAG(IS_FUCHSIA)
  virtual ~WebClientHandler() = default;

  using WebClientCreatedCallback = base::OnceCallback<void(WebClientInitialStatePtr)>;
  using WebClientCreatedMojoCallback = base::OnceCallback<void(WebClientInitialStatePtr)>;

  virtual void WebClientCreated(::mojo::PendingRemote<WebClient> web_client, WebClientCreatedCallback callback) = 0;

  virtual void WebClientInitialized() = 0;

  virtual void WebClientInitializeFailed() = 0;

  virtual void CreateActorHandler(::mojo::PendingReceiver<ActorHandler> receiver, ::mojo::PendingRemote<ActorClient> client) = 0;

  virtual void CreateExperimentalTriggeringClient(::mojo::PendingRemote<ExperimentalTriggeringClient> client) = 0;

  virtual void CreateAnnotationHandler(::mojo::PendingReceiver<AnnotationHandler> receiver) = 0;

  virtual void CreateSkillsHandler(::mojo::PendingReceiver<SkillsHandler> receiver, ::mojo::PendingRemote<SkillsClient> client) = 0;

  virtual void CreateZeroStateSuggestionsHandler(::mojo::PendingReceiver<ZeroStateSuggestionsHandler> receiver) = 0;

  using CreateTabCallback = base::OnceCallback<void(TabDataPtr)>;
  using CreateTabMojoCallback = base::OnceCallback<void(TabDataPtr)>;

  virtual void CreateTab(const ::GURL& url, CreateTabOptionsPtr create_options, CreateTabCallback callback) = 0;

  using ActivateTabWithUrlCallback = base::OnceCallback<void(TabDataPtr)>;
  using ActivateTabWithUrlMojoCallback = base::OnceCallback<void(TabDataPtr)>;

  virtual void ActivateTabWithUrl(const ::GURL& exact_url, ActivateTabOptionsPtr options, ActivateTabWithUrlCallback callback) = 0;

  virtual void OpenLinkInPopup(const ::GURL& url, int32_t popup_width, int32_t popup_height) = 0;

  virtual void OpenGlicSettingsPage(OpenSettingsOptionsPtr options) = 0;

  virtual void OpenPasswordManagerSettingsPage() = 0;

  virtual void EnableDragResize(bool enabled) = 0;

  virtual void ClosePanel() = 0;

  virtual void ClosePanelAndShutdown() = 0;

  virtual void AttachPanel() = 0;

  virtual void DetachPanel() = 0;

  virtual void OnModeChange(WebClientMode new_mode) = 0;

  virtual void OnMicrophoneStatusChange(MicrophoneStatus status) = 0;

  virtual void ShowProfilePicker() = 0;

  using GetModelQualityClientIdCallback = base::OnceCallback<void(const std::string&)>;
  using GetModelQualityClientIdMojoCallback = base::OnceCallback<void(const std::string&)>;

  virtual void GetModelQualityClientId(GetModelQualityClientIdCallback callback) = 0;

  using GetContextFromFocusedTabCallback = base::OnceCallback<void(GetContextResultPtr)>;
  using GetContextFromFocusedTabMojoCallback = base::OnceCallback<void(GetContextResultPtr)>;

  virtual void GetContextFromFocusedTab(TabContextOptionsPtr options, GetContextFromFocusedTabCallback callback) = 0;

  using GetContextFromTabCallback = base::OnceCallback<void(GetContextResultPtr)>;
  using GetContextFromTabMojoCallback = base::OnceCallback<void(GetContextResultPtr)>;

  virtual void GetContextFromTab(int32_t tab_id, TabContextOptionsPtr options, GetContextFromTabCallback callback) = 0;

  using GetImageBytesFromTabCallback = base::OnceCallback<void(GetImageBytesResultPtr)>;
  using GetImageBytesFromTabMojoCallback = base::OnceCallback<void(GetImageBytesResultPtr)>;

  virtual void GetImageBytesFromTab(int32_t tab_id, const std::string& document_id, int32_t dom_node_id, GetImageBytesFromTabCallback callback) = 0;

  using SetMaximumNumberOfPinnedTabsCallback = base::OnceCallback<void(uint32_t)>;
  using SetMaximumNumberOfPinnedTabsMojoCallback = base::OnceCallback<void(uint32_t)>;

  virtual void SetMaximumNumberOfPinnedTabs(uint32_t requested_max, SetMaximumNumberOfPinnedTabsCallback callback) = 0;

  using PinTabsCallback = base::OnceCallback<void(bool)>;
  using PinTabsMojoCallback = base::OnceCallback<void(bool)>;

  virtual void PinTabs(const std::vector<int32_t>& tab_ids, PinTabsOptionsPtr options, PinTabsCallback callback) = 0;

  using UnpinTabsCallback = base::OnceCallback<void(bool)>;
  using UnpinTabsMojoCallback = base::OnceCallback<void(bool)>;

  virtual void UnpinTabs(const std::vector<int32_t>& tab_ids, UnpinTabsOptionsPtr options, UnpinTabsCallback callback) = 0;

  virtual void UnpinAllTabs(UnpinTabsOptionsPtr options) = 0;

  virtual void SubscribeToPinCandidates(GetPinCandidatesOptionsPtr options, ::mojo::PendingRemote<PinCandidatesObserver> observer) = 0;

  using OpenPinnedTabPickerCallback = base::OnceCallback<void()>;
  using OpenPinnedTabPickerMojoCallback = base::OnceCallback<void()>;

  virtual void OpenPinnedTabPicker(OpenPinnedTabPickerOptionsPtr options, OpenPinnedTabPickerCallback callback) = 0;

  virtual void ActivateTab(int32_t task_id) = 0;

  using ResizeWidgetCallback = base::OnceCallback<void()>;
  using ResizeWidgetMojoCallback = base::OnceCallback<void()>;

  virtual void ResizeWidget(const ::gfx::Size& size, ::base::TimeDelta duration, ResizeWidgetCallback callback) = 0;

  using CaptureScreenshotCallback = base::OnceCallback<void(CaptureScreenshotResultPtr)>;
  using CaptureScreenshotMojoCallback = base::OnceCallback<void(CaptureScreenshotResultPtr)>;

  virtual void CaptureScreenshot(CaptureScreenshotCallback callback) = 0;

  virtual void CaptureRegion(::mojo::PendingRemote<CaptureRegionObserver> observer, CaptureRegionParamsPtr params) = 0;

  virtual void DeleteCapturedRegion(int32_t tab_id, const ::base::UnguessableToken& id) = 0;

  using SetAudioDuckingCallback = base::OnceCallback<void(bool)>;
  using SetAudioDuckingMojoCallback = base::OnceCallback<void(bool)>;

  virtual void SetAudioDucking(bool enable, SetAudioDuckingCallback callback) = 0;

  virtual void SetMinimumPanelSize(const ::gfx::Size& size) = 0;

  using SetMicrophonePermissionStateCallback = base::OnceCallback<void()>;
  using SetMicrophonePermissionStateMojoCallback = base::OnceCallback<void()>;

  virtual void SetMicrophonePermissionState(bool enabled, SetMicrophonePermissionStateCallback callback) = 0;

  using SetLocationPermissionStateCallback = base::OnceCallback<void()>;
  using SetLocationPermissionStateMojoCallback = base::OnceCallback<void()>;

  virtual void SetLocationPermissionState(bool enabled, SetLocationPermissionStateCallback callback) = 0;

  using SetTabContextPermissionStateCallback = base::OnceCallback<void()>;
  using SetTabContextPermissionStateMojoCallback = base::OnceCallback<void()>;

  virtual void SetTabContextPermissionState(bool enabled, SetTabContextPermissionStateCallback callback) = 0;

  using SetClosedCaptioningSettingCallback = base::OnceCallback<void()>;
  using SetClosedCaptioningSettingMojoCallback = base::OnceCallback<void()>;

  virtual void SetClosedCaptioningSetting(bool enabled, SetClosedCaptioningSettingCallback callback) = 0;

  using SetActuationOnWebSettingCallback = base::OnceCallback<void()>;
  using SetActuationOnWebSettingMojoCallback = base::OnceCallback<void()>;

  virtual void SetActuationOnWebSetting(bool enabled, SetActuationOnWebSettingCallback callback) = 0;

  using ShouldAllowMediaPermissionRequestCallback = base::OnceCallback<void(bool)>;
  using ShouldAllowMediaPermissionRequestMojoCallback = base::OnceCallback<void(bool)>;

  virtual void ShouldAllowMediaPermissionRequest(ShouldAllowMediaPermissionRequestCallback callback) = 0;

  using ShouldAllowGeolocationPermissionRequestCallback = base::OnceCallback<void(bool)>;
  using ShouldAllowGeolocationPermissionRequestMojoCallback = base::OnceCallback<void(bool)>;

  virtual void ShouldAllowGeolocationPermissionRequest(ShouldAllowGeolocationPermissionRequestCallback callback) = 0;

  virtual void SetContextAccessIndicator(bool enabled) = 0;

  using GetUserProfileInfoCallback = base::OnceCallback<void(UserProfileInfoPtr)>;
  using GetUserProfileInfoMojoCallback = base::OnceCallback<void(UserProfileInfoPtr)>;

  virtual void GetUserProfileInfo(GetUserProfileInfoCallback callback) = 0;

  using SyncCookiesCallback = base::OnceCallback<void(bool)>;
  using SyncCookiesMojoCallback = base::OnceCallback<void(bool)>;

  virtual void SyncCookies(SyncCookiesCallback callback) = 0;

  virtual void ClientErrorDialogStateChanged(std::optional<ClientErrorDialogType> shown_dialog_type) = 0;

  virtual void ReportClientTransientError(::mojo_base::mojom::AbslStatusCode status_code) = 0;

  virtual void ProcessCounterAbuseVerdict(int32_t tab_id, CounterAbuseVerdictPtr verdict) = 0;

  virtual void OnOptinImpression() = 0;

  virtual void OnUserInputSubmitted(WebClientMode mode, PromptType prompt_type) = 0;

  virtual void OnContextUploadStarted() = 0;

  virtual void OnContextUploadCompleted() = 0;

  virtual void OnReaction(MetricUserInputReactionType reactionType) = 0;

  virtual void OnResponseStarted() = 0;

  virtual void OnResponseStopped(OnResponseStoppedDetailsPtr details) = 0;

  virtual void OnSessionTerminated() = 0;

  virtual void OnTurnCompleted(WebClientModel model, ::base::TimeDelta duration) = 0;

  virtual void OnResponseRated(bool positive) = 0;

  virtual void OnClosedCaptionsShown() = 0;

  virtual void OnActionSubmitted(bool is_retry) = 0;

  virtual void SetSyntheticExperimentState(const std::string& trial_name, const std::string& group_name) = 0;

  virtual void OpenOsPermissionSettingsMenu(::content_settings::mojom::ContentSettingsType type) = 0;

  using GetOsMicrophonePermissionStatusCallback = base::OnceCallback<void(bool)>;
  using GetOsMicrophonePermissionStatusMojoCallback = base::OnceCallback<void(bool)>;

  virtual void GetOsMicrophonePermissionStatus(GetOsMicrophonePermissionStatusCallback callback) = 0;

  using GetZeroStateSuggestionsForFocusedTabCallback = base::OnceCallback<void(ZeroStateSuggestionsPtr)>;
  using GetZeroStateSuggestionsForFocusedTabMojoCallback = base::OnceCallback<void(ZeroStateSuggestionsPtr)>;

  virtual void GetZeroStateSuggestionsForFocusedTab(std::optional<bool> is_first_run, GetZeroStateSuggestionsForFocusedTabCallback callback) = 0;

  virtual void MaybeRefreshUserStatus() = 0;

  using IsDebuggerAttachedCallback = base::OnceCallback<void(bool)>;
  using IsDebuggerAttachedMojoCallback = base::OnceCallback<void(bool)>;

  virtual void IsDebuggerAttached(IsDebuggerAttachedCallback callback) = 0;

  using SubscribeToPageMetadataCallback = base::OnceCallback<void(bool)>;
  using SubscribeToPageMetadataMojoCallback = base::OnceCallback<void(bool)>;

  virtual void SubscribeToPageMetadata(int32_t tab_id, const std::vector<std::string>& names, SubscribeToPageMetadataCallback callback) = 0;

  using SwitchConversationCallback = base::OnceCallback<void(std::optional<SwitchConversationErrorReason>)>;
  using SwitchConversationMojoCallback = base::OnceCallback<void(std::optional<SwitchConversationErrorReason>)>;

  virtual void SwitchConversation(ConversationInfoPtr info, SwitchConversationCallback callback) = 0;

  using RegisterConversationCallback = base::OnceCallback<void(std::optional<RegisterConversationErrorReason>)>;
  using RegisterConversationMojoCallback = base::OnceCallback<void(std::optional<RegisterConversationErrorReason>)>;

  virtual void RegisterConversation(ConversationInfoPtr info, RegisterConversationCallback callback) = 0;

  virtual void SetOnboardingCompleted() = 0;

  virtual void SubscribeToTabData(int32_t tab_id, ::mojo::PendingRemote<TabDataHandler> receiver) = 0;

  virtual void SubscribeToTabFavicon(int32_t tab_id, ::mojo::PendingRemote<TabFaviconHandler> receiver) = 0;
};

class ZeroStateSuggestionsHandlerProxy;

template <typename ImplRefTraits>
class ZeroStateSuggestionsHandlerStub;

class ZeroStateSuggestionsHandlerRequestValidator;
class ZeroStateSuggestionsHandlerResponseValidator;


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

  using Base_ = ZeroStateSuggestionsHandlerInterfaceBase;
  using Proxy_ = ZeroStateSuggestionsHandlerProxy;

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

  using RequestValidator_ = ZeroStateSuggestionsHandlerRequestValidator;
  using ResponseValidator_ = ZeroStateSuggestionsHandlerResponseValidator;
  enum MethodMinVersions : uint32_t {
    kGetZeroStateSuggestionsAndSubscribeMinVersion = 0,
  };

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

  using GetZeroStateSuggestionsAndSubscribeCallback = base::OnceCallback<void(ZeroStateSuggestionsV2Ptr)>;
  using GetZeroStateSuggestionsAndSubscribeMojoCallback = base::OnceCallback<void(ZeroStateSuggestionsV2Ptr)>;

  virtual void GetZeroStateSuggestionsAndSubscribe(::mojo::PendingRemote<ZeroStateSuggestionsClient> client, ZeroStateSuggestionsOptionsPtr options, GetZeroStateSuggestionsAndSubscribeCallback callback) = 0;
};

class ZeroStateSuggestionsClientProxy;

template <typename ImplRefTraits>
class ZeroStateSuggestionsClientStub;

class ZeroStateSuggestionsClientRequestValidator;


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

  using Base_ = ZeroStateSuggestionsClientInterfaceBase;
  using Proxy_ = ZeroStateSuggestionsClientProxy;

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

  using RequestValidator_ = ZeroStateSuggestionsClientRequestValidator;
  using ResponseValidator_ = mojo::PassThroughFilter;
  enum MethodMinVersions : uint32_t {
    kNotifyZeroStateSuggestionsChangedMinVersion = 0,
  };

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

  virtual void NotifyZeroStateSuggestionsChanged(ZeroStateSuggestionsV2Ptr suggestions, ZeroStateSuggestionsOptionsPtr options) = 0;
};

class TabDataHandlerProxy;

template <typename ImplRefTraits>
class TabDataHandlerStub;

class TabDataHandlerRequestValidator;


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

  using Base_ = TabDataHandlerInterfaceBase;
  using Proxy_ = TabDataHandlerProxy;

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

  using RequestValidator_ = TabDataHandlerRequestValidator;
  using ResponseValidator_ = mojo::PassThroughFilter;
  enum MethodMinVersions : uint32_t {
    kOnTabDataChangedMinVersion = 0,
  };

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

  virtual void OnTabDataChanged(TabDataPtr tab_data) = 0;
};

class TabFaviconHandlerProxy;

template <typename ImplRefTraits>
class TabFaviconHandlerStub;

class TabFaviconHandlerRequestValidator;


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

  using Base_ = TabFaviconHandlerInterfaceBase;
  using Proxy_ = TabFaviconHandlerProxy;

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

  using RequestValidator_ = TabFaviconHandlerRequestValidator;
  using ResponseValidator_ = mojo::PassThroughFilter;
  enum MethodMinVersions : uint32_t {
    kOnTabFaviconChangedMinVersion = 0,
  };

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

  virtual void OnTabFaviconChanged(const ::SkBitmap& favicon) = 0;
};

class ExperimentalTriggeringUpdatesHandlerProxy;

template <typename ImplRefTraits>
class ExperimentalTriggeringUpdatesHandlerStub;

class ExperimentalTriggeringUpdatesHandlerRequestValidator;


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

  using Base_ = ExperimentalTriggeringUpdatesHandlerInterfaceBase;
  using Proxy_ = ExperimentalTriggeringUpdatesHandlerProxy;

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

  using RequestValidator_ = ExperimentalTriggeringUpdatesHandlerRequestValidator;
  using ResponseValidator_ = mojo::PassThroughFilter;
  enum MethodMinVersions : uint32_t {
    kOnUpdateMinVersion = 0,
  };

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

  virtual void OnUpdate(ExperimentalTriggeringUpdatePtr update, SubscriberObservationType observation) = 0;
};

class ExperimentalTriggeringClientProxy;

template <typename ImplRefTraits>
class ExperimentalTriggeringClientStub;

class ExperimentalTriggeringClientRequestValidator;
class ExperimentalTriggeringClientResponseValidator;


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

  using Base_ = ExperimentalTriggeringClientInterfaceBase;
  using Proxy_ = ExperimentalTriggeringClientProxy;

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

  using RequestValidator_ = ExperimentalTriggeringClientRequestValidator;
  using ResponseValidator_ = ExperimentalTriggeringClientResponseValidator;
  enum MethodMinVersions : uint32_t {
    kUploadEncryptedScreenshotMinVersion = 0,
    kGetExperimentalTriggeringUpdatesMinVersion = 0,
  };

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

  using UploadEncryptedScreenshotCallback = base::OnceCallback<void(const std::optional<std::string>&)>;
  using UploadEncryptedScreenshotMojoCallback = base::OnceCallback<void(const std::optional<std::string>&)>;

  virtual void UploadEncryptedScreenshot(ScreenshotPtr screenshot, UploadEncryptedScreenshotCallback callback) = 0;

  using GetExperimentalTriggeringUpdatesCallback = base::OnceCallback<void(bool)>;
  using GetExperimentalTriggeringUpdatesMojoCallback = base::OnceCallback<void(bool)>;

  virtual void GetExperimentalTriggeringUpdates(::mojo::PendingRemote<ExperimentalTriggeringUpdatesHandler> handler, GetExperimentalTriggeringUpdatesCallback callback) = 0;
};

class WebClientProxy;

template <typename ImplRefTraits>
class WebClientStub;

class WebClientRequestValidator;
class WebClientResponseValidator;


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

  using Base_ = WebClientInterfaceBase;
  using Proxy_ = WebClientProxy;

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

  using RequestValidator_ = WebClientRequestValidator;
  using ResponseValidator_ = WebClientResponseValidator;
  enum MethodMinVersions : uint32_t {
    kCheckResponsiveMinVersion = 0,
    kNotifyPanelWillOpenMinVersion = 0,
    kNotifyPanelWasClosedMinVersion = 0,
    kNotifyPanelStateChangeMinVersion = 0,
    kNotifyPanelActiveChangeMinVersion = 0,
    kNotifyPanelCanAttachChangeMinVersion = 0,
    kNotifyMicrophonePermissionStateChangedMinVersion = 0,
    kNotifyFileUploadStateChangedMinVersion = 0,
    kStopMicrophoneMinVersion = 0,
    kNotifyLocationPermissionStateChangedMinVersion = 0,
    kNotifyTabContextPermissionStateChangedMinVersion = 0,
    kNotifyOsLocationPermissionStateChangedMinVersion = 0,
    kNotifyFocusedTabChangedMinVersion = 0,
    kNotifyManualResizeChangedMinVersion = 0,
    kNotifyOsHotkeyStateChangedMinVersion = 0,
    kNotifyBrowserIsOpenChangedMinVersion = 0,
    kNotifyZoomLevelChangedMinVersion = 0,
    kNotifyInstanceActivationChangedMinVersion = 0,
    kNotifyClosedCaptioningSettingChangedMinVersion = 0,
    kNotifyPinnedTabsChangedMinVersion = 0,
    kNotifyPinnedTabDataChangedMinVersion = 0,
    kNotifyPageMetadataChangedMinVersion = 0,
    kNotifyDefaultTabContextPermissionStateChangedMinVersion = 0,
    kNotifyAdditionalContextMinVersion = 0,
    kNotifyActuationOnWebSettingChangedMinVersion = 0,
    kNotifyActOnWebCapabilityChangedMinVersion = 0,
    kNotifyOnboardingCompletedChangedMinVersion = 0,
    kNotifyGeminiEnterpriseSettingsChangedMinVersion = 0,
    kNotifyActorTaskListRowClickedMinVersion = 0,
    kInvokeMinVersion = 0,
  };

// crbug.com/1340245 - this causes binary size bloat on Fuchsia, and we're OK
// with not having this data in traces there.
#if !BUILDFLAG(IS_FUCHSIA)
  struct CheckResponsive_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct NotifyPanelWillOpen_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct NotifyPanelWasClosed_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct NotifyPanelStateChange_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct NotifyPanelActiveChange_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct NotifyPanelCanAttachChange_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct NotifyMicrophonePermissionStateChanged_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct NotifyFileUploadStateChanged_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct StopMicrophone_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct NotifyLocationPermissionStateChanged_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct NotifyTabContextPermissionStateChanged_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct NotifyOsLocationPermissionStateChanged_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct NotifyFocusedTabChanged_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct NotifyManualResizeChanged_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct NotifyOsHotkeyStateChanged_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct NotifyBrowserIsOpenChanged_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct NotifyZoomLevelChanged_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct NotifyInstanceActivationChanged_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct NotifyClosedCaptioningSettingChanged_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct NotifyPinnedTabsChanged_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct NotifyPinnedTabDataChanged_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct NotifyPageMetadataChanged_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct NotifyDefaultTabContextPermissionStateChanged_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct NotifyAdditionalContext_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct NotifyActuationOnWebSettingChanged_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct NotifyActOnWebCapabilityChanged_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct NotifyOnboardingCompletedChanged_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct NotifyGeminiEnterpriseSettingsChanged_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct NotifyActorTaskListRowClicked_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct Invoke_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
#endif // !BUILDFLAG(IS_FUCHSIA)
  virtual ~WebClient() = default;

  using CheckResponsiveCallback = base::OnceCallback<void()>;
  using CheckResponsiveMojoCallback = base::OnceCallback<void()>;

  virtual void CheckResponsive(CheckResponsiveCallback callback) = 0;

  using NotifyPanelWillOpenCallback = base::OnceCallback<void(OpenPanelInfoPtr)>;
  using NotifyPanelWillOpenMojoCallback = base::OnceCallback<void(OpenPanelInfoPtr)>;

  virtual void NotifyPanelWillOpen(PanelOpeningDataPtr panel_opening_data, NotifyPanelWillOpenCallback callback) = 0;

  using NotifyPanelWasClosedCallback = base::OnceCallback<void()>;
  using NotifyPanelWasClosedMojoCallback = base::OnceCallback<void()>;

  virtual void NotifyPanelWasClosed(NotifyPanelWasClosedCallback callback) = 0;

  virtual void NotifyPanelStateChange(PanelStatePtr panel_state) = 0;

  virtual void NotifyPanelActiveChange(bool panel_active) = 0;

  virtual void NotifyPanelCanAttachChange(bool can_attach) = 0;

  virtual void NotifyMicrophonePermissionStateChanged(bool enabled) = 0;

  virtual void NotifyFileUploadStateChanged(FileUploadPolicyState state) = 0;

  using StopMicrophoneCallback = base::OnceCallback<void()>;
  using StopMicrophoneMojoCallback = base::OnceCallback<void()>;

  virtual void StopMicrophone(StopMicrophoneCallback callback) = 0;

  virtual void NotifyLocationPermissionStateChanged(bool enabled) = 0;

  virtual void NotifyTabContextPermissionStateChanged(bool enabled) = 0;

  virtual void NotifyOsLocationPermissionStateChanged(bool enabled) = 0;

  virtual void NotifyFocusedTabChanged(FocusedTabDataPtr focused_tab_data) = 0;

  virtual void NotifyManualResizeChanged(bool resizing) = 0;

  virtual void NotifyOsHotkeyStateChanged(const std::string& hotkey) = 0;

  virtual void NotifyBrowserIsOpenChanged(bool browser_is_open) = 0;

  virtual void NotifyZoomLevelChanged(double zoom_factor) = 0;

  virtual void NotifyInstanceActivationChanged(bool instance_active) = 0;

  virtual void NotifyClosedCaptioningSettingChanged(bool enabled) = 0;

  virtual void NotifyPinnedTabsChanged(std::vector<TabDataPtr> tab_data) = 0;

  virtual void NotifyPinnedTabDataChanged(TabDataPtr tab_data) = 0;

  virtual void NotifyPageMetadataChanged(int32_t tab_id, ::blink::mojom::PageMetadataPtr metadata) = 0;

  virtual void NotifyDefaultTabContextPermissionStateChanged(bool enabled) = 0;

  virtual void NotifyAdditionalContext(AdditionalContextPtr context) = 0;

  virtual void NotifyActuationOnWebSettingChanged(bool enabled) = 0;

  virtual void NotifyActOnWebCapabilityChanged(bool can_act_on_web) = 0;

  virtual void NotifyOnboardingCompletedChanged(bool completed) = 0;

  virtual void NotifyGeminiEnterpriseSettingsChanged(GeminiEnterpriseSettingsPtr settings) = 0;

  virtual void NotifyActorTaskListRowClicked(int32_t task_id) = 0;

  using InvokeCallback = base::OnceCallback<void()>;
  using InvokeMojoCallback = base::OnceCallback<void()>;

  virtual void Invoke(InvokeOptionsPtr options, InvokeCallback callback) = 0;
};

class CaptureRegionObserverProxy;

template <typename ImplRefTraits>
class CaptureRegionObserverStub;

class CaptureRegionObserverRequestValidator;


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

  using Base_ = CaptureRegionObserverInterfaceBase;
  using Proxy_ = CaptureRegionObserverProxy;

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

  using RequestValidator_ = CaptureRegionObserverRequestValidator;
  using ResponseValidator_ = mojo::PassThroughFilter;
  enum MethodMinVersions : uint32_t {
    kOnUpdateMinVersion = 0,
  };

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

  virtual void OnUpdate(CaptureRegionResultPtr result, std::optional<CaptureRegionErrorReason> reason) = 0;
};



class  PinCandidatesObserverProxy
    : public PinCandidatesObserver {
 public:
  using InterfaceType = PinCandidatesObserver;

  explicit PinCandidatesObserverProxy(mojo::MessageReceiverWithResponder* receiver);
  
  void OnPinCandidatesChanged(std::vector<PinCandidatePtr> candidates) final;

 private:
  mojo::MessageReceiverWithResponder* receiver_;
};



class  ActorClientProxy
    : public ActorClient {
 public:
  using InterfaceType = ActorClient;

  explicit ActorClientProxy(mojo::MessageReceiverWithResponder* receiver);
  
  void RequestToShowCredentialSelectionDialog(::actor::webui::mojom::SelectCredentialDialogRequestPtr request, RequestToShowCredentialSelectionDialogCallback callback) final;
  
  void RequestToShowAutofillSuggestionsDialog(::actor::webui::mojom::SelectAutofillSuggestionsDialogRequestPtr request, RequestToShowAutofillSuggestionsDialogCallback callback) final;
  
  void RequestToShowUserConfirmationDialog(::actor::webui::mojom::UserConfirmationDialogRequestPtr request, RequestToShowUserConfirmationDialogCallback callback) final;
  
  void RequestToConfirmNavigation(::actor::webui::mojom::NavigationConfirmationRequestPtr request, RequestToConfirmNavigationCallback callback) final;
  
  void NotifyActorTaskStateChanged(int32_t task_id, ActorTaskState state) final;
  
  void RequestToShowGmailOtpOptInDialog(::actor::webui::mojom::GmailOtpOptInRequestPtr request, RequestToShowGmailOtpOptInDialogCallback callback) final;
  
  void RequestToShowGmailOtpConfirmationDialog(::actor::webui::mojom::GmailOtpConfirmationRequestPtr request, RequestToShowGmailOtpConfirmationDialogCallback callback) final;

 private:
  mojo::MessageReceiverWithResponder* receiver_;
};



class  ActorHandlerProxy
    : public ActorHandler {
 public:
  using InterfaceType = ActorHandler;

  explicit ActorHandlerProxy(mojo::MessageReceiverWithResponder* receiver);
  
  void AutofillSuggestionDialogOnFormPresented(int32_t task_id, ::actor::webui::mojom::AutofillSuggestionDialogOnFormPresentedParamsPtr params) final;
  
  void AutofillSuggestionDialogOnFormPreviewChanged(int32_t task_id, ::actor::webui::mojom::AutofillSuggestionDialogOnFormPreviewChangedParamsPtr params) final;
  
  void AutofillSuggestionDialogOnFormConfirmed(int32_t task_id, ::actor::webui::mojom::AutofillSuggestionDialogOnFormConfirmedParamsPtr params) final;
  
  void GetContextForActorFromTab(int32_t tab_id, TabContextOptionsPtr options, GetContextForActorFromTabCallback callback) final;
  
  void CreateTask(::actor::webui::mojom::TaskOptionsPtr task_options, CreateTaskCallback callback) final;
  
  void PerformActions(const std::vector<uint8_t>& actions_proto, PerformActionsCallback callback) final;
  
  void CancelActions(int32_t task_id, CancelActionsCallback callback) final;
  
  void StopActorTask(int32_t task_id, ActorTaskStopReason stop_reason) final;
  
  void PauseActorTask(int32_t task_id, ActorTaskPauseReason pause_reason, std::optional<int32_t> tab_id) final;
  
  void ResumeActorTask(int32_t task_id, TabContextOptionsPtr context_options, ResumeActorTaskCallback callback) final;
  
  void InterruptActorTask(int32_t task_id, std::optional<ActorTaskInterruptReason> interrupt_reason) final;
  
  void UninterruptActorTask(int32_t task_id) final;
  
  void UpdateActorTaskStepProgress(int32_t task_id, const std::string& step_progress) final;
  
  void CreateActorTab(int32_t task_id, CreateActorTabOptionsPtr options, CreateActorTabCallback callback) final;
  
  void LogBeginAsyncEvent(uint64_t event_async_id, int32_t task_id, const std::string& event, const std::string& details) final;
  
  void LogEndAsyncEvent(uint64_t event_async_id, const std::string& details) final;
  
  void LogInstantEvent(int32_t task_id, const std::string& event, const std::string& details) final;
  
  void JournalClear() final;
  
  void JournalSnapshot(bool clear_journal, JournalSnapshotCallback callback) final;
  
  void JournalStart(uint64_t max_bytes, bool capture_screenshots) final;
  
  void JournalStop() final;
  
  void JournalRecordFeedback(bool positive, const std::string& reason) final;

 private:
  mojo::MessageReceiverWithResponder* receiver_;
};



class  AnnotationHandlerProxy
    : public AnnotationHandler {
 public:
  using InterfaceType = AnnotationHandler;

  explicit AnnotationHandlerProxy(mojo::MessageReceiverWithResponder* receiver);
  
  void ScrollTo(ScrollToParamsPtr params, ScrollToCallback callback) final;
  
  void DropScrollToHighlight() final;

 private:
  mojo::MessageReceiverWithResponder* receiver_;
};



class  SkillsHandlerProxy
    : public SkillsHandler {
 public:
  using InterfaceType = SkillsHandler;

  explicit SkillsHandlerProxy(mojo::MessageReceiverWithResponder* receiver);
  
  void CreateSkill(CreateSkillRequestPtr request, CreateSkillCallback callback) final;
  
  void UpdateSkill(UpdateSkillRequestPtr request, UpdateSkillCallback callback) final;
  
  void ShowManageSkillsUi() final;
  
  void ShowBrowseSkillsUi() final;
  
  void GetSkill(const std::string& id, GetSkillCallback callback) final;
  
  void RecordSkillsWebClientEvent(SkillsWebClientEvent event) final;

 private:
  mojo::MessageReceiverWithResponder* receiver_;
};



class  SkillsClientProxy
    : public SkillsClient {
 public:
  using InterfaceType = SkillsClient;

  explicit SkillsClientProxy(mojo::MessageReceiverWithResponder* receiver);
  
  void NotifySkillPreviewsChanged(std::vector<SkillPreviewPtr> skill_previews) final;
  
  void NotifyContextualSkillPreviewsChanged(std::vector<SkillPreviewPtr> skill_previews) final;
  
  void NotifySkillPreviewChanged(SkillPreviewPtr skill_preview) final;
  
  void NotifySkillDeleted(const std::string& skill_id) final;
  
  void NotifySkillsEnabledChanged(bool enabled) final;

 private:
  mojo::MessageReceiverWithResponder* receiver_;
};



class  WebClientHandlerProxy
    : public WebClientHandler {
 public:
  using InterfaceType = WebClientHandler;

  explicit WebClientHandlerProxy(mojo::MessageReceiverWithResponder* receiver);
  
  void WebClientCreated(::mojo::PendingRemote<WebClient> web_client, WebClientCreatedCallback callback) final;
  
  void WebClientInitialized() final;
  
  void WebClientInitializeFailed() final;
  
  void CreateActorHandler(::mojo::PendingReceiver<ActorHandler> receiver, ::mojo::PendingRemote<ActorClient> client) final;
  
  void CreateExperimentalTriggeringClient(::mojo::PendingRemote<ExperimentalTriggeringClient> client) final;
  
  void CreateAnnotationHandler(::mojo::PendingReceiver<AnnotationHandler> receiver) final;
  
  void CreateSkillsHandler(::mojo::PendingReceiver<SkillsHandler> receiver, ::mojo::PendingRemote<SkillsClient> client) final;
  
  void CreateZeroStateSuggestionsHandler(::mojo::PendingReceiver<ZeroStateSuggestionsHandler> receiver) final;
  
  void CreateTab(const ::GURL& url, CreateTabOptionsPtr create_options, CreateTabCallback callback) final;
  
  void ActivateTabWithUrl(const ::GURL& exact_url, ActivateTabOptionsPtr options, ActivateTabWithUrlCallback callback) final;
  
  void OpenLinkInPopup(const ::GURL& url, int32_t popup_width, int32_t popup_height) final;
  
  void OpenGlicSettingsPage(OpenSettingsOptionsPtr options) final;
  
  void OpenPasswordManagerSettingsPage() final;
  
  void EnableDragResize(bool enabled) final;
  
  void ClosePanel() final;
  
  void ClosePanelAndShutdown() final;
  
  void AttachPanel() final;
  
  void DetachPanel() final;
  
  void OnModeChange(WebClientMode new_mode) final;
  
  void OnMicrophoneStatusChange(MicrophoneStatus status) final;
  
  void ShowProfilePicker() final;
  
  void GetModelQualityClientId(GetModelQualityClientIdCallback callback) final;
  
  void GetContextFromFocusedTab(TabContextOptionsPtr options, GetContextFromFocusedTabCallback callback) final;
  
  void GetContextFromTab(int32_t tab_id, TabContextOptionsPtr options, GetContextFromTabCallback callback) final;
  
  void GetImageBytesFromTab(int32_t tab_id, const std::string& document_id, int32_t dom_node_id, GetImageBytesFromTabCallback callback) final;
  
  void SetMaximumNumberOfPinnedTabs(uint32_t requested_max, SetMaximumNumberOfPinnedTabsCallback callback) final;
  
  void PinTabs(const std::vector<int32_t>& tab_ids, PinTabsOptionsPtr options, PinTabsCallback callback) final;
  
  void UnpinTabs(const std::vector<int32_t>& tab_ids, UnpinTabsOptionsPtr options, UnpinTabsCallback callback) final;
  
  void UnpinAllTabs(UnpinTabsOptionsPtr options) final;
  
  void SubscribeToPinCandidates(GetPinCandidatesOptionsPtr options, ::mojo::PendingRemote<PinCandidatesObserver> observer) final;
  
  void OpenPinnedTabPicker(OpenPinnedTabPickerOptionsPtr options, OpenPinnedTabPickerCallback callback) final;
  
  void ActivateTab(int32_t task_id) final;
  
  void ResizeWidget(const ::gfx::Size& size, ::base::TimeDelta duration, ResizeWidgetCallback callback) final;
  
  void CaptureScreenshot(CaptureScreenshotCallback callback) final;
  
  void CaptureRegion(::mojo::PendingRemote<CaptureRegionObserver> observer, CaptureRegionParamsPtr params) final;
  
  void DeleteCapturedRegion(int32_t tab_id, const ::base::UnguessableToken& id) final;
  
  void SetAudioDucking(bool enable, SetAudioDuckingCallback callback) final;
  
  void SetMinimumPanelSize(const ::gfx::Size& size) final;
  
  void SetMicrophonePermissionState(bool enabled, SetMicrophonePermissionStateCallback callback) final;
  
  void SetLocationPermissionState(bool enabled, SetLocationPermissionStateCallback callback) final;
  
  void SetTabContextPermissionState(bool enabled, SetTabContextPermissionStateCallback callback) final;
  
  void SetClosedCaptioningSetting(bool enabled, SetClosedCaptioningSettingCallback callback) final;
  
  void SetActuationOnWebSetting(bool enabled, SetActuationOnWebSettingCallback callback) final;
  
  void ShouldAllowMediaPermissionRequest(ShouldAllowMediaPermissionRequestCallback callback) final;
  
  void ShouldAllowGeolocationPermissionRequest(ShouldAllowGeolocationPermissionRequestCallback callback) final;
  
  void SetContextAccessIndicator(bool enabled) final;
  
  void GetUserProfileInfo(GetUserProfileInfoCallback callback) final;
  
  void SyncCookies(SyncCookiesCallback callback) final;
  
  void ClientErrorDialogStateChanged(std::optional<ClientErrorDialogType> shown_dialog_type) final;
  
  void ReportClientTransientError(::mojo_base::mojom::AbslStatusCode status_code) final;
  
  void ProcessCounterAbuseVerdict(int32_t tab_id, CounterAbuseVerdictPtr verdict) final;
  
  void OnOptinImpression() final;
  
  void OnUserInputSubmitted(WebClientMode mode, PromptType prompt_type) final;
  
  void OnContextUploadStarted() final;
  
  void OnContextUploadCompleted() final;
  
  void OnReaction(MetricUserInputReactionType reactionType) final;
  
  void OnResponseStarted() final;
  
  void OnResponseStopped(OnResponseStoppedDetailsPtr details) final;
  
  void OnSessionTerminated() final;
  
  void OnTurnCompleted(WebClientModel model, ::base::TimeDelta duration) final;
  
  void OnResponseRated(bool positive) final;
  
  void OnClosedCaptionsShown() final;
  
  void OnActionSubmitted(bool is_retry) final;
  
  void SetSyntheticExperimentState(const std::string& trial_name, const std::string& group_name) final;
  
  void OpenOsPermissionSettingsMenu(::content_settings::mojom::ContentSettingsType type) final;
  
  void GetOsMicrophonePermissionStatus(GetOsMicrophonePermissionStatusCallback callback) final;
  
  void GetZeroStateSuggestionsForFocusedTab(std::optional<bool> is_first_run, GetZeroStateSuggestionsForFocusedTabCallback callback) final;
  
  void MaybeRefreshUserStatus() final;
  
  void IsDebuggerAttached(IsDebuggerAttachedCallback callback) final;
  
  void SubscribeToPageMetadata(int32_t tab_id, const std::vector<std::string>& names, SubscribeToPageMetadataCallback callback) final;
  
  void SwitchConversation(ConversationInfoPtr info, SwitchConversationCallback callback) final;
  
  void RegisterConversation(ConversationInfoPtr info, RegisterConversationCallback callback) final;
  
  void SetOnboardingCompleted() final;
  
  void SubscribeToTabData(int32_t tab_id, ::mojo::PendingRemote<TabDataHandler> receiver) final;
  
  void SubscribeToTabFavicon(int32_t tab_id, ::mojo::PendingRemote<TabFaviconHandler> receiver) final;

 private:
  mojo::MessageReceiverWithResponder* receiver_;
};



class  ZeroStateSuggestionsHandlerProxy
    : public ZeroStateSuggestionsHandler {
 public:
  using InterfaceType = ZeroStateSuggestionsHandler;

  explicit ZeroStateSuggestionsHandlerProxy(mojo::MessageReceiverWithResponder* receiver);
  
  void GetZeroStateSuggestionsAndSubscribe(::mojo::PendingRemote<ZeroStateSuggestionsClient> client, ZeroStateSuggestionsOptionsPtr options, GetZeroStateSuggestionsAndSubscribeCallback callback) final;

 private:
  mojo::MessageReceiverWithResponder* receiver_;
};



class  ZeroStateSuggestionsClientProxy
    : public ZeroStateSuggestionsClient {
 public:
  using InterfaceType = ZeroStateSuggestionsClient;

  explicit ZeroStateSuggestionsClientProxy(mojo::MessageReceiverWithResponder* receiver);
  
  void NotifyZeroStateSuggestionsChanged(ZeroStateSuggestionsV2Ptr suggestions, ZeroStateSuggestionsOptionsPtr options) final;

 private:
  mojo::MessageReceiverWithResponder* receiver_;
};



class  TabDataHandlerProxy
    : public TabDataHandler {
 public:
  using InterfaceType = TabDataHandler;

  explicit TabDataHandlerProxy(mojo::MessageReceiverWithResponder* receiver);
  
  void OnTabDataChanged(TabDataPtr tab_data) final;

 private:
  mojo::MessageReceiverWithResponder* receiver_;
};



class  TabFaviconHandlerProxy
    : public TabFaviconHandler {
 public:
  using InterfaceType = TabFaviconHandler;

  explicit TabFaviconHandlerProxy(mojo::MessageReceiverWithResponder* receiver);
  
  void OnTabFaviconChanged(const ::SkBitmap& favicon) final;

 private:
  mojo::MessageReceiverWithResponder* receiver_;
};



class  ExperimentalTriggeringUpdatesHandlerProxy
    : public ExperimentalTriggeringUpdatesHandler {
 public:
  using InterfaceType = ExperimentalTriggeringUpdatesHandler;

  explicit ExperimentalTriggeringUpdatesHandlerProxy(mojo::MessageReceiverWithResponder* receiver);
  
  void OnUpdate(ExperimentalTriggeringUpdatePtr update, SubscriberObservationType observation) final;

 private:
  mojo::MessageReceiverWithResponder* receiver_;
};



class  ExperimentalTriggeringClientProxy
    : public ExperimentalTriggeringClient {
 public:
  using InterfaceType = ExperimentalTriggeringClient;

  explicit ExperimentalTriggeringClientProxy(mojo::MessageReceiverWithResponder* receiver);
  
  void UploadEncryptedScreenshot(ScreenshotPtr screenshot, UploadEncryptedScreenshotCallback callback) final;
  
  void GetExperimentalTriggeringUpdates(::mojo::PendingRemote<ExperimentalTriggeringUpdatesHandler> handler, GetExperimentalTriggeringUpdatesCallback callback) final;

 private:
  mojo::MessageReceiverWithResponder* receiver_;
};



class  WebClientProxy
    : public WebClient {
 public:
  using InterfaceType = WebClient;

  explicit WebClientProxy(mojo::MessageReceiverWithResponder* receiver);
  
  void CheckResponsive(CheckResponsiveCallback callback) final;
  
  void NotifyPanelWillOpen(PanelOpeningDataPtr panel_opening_data, NotifyPanelWillOpenCallback callback) final;
  
  void NotifyPanelWasClosed(NotifyPanelWasClosedCallback callback) final;
  
  void NotifyPanelStateChange(PanelStatePtr panel_state) final;
  
  void NotifyPanelActiveChange(bool panel_active) final;
  
  void NotifyPanelCanAttachChange(bool can_attach) final;
  
  void NotifyMicrophonePermissionStateChanged(bool enabled) final;
  
  void NotifyFileUploadStateChanged(FileUploadPolicyState state) final;
  
  void StopMicrophone(StopMicrophoneCallback callback) final;
  
  void NotifyLocationPermissionStateChanged(bool enabled) final;
  
  void NotifyTabContextPermissionStateChanged(bool enabled) final;
  
  void NotifyOsLocationPermissionStateChanged(bool enabled) final;
  
  void NotifyFocusedTabChanged(FocusedTabDataPtr focused_tab_data) final;
  
  void NotifyManualResizeChanged(bool resizing) final;
  
  void NotifyOsHotkeyStateChanged(const std::string& hotkey) final;
  
  void NotifyBrowserIsOpenChanged(bool browser_is_open) final;
  
  void NotifyZoomLevelChanged(double zoom_factor) final;
  
  void NotifyInstanceActivationChanged(bool instance_active) final;
  
  void NotifyClosedCaptioningSettingChanged(bool enabled) final;
  
  void NotifyPinnedTabsChanged(std::vector<TabDataPtr> tab_data) final;
  
  void NotifyPinnedTabDataChanged(TabDataPtr tab_data) final;
  
  void NotifyPageMetadataChanged(int32_t tab_id, ::blink::mojom::PageMetadataPtr metadata) final;
  
  void NotifyDefaultTabContextPermissionStateChanged(bool enabled) final;
  
  void NotifyAdditionalContext(AdditionalContextPtr context) final;
  
  void NotifyActuationOnWebSettingChanged(bool enabled) final;
  
  void NotifyActOnWebCapabilityChanged(bool can_act_on_web) final;
  
  void NotifyOnboardingCompletedChanged(bool completed) final;
  
  void NotifyGeminiEnterpriseSettingsChanged(GeminiEnterpriseSettingsPtr settings) final;
  
  void NotifyActorTaskListRowClicked(int32_t task_id) final;
  
  void Invoke(InvokeOptionsPtr options, InvokeCallback callback) final;

 private:
  mojo::MessageReceiverWithResponder* receiver_;
};



class  CaptureRegionObserverProxy
    : public CaptureRegionObserver {
 public:
  using InterfaceType = CaptureRegionObserver;

  explicit CaptureRegionObserverProxy(mojo::MessageReceiverWithResponder* receiver);
  
  void OnUpdate(CaptureRegionResultPtr result, std::optional<CaptureRegionErrorReason> reason) final;

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

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

  PinCandidatesObserverStub() = default;
  ~PinCandidatesObserverStub() override = default;

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

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

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

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

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

  ActorClientStub() = default;
  ~ActorClientStub() override = default;

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

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

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

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

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

  ActorHandlerStub() = default;
  ~ActorHandlerStub() override = default;

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

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

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

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

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

  AnnotationHandlerStub() = default;
  ~AnnotationHandlerStub() override = default;

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

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

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

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

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

  SkillsHandlerStub() = default;
  ~SkillsHandlerStub() override = default;

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

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

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

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

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

  SkillsClientStub() = default;
  ~SkillsClientStub() override = default;

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

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

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

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

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

  WebClientHandlerStub() = default;
  ~WebClientHandlerStub() override = default;

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

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

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

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

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

  ZeroStateSuggestionsHandlerStub() = default;
  ~ZeroStateSuggestionsHandlerStub() override = default;

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

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

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

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

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

  ZeroStateSuggestionsClientStub() = default;
  ~ZeroStateSuggestionsClientStub() override = default;

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

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

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

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

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

  TabDataHandlerStub() = default;
  ~TabDataHandlerStub() override = default;

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

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

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

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

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

  TabFaviconHandlerStub() = default;
  ~TabFaviconHandlerStub() override = default;

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

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

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

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

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

  ExperimentalTriggeringUpdatesHandlerStub() = default;
  ~ExperimentalTriggeringUpdatesHandlerStub() override = default;

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

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

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

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

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

  ExperimentalTriggeringClientStub() = default;
  ~ExperimentalTriggeringClientStub() override = default;

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

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

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

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

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

  WebClientStub() = default;
  ~WebClientStub() override = default;

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

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

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

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

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

  CaptureRegionObserverStub() = default;
  ~CaptureRegionObserverStub() override = default;

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

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

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

 private:
  ImplPointerType sink_;
};
class  PinCandidatesObserverRequestValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class  ActorClientRequestValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class  ActorHandlerRequestValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class  AnnotationHandlerRequestValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class  SkillsHandlerRequestValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class  SkillsClientRequestValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class  WebClientHandlerRequestValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class  ZeroStateSuggestionsHandlerRequestValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class  ZeroStateSuggestionsClientRequestValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class  TabDataHandlerRequestValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class  TabFaviconHandlerRequestValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class  ExperimentalTriggeringUpdatesHandlerRequestValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class  ExperimentalTriggeringClientRequestValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class  WebClientRequestValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class  CaptureRegionObserverRequestValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class  ActorClientResponseValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class  ActorHandlerResponseValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class  AnnotationHandlerResponseValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class  SkillsHandlerResponseValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class  WebClientHandlerResponseValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class  ZeroStateSuggestionsHandlerResponseValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class  ExperimentalTriggeringClientResponseValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class  WebClientResponseValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};





class  GeminiEnterpriseSettings {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<GeminiEnterpriseSettings, T>::value>;
  using DataView = GeminiEnterpriseSettingsDataView;
  using Data_ = internal::GeminiEnterpriseSettings_Data;

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

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

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


  GeminiEnterpriseSettings();

  GeminiEnterpriseSettings(
      const std::string& project_id,
      const std::string& app_id,
      const std::string& location);


  ~GeminiEnterpriseSettings();

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

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

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

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

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

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

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

  
  std::string project_id;
  
  std::string app_id;
  
  std::string location;

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

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

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

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







class  DefaultConversation {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<DefaultConversation, T>::value>;
  using DataView = DefaultConversationDataView;
  using Data_ = internal::DefaultConversation_Data;

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

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

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


  DefaultConversation();


  ~DefaultConversation();

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

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

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

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

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

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

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


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

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

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

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





class  NewConversation {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<NewConversation, T>::value>;
  using DataView = NewConversationDataView;
  using Data_ = internal::NewConversation_Data;

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

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

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


  NewConversation();


  ~NewConversation();

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

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

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

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

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

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

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


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

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

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

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





class  DefaultSurfaceMojo {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<DefaultSurfaceMojo, T>::value>;
  using DataView = DefaultSurfaceMojoDataView;
  using Data_ = internal::DefaultSurfaceMojo_Data;

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

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

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


  DefaultSurfaceMojo();


  ~DefaultSurfaceMojo();

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

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

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

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

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

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

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


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

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

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

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





class  NewTabMojo {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<NewTabMojo, T>::value>;
  using DataView = NewTabMojoDataView;
  using Data_ = internal::NewTabMojo_Data;

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

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

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


  NewTabMojo();

  explicit NewTabMojo(
      bool open_in_foreground);


  ~NewTabMojo();

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

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

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

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

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

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

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

  
  bool open_in_foreground;

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

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

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

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





class  ZssConfig {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<ZssConfig, T>::value>;
  using DataView = ZssConfigDataView;
  using Data_ = internal::ZssConfig_Data;

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

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

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


  ZssConfig();

  explicit ZssConfig(
      const std::optional<std::string>& additional_content);


  ~ZssConfig();

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

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

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

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

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

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

  
  std::optional<std::string> additional_content;

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

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

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

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







class  SafeBrowsingVerdict {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<SafeBrowsingVerdict, T>::value>;
  using DataView = SafeBrowsingVerdictDataView;
  using Data_ = internal::SafeBrowsingVerdict_Data;

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

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

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


  SafeBrowsingVerdict();

  SafeBrowsingVerdict(
      const std::string& url,
      SbThreatType threat_type,
      bool show_interstitial);


  ~SafeBrowsingVerdict();

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

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

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

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

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

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

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

  
  std::string url;
  
  SbThreatType threat_type;
  
  bool show_interstitial;

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

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

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

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







class  ScreenshotCollectionOptions {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<ScreenshotCollectionOptions, T>::value>;
  using DataView = ScreenshotCollectionOptionsDataView;
  using Data_ = internal::ScreenshotCollectionOptions_Data;

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

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

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


  ScreenshotCollectionOptions();

  ScreenshotCollectionOptions(
      uint32_t max_width,
      uint32_t max_height,
      ::page_content_annotations::ScreenshotOptions::ScreenshotImageFormat screenshot_image_format,
      ::page_content_annotations::ScreenshotOptions::ScreenshotCompressionQuality screenshot_compression_quality);


  ~ScreenshotCollectionOptions();

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

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

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

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

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

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

  
  uint32_t max_width;
  
  uint32_t max_height;
  
  ::page_content_annotations::ScreenshotOptions::ScreenshotImageFormat screenshot_image_format;
  
  ::page_content_annotations::ScreenshotOptions::ScreenshotCompressionQuality screenshot_compression_quality;

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

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

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

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






class  GetPinCandidatesOptions {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<GetPinCandidatesOptions, T>::value>;
  using DataView = GetPinCandidatesOptionsDataView;
  using Data_ = internal::GetPinCandidatesOptions_Data;

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

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

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


  GetPinCandidatesOptions();

  GetPinCandidatesOptions(
      uint32_t max_candidates,
      const std::optional<std::string>& query);


  ~GetPinCandidatesOptions();

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

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

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

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

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

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

  
  uint32_t max_candidates;
  
  std::optional<std::string> query;

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

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

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

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






class  ScrollToTextSelector {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<ScrollToTextSelector, T>::value>;
  using DataView = ScrollToTextSelectorDataView;
  using Data_ = internal::ScrollToTextSelector_Data;

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

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

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


  ScrollToTextSelector();

  ScrollToTextSelector(
      const std::string& text,
      std::optional<int32_t> search_range_start_node_id);


  ~ScrollToTextSelector();

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

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

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

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

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

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

  
  std::string text;
  
  std::optional<int32_t> search_range_start_node_id;

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

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

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, ScrollToTextSelector::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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





class  ScrollToTextFragmentSelector {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<ScrollToTextFragmentSelector, T>::value>;
  using DataView = ScrollToTextFragmentSelectorDataView;
  using Data_ = internal::ScrollToTextFragmentSelector_Data;

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

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

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


  ScrollToTextFragmentSelector();

  ScrollToTextFragmentSelector(
      const std::string& text_start,
      const std::string& text_end,
      std::optional<int32_t> search_range_start_node_id);


  ~ScrollToTextFragmentSelector();

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

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

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

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

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

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

  
  std::string text_start;
  
  std::string text_end;
  
  std::optional<int32_t> search_range_start_node_id;

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

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

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, ScrollToTextFragmentSelector::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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





class  ScrollToNodeSelector {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<ScrollToNodeSelector, T>::value>;
  using DataView = ScrollToNodeSelectorDataView;
  using Data_ = internal::ScrollToNodeSelector_Data;

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

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

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


  ScrollToNodeSelector();

  explicit ScrollToNodeSelector(
      int32_t node_id);


  ~ScrollToNodeSelector();

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

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

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

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

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

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

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

  
  int32_t node_id;

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

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

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, ScrollToNodeSelector::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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





class  SuggestionContent {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<SuggestionContent, T>::value>;
  using DataView = SuggestionContentDataView;
  using Data_ = internal::SuggestionContent_Data;

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

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

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


  SuggestionContent();

  explicit SuggestionContent(
      const std::string& suggestion);


  ~SuggestionContent();

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

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

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

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

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

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

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

  
  std::string suggestion;

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

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

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

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








class  UpdateSkillRequest {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<UpdateSkillRequest, T>::value>;
  using DataView = UpdateSkillRequestDataView;
  using Data_ = internal::UpdateSkillRequest_Data;

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

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

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


  UpdateSkillRequest();

  explicit UpdateSkillRequest(
      const std::string& id);


  ~UpdateSkillRequest();

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

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

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

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

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

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

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

  
  std::string id;

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

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

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, UpdateSkillRequest::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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









class  PinTabsOptions {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<PinTabsOptions, T>::value>;
  using DataView = PinTabsOptionsDataView;
  using Data_ = internal::PinTabsOptions_Data;

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

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

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


  PinTabsOptions();

  explicit PinTabsOptions(
      PinTrigger pin_trigger);


  ~PinTabsOptions();

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

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

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

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

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

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

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

  
  PinTrigger pin_trigger;

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

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

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

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





class  UnpinTabsOptions {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<UnpinTabsOptions, T>::value>;
  using DataView = UnpinTabsOptionsDataView;
  using Data_ = internal::UnpinTabsOptions_Data;

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

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

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


  UnpinTabsOptions();

  explicit UnpinTabsOptions(
      UnpinTrigger unpin_trigger);


  ~UnpinTabsOptions();

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

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

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

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

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

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

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

  
  UnpinTrigger unpin_trigger;

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

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

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

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





class  OpenPinnedTabPickerOptions {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<OpenPinnedTabPickerOptions, T>::value>;
  using DataView = OpenPinnedTabPickerOptionsDataView;
  using Data_ = internal::OpenPinnedTabPickerOptions_Data;

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

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

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


  OpenPinnedTabPickerOptions();


  ~OpenPinnedTabPickerOptions();

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

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

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

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

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

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

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


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

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

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

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





class  CreateActorTabOptions {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<CreateActorTabOptions, T>::value>;
  using DataView = CreateActorTabOptionsDataView;
  using Data_ = internal::CreateActorTabOptions_Data;

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

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

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


  CreateActorTabOptions();

  CreateActorTabOptions(
      std::optional<int32_t> initiator_tab_id,
      std::optional<int32_t> initiator_window_id,
      bool open_in_background);


  ~CreateActorTabOptions();

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

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

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

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

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

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

  
  std::optional<int32_t> initiator_tab_id;
  
  std::optional<int32_t> initiator_window_id;
  
  bool open_in_background;

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

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

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

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






class  ActivateTabOptions {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<ActivateTabOptions, T>::value>;
  using DataView = ActivateTabOptionsDataView;
  using Data_ = internal::ActivateTabOptions_Data;

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

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

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


  ActivateTabOptions();

  ActivateTabOptions(
      const std::string& pattern,
      std::optional<int32_t> fallback_window_id);


  ~ActivateTabOptions();

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

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

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

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

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

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

  
  std::string pattern;
  
  std::optional<int32_t> fallback_window_id;

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

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

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, ActivateTabOptions::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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





class  CreateTabOptions {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<CreateTabOptions, T>::value>;
  using DataView = CreateTabOptionsDataView;
  using Data_ = internal::CreateTabOptions_Data;

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

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

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


  CreateTabOptions();

  CreateTabOptions(
      bool open_in_background,
      std::optional<int32_t> window_id);


  ~CreateTabOptions();

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

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

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

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

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

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

  
  bool open_in_background;
  
  std::optional<int32_t> window_id;

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

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

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, CreateTabOptions::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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







class  PanelState {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<PanelState, T>::value>;
  using DataView = PanelStateDataView;
  using Data_ = internal::PanelState_Data;

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

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

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


  PanelState();

  PanelState(
      PanelStateKind kind,
      std::optional<int32_t> window_id);


  ~PanelState();

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

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

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

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

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

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

  
  PanelStateKind kind;
  
  std::optional<int32_t> window_id;

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

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

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, PanelState::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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





class  SkillsPayload {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<SkillsPayload, T>::value>;
  using DataView = SkillsPayloadDataView;
  using Data_ = internal::SkillsPayload_Data;

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

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

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


  SkillsPayload();

  SkillsPayload(
      const std::string& skill_id,
      const std::string& skill_name,
      const std::string& skill_icon);


  ~SkillsPayload();

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

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

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

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

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

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

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

  
  std::string skill_id;
  
  std::string skill_name;
  
  std::string skill_icon;

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

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

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

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







class  OnResponseStoppedDetails {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<OnResponseStoppedDetails, T>::value>;
  using DataView = OnResponseStoppedDetailsDataView;
  using Data_ = internal::OnResponseStoppedDetails_Data;

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

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

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


  OnResponseStoppedDetails();

  explicit OnResponseStoppedDetails(
      ResponseStopCause cause);


  ~OnResponseStoppedDetails();

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

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

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

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

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

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

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

  
  ResponseStopCause cause;

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

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

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

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







class  ParentConversationMetadata {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<ParentConversationMetadata, T>::value>;
  using DataView = ParentConversationMetadataDataView;
  using Data_ = internal::ParentConversationMetadata_Data;

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

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

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


  ParentConversationMetadata();

  ParentConversationMetadata(
      const std::optional<std::string>& conversation_id,
      const std::optional<std::string>& conversation_title);


  ~ParentConversationMetadata();

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

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

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

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

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

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

  
  std::optional<std::string> conversation_id;
  
  std::optional<std::string> conversation_title;

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

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

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

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














class  ImageOriginAnnotations {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<ImageOriginAnnotations, T>::value>;
  using DataView = ImageOriginAnnotationsDataView;
  using Data_ = internal::ImageOriginAnnotations_Data;

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

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

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


  ImageOriginAnnotations();


  ~ImageOriginAnnotations();

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

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

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

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

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

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

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


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

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

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

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











class  OpenSettingsOptions {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<OpenSettingsOptions, T>::value>;
  using DataView = OpenSettingsOptionsDataView;
  using Data_ = internal::OpenSettingsOptions_Data;

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

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

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


  OpenSettingsOptions();

  explicit OpenSettingsOptions(
      SettingsPageField highlightField);


  ~OpenSettingsOptions();

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

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

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

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

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

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

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

  
  SettingsPageField highlightField;

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

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

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

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





class  InvokeConversationSelection {
 public:
  using DataView = InvokeConversationSelectionDataView;
  using Data_ = internal::InvokeConversationSelection_Data;
  using Tag = Data_::InvokeConversationSelection_Tag;

  template <typename... Args>
  static InvokeConversationSelectionPtr 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 |default_conversation|.
  static InvokeConversationSelectionPtr NewDefaultConversation(
      DefaultConversationPtr value);
  // Construct an instance holding |new_conversation|.
  static InvokeConversationSelectionPtr NewNewConversation(
      NewConversationPtr value);
  // Construct an instance holding |conversation_id|.
  static InvokeConversationSelectionPtr NewConversationId(
      const std::string& value);

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

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

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

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

  Tag which() const {
    return tag_;
  }

  bool is_default_conversation() const { return tag_ == Tag::kDefaultConversation; }
  const DefaultConversationPtr& get_default_conversation() const {
    CHECK(tag_ == Tag::kDefaultConversation);
    return data_.default_conversation;
  }
  DefaultConversationPtr& get_default_conversation() {
    CHECK(tag_ == Tag::kDefaultConversation);
    return data_.default_conversation;
  }
  void set_default_conversation(DefaultConversationPtr default_conversation);

  bool is_new_conversation() const { return tag_ == Tag::kNewConversation; }
  const NewConversationPtr& get_new_conversation() const {
    CHECK(tag_ == Tag::kNewConversation);
    return data_.new_conversation;
  }
  NewConversationPtr& get_new_conversation() {
    CHECK(tag_ == Tag::kNewConversation);
    return data_.new_conversation;
  }
  void set_new_conversation(NewConversationPtr new_conversation);

  bool is_conversation_id() const { return tag_ == Tag::kConversationId; }
  const std::string& get_conversation_id() const {
    CHECK(tag_ == Tag::kConversationId);
    return data_.conversation_id;
  }
  std::string& get_conversation_id() {
    CHECK(tag_ == Tag::kConversationId);
    return data_.conversation_id;
  }
  void set_conversation_id(const std::string& conversation_id);

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

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    return mojo::internal::DeserializeImpl<InvokeConversationSelection::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::kDefaultConversation)>,
        DefaultConversationPtr value);
    Union_(
        std::in_place_index_t<static_cast<size_t>(Tag::kNewConversation)>,
        NewConversationPtr value);
    Union_(
        std::in_place_index_t<static_cast<size_t>(Tag::kConversationId)>,
        const std::string& value);
    // The contents of the union are explicitly destroyed by `DestroyActive()`.
    ~Union_() {}

    DefaultConversationPtr default_conversation;
    NewConversationPtr new_conversation;
    std::string conversation_id;
  };

  InvokeConversationSelection(
      std::in_place_index_t<static_cast<size_t>(Tag::kDefaultConversation)>,
      DefaultConversationPtr value);
  InvokeConversationSelection(
      std::in_place_index_t<static_cast<size_t>(Tag::kNewConversation)>,
      NewConversationPtr value);
  InvokeConversationSelection(
      std::in_place_index_t<static_cast<size_t>(Tag::kConversationId)>,
      const std::string& value);

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

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



class  InvokeTargetSurface {
 public:
  using DataView = InvokeTargetSurfaceDataView;
  using Data_ = internal::InvokeTargetSurface_Data;
  using Tag = Data_::InvokeTargetSurface_Tag;

  template <typename... Args>
  static InvokeTargetSurfacePtr 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 |default_surface|.
  static InvokeTargetSurfacePtr NewDefaultSurface(
      DefaultSurfaceMojoPtr value);
  // Construct an instance holding |new_tab|.
  static InvokeTargetSurfacePtr NewNewTab(
      NewTabMojoPtr value);

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

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

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

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

  Tag which() const {
    return tag_;
  }

  bool is_default_surface() const { return tag_ == Tag::kDefaultSurface; }
  const DefaultSurfaceMojoPtr& get_default_surface() const {
    CHECK(tag_ == Tag::kDefaultSurface);
    return data_.default_surface;
  }
  DefaultSurfaceMojoPtr& get_default_surface() {
    CHECK(tag_ == Tag::kDefaultSurface);
    return data_.default_surface;
  }
  void set_default_surface(DefaultSurfaceMojoPtr default_surface);

  bool is_new_tab() const { return tag_ == Tag::kNewTab; }
  const NewTabMojoPtr& get_new_tab() const {
    CHECK(tag_ == Tag::kNewTab);
    return data_.new_tab;
  }
  NewTabMojoPtr& get_new_tab() {
    CHECK(tag_ == Tag::kNewTab);
    return data_.new_tab;
  }
  void set_new_tab(NewTabMojoPtr new_tab);

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

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

    DefaultSurfaceMojoPtr default_surface;
    NewTabMojoPtr new_tab;
  };

  InvokeTargetSurface(
      std::in_place_index_t<static_cast<size_t>(Tag::kDefaultSurface)>,
      DefaultSurfaceMojoPtr value);
  InvokeTargetSurface(
      std::in_place_index_t<static_cast<size_t>(Tag::kNewTab)>,
      NewTabMojoPtr value);

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

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



class  GetContextResult {
 public:
  using DataView = GetContextResultDataView;
  using Data_ = internal::GetContextResult_Data;
  using Tag = Data_::GetContextResult_Tag;

  template <typename... Args>
  static GetContextResultPtr 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 |error_reason|.
  static GetContextResultPtr NewErrorReason(
      const std::string& value);
  // Construct an instance holding |tab_context|.
  static GetContextResultPtr NewTabContext(
      TabContextResultPtr value);

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

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

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

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

  Tag which() const {
    return tag_;
  }

  bool is_error_reason() const { return tag_ == Tag::kErrorReason; }
  const std::string& get_error_reason() const {
    CHECK(tag_ == Tag::kErrorReason);
    return data_.error_reason;
  }
  std::string& get_error_reason() {
    CHECK(tag_ == Tag::kErrorReason);
    return data_.error_reason;
  }
  void set_error_reason(const std::string& error_reason);

  bool is_tab_context() const { return tag_ == Tag::kTabContext; }
  const TabContextResultPtr& get_tab_context() const {
    CHECK(tag_ == Tag::kTabContext);
    return data_.tab_context;
  }
  TabContextResultPtr& get_tab_context() {
    CHECK(tag_ == Tag::kTabContext);
    return data_.tab_context;
  }
  void set_tab_context(TabContextResultPtr tab_context);

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

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

    std::string error_reason;
    TabContextResultPtr tab_context;
  };

  GetContextResult(
      std::in_place_index_t<static_cast<size_t>(Tag::kErrorReason)>,
      const std::string& value);
  GetContextResult(
      std::in_place_index_t<static_cast<size_t>(Tag::kTabContext)>,
      TabContextResultPtr value);

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

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



class  CaptureScreenshotResult {
 public:
  using DataView = CaptureScreenshotResultDataView;
  using Data_ = internal::CaptureScreenshotResult_Data;
  using Tag = Data_::CaptureScreenshotResult_Tag;

  template <typename... Args>
  static CaptureScreenshotResultPtr 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 |error_reason|.
  static CaptureScreenshotResultPtr NewErrorReason(
      CaptureScreenshotErrorReason value);
  // Construct an instance holding |screenshot|.
  static CaptureScreenshotResultPtr NewScreenshot(
      ScreenshotPtr value);

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

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

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

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

  Tag which() const {
    return tag_;
  }

  bool is_error_reason() const { return tag_ == Tag::kErrorReason; }
  CaptureScreenshotErrorReason get_error_reason() const {
    CHECK(tag_ == Tag::kErrorReason);
    return data_.error_reason;
  }
  void set_error_reason(CaptureScreenshotErrorReason error_reason);

  bool is_screenshot() const { return tag_ == Tag::kScreenshot; }
  const ScreenshotPtr& get_screenshot() const {
    CHECK(tag_ == Tag::kScreenshot);
    return data_.screenshot;
  }
  ScreenshotPtr& get_screenshot() {
    CHECK(tag_ == Tag::kScreenshot);
    return data_.screenshot;
  }
  void set_screenshot(ScreenshotPtr screenshot);

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

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

    CaptureScreenshotErrorReason error_reason;
    ScreenshotPtr screenshot;
  };

  CaptureScreenshotResult(
      std::in_place_index_t<static_cast<size_t>(Tag::kErrorReason)>,
      CaptureScreenshotErrorReason value);
  CaptureScreenshotResult(
      std::in_place_index_t<static_cast<size_t>(Tag::kScreenshot)>,
      ScreenshotPtr value);

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

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



class  ScrollToSelector {
 public:
  using DataView = ScrollToSelectorDataView;
  using Data_ = internal::ScrollToSelector_Data;
  using Tag = Data_::ScrollToSelector_Tag;

  template <typename... Args>
  static ScrollToSelectorPtr 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 |exact_text|.
  static ScrollToSelectorPtr NewExactText(
      ScrollToTextSelectorPtr value);
  // Construct an instance holding |text_fragment|.
  static ScrollToSelectorPtr NewTextFragment(
      ScrollToTextFragmentSelectorPtr value);
  // Construct an instance holding |node|.
  static ScrollToSelectorPtr NewNode(
      ScrollToNodeSelectorPtr value);

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

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

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

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

  Tag which() const {
    return tag_;
  }

  bool is_exact_text() const { return tag_ == Tag::kExactText; }
  const ScrollToTextSelectorPtr& get_exact_text() const {
    CHECK(tag_ == Tag::kExactText);
    return data_.exact_text;
  }
  ScrollToTextSelectorPtr& get_exact_text() {
    CHECK(tag_ == Tag::kExactText);
    return data_.exact_text;
  }
  void set_exact_text(ScrollToTextSelectorPtr exact_text);

  bool is_text_fragment() const { return tag_ == Tag::kTextFragment; }
  const ScrollToTextFragmentSelectorPtr& get_text_fragment() const {
    CHECK(tag_ == Tag::kTextFragment);
    return data_.text_fragment;
  }
  ScrollToTextFragmentSelectorPtr& get_text_fragment() {
    CHECK(tag_ == Tag::kTextFragment);
    return data_.text_fragment;
  }
  void set_text_fragment(ScrollToTextFragmentSelectorPtr text_fragment);

  bool is_node() const { return tag_ == Tag::kNode; }
  const ScrollToNodeSelectorPtr& get_node() const {
    CHECK(tag_ == Tag::kNode);
    return data_.node;
  }
  ScrollToNodeSelectorPtr& get_node() {
    CHECK(tag_ == Tag::kNode);
    return data_.node;
  }
  void set_node(ScrollToNodeSelectorPtr node);

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

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

    ScrollToTextSelectorPtr exact_text;
    ScrollToTextFragmentSelectorPtr text_fragment;
    ScrollToNodeSelectorPtr node;
  };

  ScrollToSelector(
      std::in_place_index_t<static_cast<size_t>(Tag::kExactText)>,
      ScrollToTextSelectorPtr value);
  ScrollToSelector(
      std::in_place_index_t<static_cast<size_t>(Tag::kTextFragment)>,
      ScrollToTextFragmentSelectorPtr value);
  ScrollToSelector(
      std::in_place_index_t<static_cast<size_t>(Tag::kNode)>,
      ScrollToNodeSelectorPtr value);

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

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



class  InvocationPayload {
 public:
  using DataView = InvocationPayloadDataView;
  using Data_ = internal::InvocationPayload_Data;
  using Tag = Data_::InvocationPayload_Tag;

  template <typename... Args>
  static InvocationPayloadPtr 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 |universal_cart|.
  static InvocationPayloadPtr NewUniversalCart(
      UniversalCartPayloadPtr value);
  // Construct an instance holding |skills_payload|.
  static InvocationPayloadPtr NewSkillsPayload(
      SkillsPayloadPtr value);

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

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

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

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

  Tag which() const {
    return tag_;
  }

  bool is_universal_cart() const { return tag_ == Tag::kUniversalCart; }
  const UniversalCartPayloadPtr& get_universal_cart() const {
    CHECK(tag_ == Tag::kUniversalCart);
    return data_.universal_cart;
  }
  UniversalCartPayloadPtr& get_universal_cart() {
    CHECK(tag_ == Tag::kUniversalCart);
    return data_.universal_cart;
  }
  void set_universal_cart(UniversalCartPayloadPtr universal_cart);

  bool is_skills_payload() const { return tag_ == Tag::kSkillsPayload; }
  const SkillsPayloadPtr& get_skills_payload() const {
    CHECK(tag_ == Tag::kSkillsPayload);
    return data_.skills_payload;
  }
  SkillsPayloadPtr& get_skills_payload() {
    CHECK(tag_ == Tag::kSkillsPayload);
    return data_.skills_payload;
  }
  void set_skills_payload(SkillsPayloadPtr skills_payload);

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

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

    UniversalCartPayloadPtr universal_cart;
    SkillsPayloadPtr skills_payload;
  };

  InvocationPayload(
      std::in_place_index_t<static_cast<size_t>(Tag::kUniversalCart)>,
      UniversalCartPayloadPtr value);
  InvocationPayload(
      std::in_place_index_t<static_cast<size_t>(Tag::kSkillsPayload)>,
      SkillsPayloadPtr value);

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

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



class  AdditionalContextPart {
 public:
  using DataView = AdditionalContextPartDataView;
  using Data_ = internal::AdditionalContextPart_Data;
  using Tag = Data_::AdditionalContextPart_Tag;

  template <typename... Args>
  static AdditionalContextPartPtr 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 |data|.
  static AdditionalContextPartPtr NewData(
      ContextDataPtr value);
  // Construct an instance holding |screenshot|.
  static AdditionalContextPartPtr NewScreenshot(
      ScreenshotPtr value);
  // Construct an instance holding |web_page_data|.
  static AdditionalContextPartPtr NewWebPageData(
      WebPageDataPtr value);
  // Construct an instance holding |annotated_page_data|.
  static AdditionalContextPartPtr NewAnnotatedPageData(
      AnnotatedPageDataPtr value);
  // Construct an instance holding |pdf_document_data|.
  static AdditionalContextPartPtr NewPdfDocumentData(
      PdfDocumentDataPtr value);
  // Construct an instance holding |tab_context|.
  static AdditionalContextPartPtr NewTabContext(
      TabContextResultPtr value);
  // Construct an instance holding |region|.
  static AdditionalContextPartPtr NewRegion(
      CapturedRegionPtr value);
  // Construct an instance holding |pending_region|.
  static AdditionalContextPartPtr NewPendingRegion(
      PendingCapturedRegionPtr value);
  // Construct an instance holding |parent_conversation_metadata|.
  static AdditionalContextPartPtr NewParentConversationMetadata(
      ParentConversationMetadataPtr value);

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

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

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

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

  Tag which() const {
    return tag_;
  }

  bool is_data() const { return tag_ == Tag::kData; }
  const ContextDataPtr& get_data() const {
    CHECK(tag_ == Tag::kData);
    return data_.data;
  }
  ContextDataPtr& get_data() {
    CHECK(tag_ == Tag::kData);
    return data_.data;
  }
  void set_data(ContextDataPtr data);

  bool is_screenshot() const { return tag_ == Tag::kScreenshot; }
  const ScreenshotPtr& get_screenshot() const {
    CHECK(tag_ == Tag::kScreenshot);
    return data_.screenshot;
  }
  ScreenshotPtr& get_screenshot() {
    CHECK(tag_ == Tag::kScreenshot);
    return data_.screenshot;
  }
  void set_screenshot(ScreenshotPtr screenshot);

  bool is_web_page_data() const { return tag_ == Tag::kWebPageData; }
  const WebPageDataPtr& get_web_page_data() const {
    CHECK(tag_ == Tag::kWebPageData);
    return data_.web_page_data;
  }
  WebPageDataPtr& get_web_page_data() {
    CHECK(tag_ == Tag::kWebPageData);
    return data_.web_page_data;
  }
  void set_web_page_data(WebPageDataPtr web_page_data);

  bool is_annotated_page_data() const { return tag_ == Tag::kAnnotatedPageData; }
  const AnnotatedPageDataPtr& get_annotated_page_data() const {
    CHECK(tag_ == Tag::kAnnotatedPageData);
    return data_.annotated_page_data;
  }
  AnnotatedPageDataPtr& get_annotated_page_data() {
    CHECK(tag_ == Tag::kAnnotatedPageData);
    return data_.annotated_page_data;
  }
  void set_annotated_page_data(AnnotatedPageDataPtr annotated_page_data);

  bool is_pdf_document_data() const { return tag_ == Tag::kPdfDocumentData; }
  const PdfDocumentDataPtr& get_pdf_document_data() const {
    CHECK(tag_ == Tag::kPdfDocumentData);
    return data_.pdf_document_data;
  }
  PdfDocumentDataPtr& get_pdf_document_data() {
    CHECK(tag_ == Tag::kPdfDocumentData);
    return data_.pdf_document_data;
  }
  void set_pdf_document_data(PdfDocumentDataPtr pdf_document_data);

  bool is_tab_context() const { return tag_ == Tag::kTabContext; }
  const TabContextResultPtr& get_tab_context() const {
    CHECK(tag_ == Tag::kTabContext);
    return data_.tab_context;
  }
  TabContextResultPtr& get_tab_context() {
    CHECK(tag_ == Tag::kTabContext);
    return data_.tab_context;
  }
  void set_tab_context(TabContextResultPtr tab_context);

  bool is_region() const { return tag_ == Tag::kRegion; }
  const CapturedRegionPtr& get_region() const {
    CHECK(tag_ == Tag::kRegion);
    return data_.region;
  }
  CapturedRegionPtr& get_region() {
    CHECK(tag_ == Tag::kRegion);
    return data_.region;
  }
  void set_region(CapturedRegionPtr region);

  bool is_pending_region() const { return tag_ == Tag::kPendingRegion; }
  const PendingCapturedRegionPtr& get_pending_region() const {
    CHECK(tag_ == Tag::kPendingRegion);
    return data_.pending_region;
  }
  PendingCapturedRegionPtr& get_pending_region() {
    CHECK(tag_ == Tag::kPendingRegion);
    return data_.pending_region;
  }
  void set_pending_region(PendingCapturedRegionPtr pending_region);

  bool is_parent_conversation_metadata() const { return tag_ == Tag::kParentConversationMetadata; }
  const ParentConversationMetadataPtr& get_parent_conversation_metadata() const {
    CHECK(tag_ == Tag::kParentConversationMetadata);
    return data_.parent_conversation_metadata;
  }
  ParentConversationMetadataPtr& get_parent_conversation_metadata() {
    CHECK(tag_ == Tag::kParentConversationMetadata);
    return data_.parent_conversation_metadata;
  }
  void set_parent_conversation_metadata(ParentConversationMetadataPtr parent_conversation_metadata);

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

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    return mojo::internal::DeserializeImpl<AdditionalContextPart::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::kData)>,
        ContextDataPtr value);
    Union_(
        std::in_place_index_t<static_cast<size_t>(Tag::kScreenshot)>,
        ScreenshotPtr value);
    Union_(
        std::in_place_index_t<static_cast<size_t>(Tag::kWebPageData)>,
        WebPageDataPtr value);
    Union_(
        std::in_place_index_t<static_cast<size_t>(Tag::kAnnotatedPageData)>,
        AnnotatedPageDataPtr value);
    Union_(
        std::in_place_index_t<static_cast<size_t>(Tag::kPdfDocumentData)>,
        PdfDocumentDataPtr value);
    Union_(
        std::in_place_index_t<static_cast<size_t>(Tag::kTabContext)>,
        TabContextResultPtr value);
    Union_(
        std::in_place_index_t<static_cast<size_t>(Tag::kRegion)>,
        CapturedRegionPtr value);
    Union_(
        std::in_place_index_t<static_cast<size_t>(Tag::kPendingRegion)>,
        PendingCapturedRegionPtr value);
    Union_(
        std::in_place_index_t<static_cast<size_t>(Tag::kParentConversationMetadata)>,
        ParentConversationMetadataPtr value);
    // The contents of the union are explicitly destroyed by `DestroyActive()`.
    ~Union_() {}

    ContextDataPtr data;
    ScreenshotPtr screenshot;
    WebPageDataPtr web_page_data;
    AnnotatedPageDataPtr annotated_page_data;
    PdfDocumentDataPtr pdf_document_data;
    TabContextResultPtr tab_context;
    CapturedRegionPtr region;
    PendingCapturedRegionPtr pending_region;
    ParentConversationMetadataPtr parent_conversation_metadata;
  };

  AdditionalContextPart(
      std::in_place_index_t<static_cast<size_t>(Tag::kData)>,
      ContextDataPtr value);
  AdditionalContextPart(
      std::in_place_index_t<static_cast<size_t>(Tag::kScreenshot)>,
      ScreenshotPtr value);
  AdditionalContextPart(
      std::in_place_index_t<static_cast<size_t>(Tag::kWebPageData)>,
      WebPageDataPtr value);
  AdditionalContextPart(
      std::in_place_index_t<static_cast<size_t>(Tag::kAnnotatedPageData)>,
      AnnotatedPageDataPtr value);
  AdditionalContextPart(
      std::in_place_index_t<static_cast<size_t>(Tag::kPdfDocumentData)>,
      PdfDocumentDataPtr value);
  AdditionalContextPart(
      std::in_place_index_t<static_cast<size_t>(Tag::kTabContext)>,
      TabContextResultPtr value);
  AdditionalContextPart(
      std::in_place_index_t<static_cast<size_t>(Tag::kRegion)>,
      CapturedRegionPtr value);
  AdditionalContextPart(
      std::in_place_index_t<static_cast<size_t>(Tag::kPendingRegion)>,
      PendingCapturedRegionPtr value);
  AdditionalContextPart(
      std::in_place_index_t<static_cast<size_t>(Tag::kParentConversationMetadata)>,
      ParentConversationMetadataPtr value);

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

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



class  FocusedTabData {
 public:
  using DataView = FocusedTabDataDataView;
  using Data_ = internal::FocusedTabData_Data;
  using Tag = Data_::FocusedTabData_Tag;

  template <typename... Args>
  static FocusedTabDataPtr 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 |focused_tab|.
  static FocusedTabDataPtr NewFocusedTab(
      TabDataPtr value);
  // Construct an instance holding |no_focused_tab_data|.
  static FocusedTabDataPtr NewNoFocusedTabData(
      NoFocusedTabDataPtr value);

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

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

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

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

  Tag which() const {
    return tag_;
  }

  bool is_focused_tab() const { return tag_ == Tag::kFocusedTab; }
  const TabDataPtr& get_focused_tab() const {
    CHECK(tag_ == Tag::kFocusedTab);
    return data_.focused_tab;
  }
  TabDataPtr& get_focused_tab() {
    CHECK(tag_ == Tag::kFocusedTab);
    return data_.focused_tab;
  }
  void set_focused_tab(TabDataPtr focused_tab);

  bool is_no_focused_tab_data() const { return tag_ == Tag::kNoFocusedTabData; }
  const NoFocusedTabDataPtr& get_no_focused_tab_data() const {
    CHECK(tag_ == Tag::kNoFocusedTabData);
    return data_.no_focused_tab_data;
  }
  NoFocusedTabDataPtr& get_no_focused_tab_data() {
    CHECK(tag_ == Tag::kNoFocusedTabData);
    return data_.no_focused_tab_data;
  }
  void set_no_focused_tab_data(NoFocusedTabDataPtr no_focused_tab_data);

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

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

    TabDataPtr focused_tab;
    NoFocusedTabDataPtr no_focused_tab_data;
  };

  FocusedTabData(
      std::in_place_index_t<static_cast<size_t>(Tag::kFocusedTab)>,
      TabDataPtr value);
  FocusedTabData(
      std::in_place_index_t<static_cast<size_t>(Tag::kNoFocusedTabData)>,
      NoFocusedTabDataPtr value);

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

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



class  CapturedRegion {
 public:
  using DataView = CapturedRegionDataView;
  using Data_ = internal::CapturedRegion_Data;
  using Tag = Data_::CapturedRegion_Tag;

  template <typename... Args>
  static CapturedRegionPtr 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 |rect|.
  static CapturedRegionPtr NewRect(
      const ::gfx::Rect& value);
  // Construct an instance holding |polyline|.
  static CapturedRegionPtr NewPolyline(
      std::vector<::gfx::Point> value);

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

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

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

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

  Tag which() const {
    return tag_;
  }

  bool is_rect() const { return tag_ == Tag::kRect; }
  const ::gfx::Rect& get_rect() const {
    CHECK(tag_ == Tag::kRect);
    return data_.rect;
  }
  ::gfx::Rect& get_rect() {
    CHECK(tag_ == Tag::kRect);
    return data_.rect;
  }
  void set_rect(const ::gfx::Rect& rect);

  bool is_polyline() const { return tag_ == Tag::kPolyline; }
  const std::vector<::gfx::Point>& get_polyline() const {
    CHECK(tag_ == Tag::kPolyline);
    return data_.polyline;
  }
  std::vector<::gfx::Point>& get_polyline() {
    CHECK(tag_ == Tag::kPolyline);
    return data_.polyline;
  }
  void set_polyline(std::vector<::gfx::Point> polyline);

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

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    return mojo::internal::DeserializeImpl<CapturedRegion::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::kRect)>,
        const ::gfx::Rect& value);
    Union_(
        std::in_place_index_t<static_cast<size_t>(Tag::kPolyline)>,
        std::vector<::gfx::Point> value);
    // The contents of the union are explicitly destroyed by `DestroyActive()`.
    ~Union_() {}

    ::gfx::Rect rect;
    std::vector<::gfx::Point> polyline;
  };

  CapturedRegion(
      std::in_place_index_t<static_cast<size_t>(Tag::kRect)>,
      const ::gfx::Rect& value);
  CapturedRegion(
      std::in_place_index_t<static_cast<size_t>(Tag::kPolyline)>,
      std::vector<::gfx::Point> value);

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

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



class  GetImageBytesResult {
 public:
  using DataView = GetImageBytesResultDataView;
  using Data_ = internal::GetImageBytesResult_Data;
  using Tag = Data_::GetImageBytesResult_Tag;

  template <typename... Args>
  static GetImageBytesResultPtr 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 |image_bytes|.
  static GetImageBytesResultPtr NewImageBytes(
      ImageBytesResultPtr value);
  // Construct an instance holding |error_reason|.
  static GetImageBytesResultPtr NewErrorReason(
      const std::string& value);

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

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

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

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

  Tag which() const {
    return tag_;
  }

  bool is_image_bytes() const { return tag_ == Tag::kImageBytes; }
  const ImageBytesResultPtr& get_image_bytes() const {
    CHECK(tag_ == Tag::kImageBytes);
    return data_.image_bytes;
  }
  ImageBytesResultPtr& get_image_bytes() {
    CHECK(tag_ == Tag::kImageBytes);
    return data_.image_bytes;
  }
  void set_image_bytes(ImageBytesResultPtr image_bytes);

  bool is_error_reason() const { return tag_ == Tag::kErrorReason; }
  const std::string& get_error_reason() const {
    CHECK(tag_ == Tag::kErrorReason);
    return data_.error_reason;
  }
  std::string& get_error_reason() {
    CHECK(tag_ == Tag::kErrorReason);
    return data_.error_reason;
  }
  void set_error_reason(const std::string& error_reason);

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

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

    ImageBytesResultPtr image_bytes;
    std::string error_reason;
  };

  GetImageBytesResult(
      std::in_place_index_t<static_cast<size_t>(Tag::kImageBytes)>,
      ImageBytesResultPtr value);
  GetImageBytesResult(
      std::in_place_index_t<static_cast<size_t>(Tag::kErrorReason)>,
      const std::string& value);

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

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



class  ActorHandler_CreateTask_ResponseParam_Result {
 public:
  using DataView = ActorHandler_CreateTask_ResponseParam_ResultDataView;
  using Data_ = internal::ActorHandler_CreateTask_ResponseParam_Result_Data;
  using Tag = Data_::ActorHandler_CreateTask_ResponseParam_Result_Tag;

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

  // Construct an instance holding |success|.
  static ActorHandler_CreateTask_ResponseParam_ResultPtr NewSuccess(
      int32_t value);
  // Construct an instance holding |failure|.
  static ActorHandler_CreateTask_ResponseParam_ResultPtr NewFailure(
      CreateTaskErrorReason value);

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

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


  // 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 = ActorHandler_CreateTask_ResponseParam_ResultPtr>
  ActorHandler_CreateTask_ResponseParam_ResultPtr Clone() const;

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

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

  Tag which() const {
    return tag_;
  }

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

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

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

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

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

  union Union_ {
    Union_(
        std::in_place_index_t<static_cast<size_t>(Tag::kSuccess)>,
        int32_t value);
    Union_(
        std::in_place_index_t<static_cast<size_t>(Tag::kFailure)>,
        CreateTaskErrorReason value);
    // The contents of the union are explicitly destroyed by `DestroyActive()`.
    ~Union_() {}

    int32_t success;
    CreateTaskErrorReason failure;
  };

  ActorHandler_CreateTask_ResponseParam_Result(
      std::in_place_index_t<static_cast<size_t>(Tag::kSuccess)>,
      int32_t value);
  ActorHandler_CreateTask_ResponseParam_Result(
      std::in_place_index_t<static_cast<size_t>(Tag::kFailure)>,
      CreateTaskErrorReason value);

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

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



class  ActorHandler_PerformActions_ResponseParam_Result {
 public:
  using DataView = ActorHandler_PerformActions_ResponseParam_ResultDataView;
  using Data_ = internal::ActorHandler_PerformActions_ResponseParam_Result_Data;
  using Tag = Data_::ActorHandler_PerformActions_ResponseParam_Result_Tag;

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

  // Construct an instance holding |success|.
  static ActorHandler_PerformActions_ResponseParam_ResultPtr NewSuccess(
      ::mojo_base::ProtoWrapper value);
  // Construct an instance holding |failure|.
  static ActorHandler_PerformActions_ResponseParam_ResultPtr NewFailure(
      PerformActionsErrorReason value);

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

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

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

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

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

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

  Tag which() const {
    return tag_;
  }

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

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

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

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

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

  union Union_ {
    Union_(
        std::in_place_index_t<static_cast<size_t>(Tag::kSuccess)>,
        ::mojo_base::ProtoWrapper value);
    Union_(
        std::in_place_index_t<static_cast<size_t>(Tag::kFailure)>,
        PerformActionsErrorReason value);
    // The contents of the union are explicitly destroyed by `DestroyActive()`.
    ~Union_() {}

    ::mojo_base::ProtoWrapper success;
    PerformActionsErrorReason failure;
  };

  ActorHandler_PerformActions_ResponseParam_Result(
      std::in_place_index_t<static_cast<size_t>(Tag::kSuccess)>,
      ::mojo_base::ProtoWrapper value);
  ActorHandler_PerformActions_ResponseParam_Result(
      std::in_place_index_t<static_cast<size_t>(Tag::kFailure)>,
      PerformActionsErrorReason value);

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

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






class  ProfileEnablement {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<ProfileEnablement, T>::value>;
  using DataView = ProfileEnablementDataView;
  using Data_ = internal::ProfileEnablement_Data;

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

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

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


  ProfileEnablement();

  ProfileEnablement(
      bool feature_enabled,
      bool is_regular_profile,
      bool is_rolled_out,
      bool primary_account_is_capable,
      bool primary_account_is_fully_signed_in,
      bool allowed_by_chrome_policy,
      bool allowed_by_remote_admin,
      bool allowed_by_remote_other,
      bool fre_is_consented,
      bool allowed_by_country_filter,
      bool allowed_by_locale_filter,
      bool actuation_is_consented,
      bool live_allowed,
      bool share_image_allowed,
      GeminiEnterpriseSettingsPtr gemini_enterprise_settings,
      ActuationEligibility actuation_eligibility,
      ActuationEligibility glic_api_actuation_eligibility,
      GlicExperimentalTriggeringState glic_experimental_triggering_state);

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

  ~ProfileEnablement();

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

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

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

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

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

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

  
  bool feature_enabled;
  
  bool is_regular_profile;
  
  bool is_rolled_out;
  
  bool primary_account_is_capable;
  
  bool primary_account_is_fully_signed_in;
  
  bool allowed_by_chrome_policy;
  
  bool allowed_by_remote_admin;
  
  bool allowed_by_remote_other;
  
  bool fre_is_consented;
  
  bool allowed_by_country_filter;
  
  bool allowed_by_locale_filter;
  
  bool actuation_is_consented;
  
  bool live_allowed;
  
  bool share_image_allowed;
  
  GeminiEnterpriseSettingsPtr gemini_enterprise_settings;
  
  ActuationEligibility actuation_eligibility;
  
  ActuationEligibility glic_api_actuation_eligibility;
  
  GlicExperimentalTriggeringState glic_experimental_triggering_state;

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

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

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

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





class  ConfigInfo {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<ConfigInfo, T>::value>;
  using DataView = ConfigInfoDataView;
  using Data_ = internal::ConfigInfo_Data;

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

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

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


  ConfigInfo();

  ConfigInfo(
      const ::GURL& guest_url,
      const ::GURL& autopush_guest_url,
      const ::GURL& staging_guest_url,
      const ::GURL& preprod_guest_url,
      const ::GURL& prod_guest_url,
      const ::GURL& web_continuity_originating_host_url);


  ~ConfigInfo();

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

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

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

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

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

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

  
  ::GURL guest_url;
  
  ::GURL autopush_guest_url;
  
  ::GURL staging_guest_url;
  
  ::GURL preprod_guest_url;
  
  ::GURL prod_guest_url;
  
  ::GURL web_continuity_originating_host_url;

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

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

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, ConfigInfo::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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










class  GetContextResultWithActionResultCode {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<GetContextResultWithActionResultCode, T>::value>;
  using DataView = GetContextResultWithActionResultCodeDataView;
  using Data_ = internal::GetContextResultWithActionResultCode_Data;

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

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

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


  GetContextResultWithActionResultCode();

  GetContextResultWithActionResultCode(
      GetContextResultPtr get_context_result,
      std::optional<int32_t> action_result);

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

  ~GetContextResultWithActionResultCode();

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

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

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

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

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

  
  GetContextResultPtr get_context_result;
  
  std::optional<int32_t> action_result;

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

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

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

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





class  UserProfileInfo {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<UserProfileInfo, T>::value>;
  using DataView = UserProfileInfoDataView;
  using Data_ = internal::UserProfileInfo_Data;

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

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

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


  UserProfileInfo();

  UserProfileInfo(
      const ::SkBitmap& avatar_icon,
      const std::string& display_name,
      const std::string& given_name,
      const std::string& local_profile_name,
      const std::string& email,
      bool is_managed);


  ~UserProfileInfo();

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

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

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

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

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

  
  ::SkBitmap avatar_icon;
  
  std::string display_name;
  
  std::string given_name;
  
  std::string local_profile_name;
  
  std::string email;
  
  bool is_managed;

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

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

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

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






class  CounterAbuseVerdict {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<CounterAbuseVerdict, T>::value>;
  using DataView = CounterAbuseVerdictDataView;
  using Data_ = internal::CounterAbuseVerdict_Data;

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

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

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


  CounterAbuseVerdict();

  explicit CounterAbuseVerdict(
      SafeBrowsingVerdictPtr sb_verdict_result);

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

  ~CounterAbuseVerdict();

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

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

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

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

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

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

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

  
  SafeBrowsingVerdictPtr sb_verdict_result;

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

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

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

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





class  WebClientInitialState {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<WebClientInitialState, T>::value>;
  using DataView = WebClientInitialStateDataView;
  using Data_ = internal::WebClientInitialState_Data;

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

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

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


  WebClientInitialState();

  WebClientInitialState(
      PanelStatePtr panel_state,
      FocusedTabDataPtr focused_tab_data,
      bool microphone_permission_enabled,
      bool location_permission_enabled,
      bool tab_context_permission_enabled,
      bool os_location_permission_enabled,
      double zoom_factor,
      const std::string& hotkey,
      const ::base::Version& chrome_version,
      Platform platform,
      FormFactor form_factor,
      bool can_attach,
      bool panel_is_active,
      bool browser_is_open,
      bool instance_is_active,
      bool enable_zero_state_suggestions,
      bool enable_cached_get_user_profile_info,
      bool enable_act_in_focused_tab,
      bool enable_scroll_to,
      bool enable_default_tab_context_setting_feature,
      bool default_tab_context_setting_enabled,
      bool closed_captioning_setting_enabled,
      bool enable_maybe_refresh_user_status,
      bool enable_multi_tab,
      bool enable_get_context_actor,
      std::vector<HostCapability> host_capabilities,
      bool enable_get_page_metadata,
      bool enable_capture_region,
      bool enable_web_actuation_setting_feature,
      bool actuation_on_web_setting_enabled,
      bool can_act_on_web,
      bool enable_activate_tab,
      bool enable_get_tab_by_id,
      bool enable_open_password_manager_settings_page,
      bool enable_trust_first_onboarding,
      bool onboarding_completed,
      bool enable_skills,
      bool enable_get_tab_favicon_by_id,
      bool enable_process_counter_abuse_verdict,
      GeminiEnterpriseSettingsPtr gemini_enterprise_settings,
      bool enable_gmail_otp_opt_in,
      bool enable_gmail_otp_confirmation,
      FileUploadPolicyState file_upload_policy_state);

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

  ~WebClientInitialState();

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

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

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

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

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

  
  PanelStatePtr panel_state;
  
  FocusedTabDataPtr focused_tab_data;
  
  bool microphone_permission_enabled;
  
  bool location_permission_enabled;
  
  bool tab_context_permission_enabled;
  
  bool os_location_permission_enabled;
  
  double zoom_factor;
  
  std::string hotkey;
  
  ::base::Version chrome_version;
  
  Platform platform;
  
  FormFactor form_factor;
  
  bool can_attach;
  
  bool panel_is_active;
  
  bool browser_is_open;
  
  bool instance_is_active;
  
  bool enable_zero_state_suggestions;
  
  bool enable_cached_get_user_profile_info;
  
  bool enable_act_in_focused_tab;
  
  bool enable_scroll_to;
  
  bool enable_default_tab_context_setting_feature;
  
  bool default_tab_context_setting_enabled;
  
  bool closed_captioning_setting_enabled;
  
  bool enable_maybe_refresh_user_status;
  
  bool enable_multi_tab;
  
  bool enable_get_context_actor;
  
  std::vector<HostCapability> host_capabilities;
  
  bool enable_get_page_metadata;
  
  bool enable_capture_region;
  
  bool enable_web_actuation_setting_feature;
  
  bool actuation_on_web_setting_enabled;
  
  bool can_act_on_web;
  
  bool enable_activate_tab;
  
  bool enable_get_tab_by_id;
  
  bool enable_open_password_manager_settings_page;
  
  bool enable_trust_first_onboarding;
  
  bool onboarding_completed;
  
  bool enable_skills;
  
  bool enable_get_tab_favicon_by_id;
  
  bool enable_process_counter_abuse_verdict;
  
  GeminiEnterpriseSettingsPtr gemini_enterprise_settings;
  
  bool enable_gmail_otp_opt_in;
  
  bool enable_gmail_otp_confirmation;
  
  FileUploadPolicyState file_upload_policy_state;

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

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

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

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






class  TabContextOptions {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<TabContextOptions, T>::value>;
  using DataView = TabContextOptionsDataView;
  using Data_ = internal::TabContextOptions_Data;

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

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

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


  TabContextOptions();

  TabContextOptions(
      bool inner_text,
      uint32_t inner_text_bytes_limit,
      bool viewport_screenshot,
      bool annotated_page_content,
      uint32_t max_meta_tags,
      bool pdf_data,
      uint32_t pdf_size_limit,
      uint32_t annotated_page_content_mode,
      const ::page_content_annotations::ScreenshotOptions::ScreenshotCollectionOptions& screenshot_collection_options);


  ~TabContextOptions();

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

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

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

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

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

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

  
  bool inner_text;
  
  uint32_t inner_text_bytes_limit;
  
  bool viewport_screenshot;
  
  bool annotated_page_content;
  
  uint32_t max_meta_tags;
  
  bool pdf_data;
  
  uint32_t pdf_size_limit;
  
  uint32_t annotated_page_content_mode;
  
  ::page_content_annotations::ScreenshotOptions::ScreenshotCollectionOptions screenshot_collection_options;

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

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

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

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






class  ScrollToParams {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<ScrollToParams, T>::value>;
  using DataView = ScrollToParamsDataView;
  using Data_ = internal::ScrollToParams_Data;

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

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

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


  ScrollToParams();

  ScrollToParams(
      ScrollToSelectorPtr selector,
      bool highlight,
      const std::optional<::base::UnguessableToken>& document_id,
      const std::optional<::GURL>& url);

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

  ~ScrollToParams();

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

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

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

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

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

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

  
  ScrollToSelectorPtr selector;
  
  bool highlight;
  
  std::optional<::base::UnguessableToken> document_id;
  
  std::optional<::GURL> url;

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

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

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, ScrollToParams::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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









class  SkillPreview {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<SkillPreview, T>::value>;
  using DataView = SkillPreviewDataView;
  using Data_ = internal::SkillPreview_Data;

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

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

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


  SkillPreview();

  SkillPreview(
      const std::string& id,
      const std::string& name,
      const std::string& icon,
      SkillSource source,
      const std::string& description,
      const std::optional<std::string>& curated_by,
      const std::optional<::GURL>& image_url,
      const std::optional<std::string>& category,
      std::optional<::base::Time> creation_time);


  ~SkillPreview();

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

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

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

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

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

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

  
  std::string id;
  
  std::string name;
  
  std::string icon;
  
  SkillSource source;
  
  std::string description;
  
  std::optional<std::string> curated_by;
  
  std::optional<::GURL> image_url;
  
  std::optional<std::string> category;
  
  std::optional<::base::Time> creation_time;

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

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

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

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





class  Skill {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<Skill, T>::value>;
  using DataView = SkillDataView;
  using Data_ = internal::Skill_Data;

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

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

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


  Skill();

  Skill(
      SkillPreviewPtr preview,
      const std::string& prompt,
      const std::optional<std::string>& source_skill_id);

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

  ~Skill();

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

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

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

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

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

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

  
  SkillPreviewPtr preview;
  
  std::string prompt;
  
  std::optional<std::string> source_skill_id;

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

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

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, Skill::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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





class  CreateSkillRequest {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<CreateSkillRequest, T>::value>;
  using DataView = CreateSkillRequestDataView;
  using Data_ = internal::CreateSkillRequest_Data;

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

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

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


  CreateSkillRequest();

  CreateSkillRequest(
      const std::string& id,
      const std::string& name,
      const std::string& icon,
      SkillSource source,
      const std::string& prompt,
      const std::string& description);


  ~CreateSkillRequest();

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

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

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

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

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

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

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

  
  std::string id;
  
  std::string name;
  
  std::string icon;
  
  SkillSource source;
  
  std::string prompt;
  
  std::string description;

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

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

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, CreateSkillRequest::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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






class  ZeroStateSuggestions {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<ZeroStateSuggestions, T>::value>;
  using DataView = ZeroStateSuggestionsDataView;
  using Data_ = internal::ZeroStateSuggestions_Data;

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

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

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


  ZeroStateSuggestions();

  ZeroStateSuggestions(
      std::vector<SuggestionContentPtr> suggestions,
      int32_t tab_id,
      const ::GURL& url);

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

  ~ZeroStateSuggestions();

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

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

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

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

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

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

  
  std::vector<SuggestionContentPtr> suggestions;
  
  int32_t tab_id;
  
  ::GURL url;

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

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

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, ZeroStateSuggestions::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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





class  ZeroStateSuggestionsV2 {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<ZeroStateSuggestionsV2, T>::value>;
  using DataView = ZeroStateSuggestionsV2DataView;
  using Data_ = internal::ZeroStateSuggestionsV2_Data;

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

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

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


  ZeroStateSuggestionsV2();

  ZeroStateSuggestionsV2(
      std::vector<SuggestionContentPtr> suggestions,
      bool is_pending,
      InvocationSource invocation_source);

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

  ~ZeroStateSuggestionsV2();

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

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

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

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

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

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

  
  std::vector<SuggestionContentPtr> suggestions;
  
  bool is_pending;
  
  InvocationSource invocation_source;

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

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

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

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





class  ZeroStateSuggestionsOptions {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<ZeroStateSuggestionsOptions, T>::value>;
  using DataView = ZeroStateSuggestionsOptionsDataView;
  using Data_ = internal::ZeroStateSuggestionsOptions_Data;

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

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

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


  ZeroStateSuggestionsOptions();

  ZeroStateSuggestionsOptions(
      bool is_first_run,
      std::vector<std::string> supported_tools);


  ~ZeroStateSuggestionsOptions();

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

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

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

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

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

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

  
  bool is_first_run;
  
  std::vector<std::string> supported_tools;

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

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

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

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





class  PinCandidate {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<PinCandidate, T>::value>;
  using DataView = PinCandidateDataView;
  using Data_ = internal::PinCandidate_Data;

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

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

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


  PinCandidate();

  explicit PinCandidate(
      TabDataPtr tab_data);

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

  ~PinCandidate();

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

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

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

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

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

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

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

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

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









class  CaptureRegionParams {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<CaptureRegionParams, T>::value>;
  using DataView = CaptureRegionParamsDataView;
  using Data_ = internal::CaptureRegionParams_Data;

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

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

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


  CaptureRegionParams();

  CaptureRegionParams(
      int32_t tab_id,
      TabContextOptionsPtr options);

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

  ~CaptureRegionParams();

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

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

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

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

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

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

  
  int32_t tab_id;
  
  TabContextOptionsPtr options;

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

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

template <typename T, CaptureRegionParams::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
  return rhs < lhs;
}

template <typename T, CaptureRegionParams::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
  return !(lhs < rhs);
}







class  ConversationInfo {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<ConversationInfo, T>::value>;
  using DataView = ConversationInfoDataView;
  using Data_ = internal::ConversationInfo_Data;

  template <typename... Args>
  static ConversationInfoPtr New(Args&&... args) {
    return ConversationInfoPtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static ConversationInfoPtr From(const U& u) {
    return mojo::TypeConverter<ConversationInfoPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, ConversationInfo>::Convert(*this);
  }


  ConversationInfo();

  ConversationInfo(
      const std::string& conversation_id,
      const std::string& conversation_title,
      const std::optional<std::string>& client_data,
      const std::optional<std::string>& turn_id);


  ~ConversationInfo();

  // 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 = ConversationInfoPtr>
  ConversationInfoPtr 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, ConversationInfo::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, ConversationInfo::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, ConversationInfo::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<
        ConversationInfo::DataView, std::vector<uint8_t>, send_validation>(input);
  }

  template <typename UserType>
  static std::vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        ConversationInfo::DataView, std::vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        ConversationInfo::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::ConversationInfo_UnserializedMessageContext<
            UserType, ConversationInfo::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<ConversationInfo::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(base::span<const uint8_t> input,
                          UserType* output) {
    return ConversationInfo::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::ConversationInfo_UnserializedMessageContext<
            UserType, ConversationInfo::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<ConversationInfo::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
  std::string conversation_id;
  
  std::string conversation_title;
  
  std::optional<std::string> client_data;
  
  std::optional<std::string> turn_id;

  // Serialise this struct into a trace.
  void WriteIntoTrace(perfetto::TracedValue traced_context) const;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
};

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, ConversationInfo::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, ConversationInfo::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {
  return !(rhs < lhs);
}

template <typename T, ConversationInfo::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
  return rhs < lhs;
}

template <typename T, ConversationInfo::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
  return !(lhs < rhs);
}





class  PanelOpeningData {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<PanelOpeningData, T>::value>;
  using DataView = PanelOpeningDataDataView;
  using Data_ = internal::PanelOpeningData_Data;

  template <typename... Args>
  static PanelOpeningDataPtr New(Args&&... args) {
    return PanelOpeningDataPtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static PanelOpeningDataPtr From(const U& u) {
    return mojo::TypeConverter<PanelOpeningDataPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, PanelOpeningData>::Convert(*this);
  }


  PanelOpeningData();

  PanelOpeningData(
      PanelStatePtr panel_state,
      InvocationSource invocation_source,
      const std::optional<std::string>& prompt_suggestion,
      bool auto_send,
      SkillPtr skill_to_invoke,
      std::optional<std::vector<ConversationInfoPtr>> recently_active_conversations,
      ConversationInfoPtr conversation_info,
      FreOverride fre_override);

PanelOpeningData(const PanelOpeningData&) = delete;
PanelOpeningData& operator=(const PanelOpeningData&) = delete;

  ~PanelOpeningData();

  // 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 = PanelOpeningDataPtr>
  PanelOpeningDataPtr 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, PanelOpeningData::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, PanelOpeningData::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, PanelOpeningData::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<
        PanelOpeningData::DataView, std::vector<uint8_t>, send_validation>(input);
  }

  template <typename UserType>
  static std::vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        PanelOpeningData::DataView, std::vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        PanelOpeningData::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::PanelOpeningData_UnserializedMessageContext<
            UserType, PanelOpeningData::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<PanelOpeningData::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(base::span<const uint8_t> input,
                          UserType* output) {
    return PanelOpeningData::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::PanelOpeningData_UnserializedMessageContext<
            UserType, PanelOpeningData::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<PanelOpeningData::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
  PanelStatePtr panel_state;
  
  InvocationSource invocation_source;
  
  std::optional<std::string> prompt_suggestion;
  
  bool auto_send;
  
  SkillPtr skill_to_invoke;
  
  std::optional<std::vector<ConversationInfoPtr>> recently_active_conversations;
  
  ConversationInfoPtr conversation_info;
  
  FreOverride fre_override;

  // 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, PanelOpeningData::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, PanelOpeningData::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {
  return !(rhs < lhs);
}

template <typename T, PanelOpeningData::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
  return rhs < lhs;
}

template <typename T, PanelOpeningData::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
  return !(lhs < rhs);
}







class  UniversalCartPayload {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<UniversalCartPayload, T>::value>;
  using DataView = UniversalCartPayloadDataView;
  using Data_ = internal::UniversalCartPayload_Data;

  template <typename... Args>
  static UniversalCartPayloadPtr New(Args&&... args) {
    return UniversalCartPayloadPtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static UniversalCartPayloadPtr From(const U& u) {
    return mojo::TypeConverter<UniversalCartPayloadPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, UniversalCartPayload>::Convert(*this);
  }


  UniversalCartPayload();

  explicit UniversalCartPayload(
      std::vector<uint8_t> serialized_metadata);


  ~UniversalCartPayload();

  // 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 = UniversalCartPayloadPtr>
  UniversalCartPayloadPtr 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, UniversalCartPayload::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, UniversalCartPayload::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, UniversalCartPayload::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<
        UniversalCartPayload::DataView, std::vector<uint8_t>, send_validation>(input);
  }

  template <typename UserType>
  static std::vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        UniversalCartPayload::DataView, std::vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        UniversalCartPayload::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::UniversalCartPayload_UnserializedMessageContext<
            UserType, UniversalCartPayload::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<UniversalCartPayload::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(base::span<const uint8_t> input,
                          UserType* output) {
    return UniversalCartPayload::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::UniversalCartPayload_UnserializedMessageContext<
            UserType, UniversalCartPayload::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<UniversalCartPayload::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
  std::vector<uint8_t> serialized_metadata;

  // 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, UniversalCartPayload::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, UniversalCartPayload::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {
  return !(rhs < lhs);
}

template <typename T, UniversalCartPayload::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
  return rhs < lhs;
}

template <typename T, UniversalCartPayload::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
  return !(lhs < rhs);
}





class  InvokeOptions {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<InvokeOptions, T>::value>;
  using DataView = InvokeOptionsDataView;
  using Data_ = internal::InvokeOptions_Data;

  template <typename... Args>
  static InvokeOptionsPtr New(Args&&... args) {
    return InvokeOptionsPtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static InvokeOptionsPtr From(const U& u) {
    return mojo::TypeConverter<InvokeOptionsPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, InvokeOptions>::Convert(*this);
  }


  InvokeOptions();

  InvokeOptions(
      InvocationSource invocation_source,
      std::optional<std::vector<std::string>> prompts,
      AdditionalContextPtr context,
      bool auto_submit,
      ::glic::mojom::FeatureMode feature_mode,
      ActuationTarget actuation_target,
      bool disable_zero_state_suggestions,
      const std::optional<std::string>& skill_id,
      ZssConfigPtr zss_config,
      InvocationPayloadPtr payload);

  InvokeOptions(
      InvocationSource invocation_source,
      std::optional<std::vector<std::string>> prompts,
      AdditionalContextPtr context,
      bool auto_submit,
      ::glic::mojom::FeatureMode feature_mode,
      ActuationTarget actuation_target,
      bool disable_zero_state_suggestions,
      const std::optional<std::string>& skill_id,
      ZssConfigPtr zss_config,
      InvocationPayloadPtr payload,
      std::optional<int32_t> actuation_tab_id);

InvokeOptions(const InvokeOptions&) = delete;
InvokeOptions& operator=(const InvokeOptions&) = delete;

  ~InvokeOptions();

  // 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 = InvokeOptionsPtr>
  InvokeOptionsPtr 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, InvokeOptions::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, InvokeOptions::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, InvokeOptions::EnableIfSame<T>* = nullptr>
  bool operator!=(const T& rhs) const { return !operator==(rhs); }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        InvokeOptions::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::InvokeOptions_UnserializedMessageContext<
            UserType, InvokeOptions::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<InvokeOptions::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(base::span<const uint8_t> input,
                          UserType* output) {
    return InvokeOptions::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::InvokeOptions_UnserializedMessageContext<
            UserType, InvokeOptions::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<InvokeOptions::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
  InvocationSource invocation_source;
  
  std::optional<std::vector<std::string>> prompts;
  
  AdditionalContextPtr context;
  
  bool auto_submit;
  
  ::glic::mojom::FeatureMode feature_mode;
  
  ActuationTarget actuation_target;
  
  bool disable_zero_state_suggestions;
  
  std::optional<std::string> skill_id;
  
  ZssConfigPtr zss_config;
  
  InvocationPayloadPtr payload;
  
  std::optional<int32_t> actuation_tab_id;

  // Serialise this struct into a trace.
  void WriteIntoTrace(perfetto::TracedValue traced_context) const;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
};

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, InvokeOptions::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, InvokeOptions::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {
  return !(rhs < lhs);
}

template <typename T, InvokeOptions::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
  return rhs < lhs;
}

template <typename T, InvokeOptions::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
  return !(lhs < rhs);
}






class  OpenPanelInfo {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<OpenPanelInfo, T>::value>;
  using DataView = OpenPanelInfoDataView;
  using Data_ = internal::OpenPanelInfo_Data;

  template <typename... Args>
  static OpenPanelInfoPtr New(Args&&... args) {
    return OpenPanelInfoPtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static OpenPanelInfoPtr From(const U& u) {
    return mojo::TypeConverter<OpenPanelInfoPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, OpenPanelInfo>::Convert(*this);
  }


  OpenPanelInfo();

  OpenPanelInfo(
      WebClientMode web_client_mode,
      const std::optional<::gfx::Size>& panelSize,
      ::base::TimeDelta resizeDuration,
      bool can_user_resize);


  ~OpenPanelInfo();

  // 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 = OpenPanelInfoPtr>
  OpenPanelInfoPtr 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, OpenPanelInfo::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, OpenPanelInfo::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, OpenPanelInfo::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<
        OpenPanelInfo::DataView, std::vector<uint8_t>, send_validation>(input);
  }

  template <typename UserType>
  static std::vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        OpenPanelInfo::DataView, std::vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        OpenPanelInfo::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::OpenPanelInfo_UnserializedMessageContext<
            UserType, OpenPanelInfo::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<OpenPanelInfo::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(base::span<const uint8_t> input,
                          UserType* output) {
    return OpenPanelInfo::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::OpenPanelInfo_UnserializedMessageContext<
            UserType, OpenPanelInfo::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<OpenPanelInfo::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
  WebClientMode web_client_mode;
  
  std::optional<::gfx::Size> panelSize;
  
  ::base::TimeDelta resizeDuration;
  
  bool can_user_resize;

  // 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, OpenPanelInfo::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, OpenPanelInfo::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {
  return !(rhs < lhs);
}

template <typename T, OpenPanelInfo::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
  return rhs < lhs;
}

template <typename T, OpenPanelInfo::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
  return !(lhs < rhs);
}





class  ContextData {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<ContextData, T>::value>;
  using DataView = ContextDataDataView;
  using Data_ = internal::ContextData_Data;

  template <typename... Args>
  static ContextDataPtr New(Args&&... args) {
    return ContextDataPtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static ContextDataPtr From(const U& u) {
    return mojo::TypeConverter<ContextDataPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, ContextData>::Convert(*this);
  }


  ContextData();

  ContextData(
      const std::string& mime_type,
      ::mojo_base::BigBuffer data,
      const std::optional<std::string>& filename);

ContextData(const ContextData&) = delete;
ContextData& operator=(const ContextData&) = delete;

  ~ContextData();

  // 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 = ContextDataPtr>
  ContextDataPtr 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, ContextData::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, ContextData::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, ContextData::EnableIfSame<T>* = nullptr>
  bool operator!=(const T& rhs) const { return !operator==(rhs); }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        ContextData::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::ContextData_UnserializedMessageContext<
            UserType, ContextData::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<ContextData::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(base::span<const uint8_t> input,
                          UserType* output) {
    return ContextData::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::ContextData_UnserializedMessageContext<
            UserType, ContextData::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<ContextData::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
  std::string mime_type;
  
  ::mojo_base::BigBuffer data;
  
  std::optional<std::string> filename;

  // 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, ContextData::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, ContextData::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {
  return !(rhs < lhs);
}

template <typename T, ContextData::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
  return rhs < lhs;
}

template <typename T, ContextData::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
  return !(lhs < rhs);
}






class  AdditionalContext {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<AdditionalContext, T>::value>;
  using DataView = AdditionalContextDataView;
  using Data_ = internal::AdditionalContext_Data;

  template <typename... Args>
  static AdditionalContextPtr New(Args&&... args) {
    return AdditionalContextPtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static AdditionalContextPtr From(const U& u) {
    return mojo::TypeConverter<AdditionalContextPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, AdditionalContext>::Convert(*this);
  }


  AdditionalContext();

  AdditionalContext(
      AdditionalContextSource source,
      const std::optional<std::string>& name,
      std::optional<int32_t> tab_id,
      const std::optional<::url::Origin>& origin,
      const std::optional<::GURL>& frameUrl,
      std::vector<AdditionalContextPartPtr> parts);

AdditionalContext(const AdditionalContext&) = delete;
AdditionalContext& operator=(const AdditionalContext&) = delete;

  ~AdditionalContext();

  // 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 = AdditionalContextPtr>
  AdditionalContextPtr 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, AdditionalContext::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, AdditionalContext::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, AdditionalContext::EnableIfSame<T>* = nullptr>
  bool operator!=(const T& rhs) const { return !operator==(rhs); }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        AdditionalContext::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::AdditionalContext_UnserializedMessageContext<
            UserType, AdditionalContext::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<AdditionalContext::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(base::span<const uint8_t> input,
                          UserType* output) {
    return AdditionalContext::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::AdditionalContext_UnserializedMessageContext<
            UserType, AdditionalContext::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<AdditionalContext::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
  AdditionalContextSource source;
  
  std::optional<std::string> name;
  
  std::optional<int32_t> tab_id;
  
  std::optional<::url::Origin> origin;
  
  std::optional<::GURL> frameUrl;
  
  std::vector<AdditionalContextPartPtr> parts;

  // 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, AdditionalContext::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, AdditionalContext::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {
  return !(rhs < lhs);
}

template <typename T, AdditionalContext::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
  return rhs < lhs;
}

template <typename T, AdditionalContext::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
  return !(lhs < rhs);
}





class  ExperimentalTriggeringUpdate {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<ExperimentalTriggeringUpdate, T>::value>;
  using DataView = ExperimentalTriggeringUpdateDataView;
  using Data_ = internal::ExperimentalTriggeringUpdate_Data;

  template <typename... Args>
  static ExperimentalTriggeringUpdatePtr New(Args&&... args) {
    return ExperimentalTriggeringUpdatePtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static ExperimentalTriggeringUpdatePtr From(const U& u) {
    return mojo::TypeConverter<ExperimentalTriggeringUpdatePtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, ExperimentalTriggeringUpdate>::Convert(*this);
  }


  ExperimentalTriggeringUpdate();

  ExperimentalTriggeringUpdate(
      ExperimentalTriggeringUpdateType type,
      const std::string& data,
      const std::optional<base::flat_map<std::string, std::string>>& metadata);


  ~ExperimentalTriggeringUpdate();

  // 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 = ExperimentalTriggeringUpdatePtr>
  ExperimentalTriggeringUpdatePtr 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, ExperimentalTriggeringUpdate::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, ExperimentalTriggeringUpdate::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, ExperimentalTriggeringUpdate::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<
        ExperimentalTriggeringUpdate::DataView, std::vector<uint8_t>, send_validation>(input);
  }

  template <typename UserType>
  static std::vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        ExperimentalTriggeringUpdate::DataView, std::vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        ExperimentalTriggeringUpdate::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::ExperimentalTriggeringUpdate_UnserializedMessageContext<
            UserType, ExperimentalTriggeringUpdate::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<ExperimentalTriggeringUpdate::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(base::span<const uint8_t> input,
                          UserType* output) {
    return ExperimentalTriggeringUpdate::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::ExperimentalTriggeringUpdate_UnserializedMessageContext<
            UserType, ExperimentalTriggeringUpdate::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<ExperimentalTriggeringUpdate::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
  ExperimentalTriggeringUpdateType type;
  
  std::string data;
  
  std::optional<base::flat_map<std::string, std::string>> metadata;

  // 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, ExperimentalTriggeringUpdate::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, ExperimentalTriggeringUpdate::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {
  return !(rhs < lhs);
}

template <typename T, ExperimentalTriggeringUpdate::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
  return rhs < lhs;
}

template <typename T, ExperimentalTriggeringUpdate::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
  return !(lhs < rhs);
}





class  TabContextResult {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<TabContextResult, T>::value>;
  using DataView = TabContextResultDataView;
  using Data_ = internal::TabContextResult_Data;

  template <typename... Args>
  static TabContextResultPtr New(Args&&... args) {
    return TabContextResultPtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static TabContextResultPtr From(const U& u) {
    return mojo::TypeConverter<TabContextResultPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, TabContextResult>::Convert(*this);
  }


  TabContextResult();

  TabContextResult(
      TabDataPtr tab_data,
      WebPageDataPtr web_page_data,
      ScreenshotPtr viewport_screenshot,
      std::optional<::mojo_base::ProtoWrapper> screenshot_info,
      PdfDocumentDataPtr pdf_document_data,
      AnnotatedPageDataPtr annotated_page_data);

TabContextResult(const TabContextResult&) = delete;
TabContextResult& operator=(const TabContextResult&) = delete;

  ~TabContextResult();

  // 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 = TabContextResultPtr>
  TabContextResultPtr 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, TabContextResult::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, TabContextResult::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, TabContextResult::EnableIfSame<T>* = nullptr>
  bool operator!=(const T& rhs) const { return !operator==(rhs); }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        TabContextResult::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::TabContextResult_UnserializedMessageContext<
            UserType, TabContextResult::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<TabContextResult::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(base::span<const uint8_t> input,
                          UserType* output) {
    return TabContextResult::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::TabContextResult_UnserializedMessageContext<
            UserType, TabContextResult::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<TabContextResult::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
  TabDataPtr tab_data;
  
  WebPageDataPtr web_page_data;
  
  ScreenshotPtr viewport_screenshot;
  
  std::optional<::mojo_base::ProtoWrapper> screenshot_info;
  
  PdfDocumentDataPtr pdf_document_data;
  
  AnnotatedPageDataPtr annotated_page_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, TabContextResult::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, TabContextResult::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {
  return !(rhs < lhs);
}

template <typename T, TabContextResult::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
  return rhs < lhs;
}

template <typename T, TabContextResult::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
  return !(lhs < rhs);
}





class  WebPageData {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<WebPageData, T>::value>;
  using DataView = WebPageDataDataView;
  using Data_ = internal::WebPageData_Data;

  template <typename... Args>
  static WebPageDataPtr New(Args&&... args) {
    return WebPageDataPtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static WebPageDataPtr From(const U& u) {
    return mojo::TypeConverter<WebPageDataPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, WebPageData>::Convert(*this);
  }


  WebPageData();

  explicit WebPageData(
      DocumentDataPtr main_document);

WebPageData(const WebPageData&) = delete;
WebPageData& operator=(const WebPageData&) = delete;

  ~WebPageData();

  // 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 = WebPageDataPtr>
  WebPageDataPtr 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, WebPageData::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, WebPageData::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, WebPageData::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<
        WebPageData::DataView, std::vector<uint8_t>, send_validation>(input);
  }

  template <typename UserType>
  static std::vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        WebPageData::DataView, std::vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        WebPageData::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::WebPageData_UnserializedMessageContext<
            UserType, WebPageData::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<WebPageData::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(base::span<const uint8_t> input,
                          UserType* output) {
    return WebPageData::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::WebPageData_UnserializedMessageContext<
            UserType, WebPageData::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<WebPageData::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
  DocumentDataPtr main_document;

  // 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, WebPageData::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, WebPageData::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {
  return !(rhs < lhs);
}

template <typename T, WebPageData::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
  return rhs < lhs;
}

template <typename T, WebPageData::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
  return !(lhs < rhs);
}





class  DocumentData {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<DocumentData, T>::value>;
  using DataView = DocumentDataDataView;
  using Data_ = internal::DocumentData_Data;

  template <typename... Args>
  static DocumentDataPtr New(Args&&... args) {
    return DocumentDataPtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static DocumentDataPtr From(const U& u) {
    return mojo::TypeConverter<DocumentDataPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, DocumentData>::Convert(*this);
  }


  DocumentData();

  DocumentData(
      const ::url::Origin& origin,
      const std::string& inner_text,
      bool inner_text_truncated);


  ~DocumentData();

  // 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 = DocumentDataPtr>
  DocumentDataPtr 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, DocumentData::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, DocumentData::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, DocumentData::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<
        DocumentData::DataView, std::vector<uint8_t>, send_validation>(input);
  }

  template <typename UserType>
  static std::vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        DocumentData::DataView, std::vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        DocumentData::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::DocumentData_UnserializedMessageContext<
            UserType, DocumentData::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<DocumentData::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(base::span<const uint8_t> input,
                          UserType* output) {
    return DocumentData::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::DocumentData_UnserializedMessageContext<
            UserType, DocumentData::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<DocumentData::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
  ::url::Origin origin;
  
  std::string inner_text;
  
  bool inner_text_truncated;

  // 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, DocumentData::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, DocumentData::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {
  return !(rhs < lhs);
}

template <typename T, DocumentData::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
  return rhs < lhs;
}

template <typename T, DocumentData::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
  return !(lhs < rhs);
}





class  PdfDocumentData {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<PdfDocumentData, T>::value>;
  using DataView = PdfDocumentDataDataView;
  using Data_ = internal::PdfDocumentData_Data;

  template <typename... Args>
  static PdfDocumentDataPtr New(Args&&... args) {
    return PdfDocumentDataPtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static PdfDocumentDataPtr From(const U& u) {
    return mojo::TypeConverter<PdfDocumentDataPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, PdfDocumentData>::Convert(*this);
  }


  PdfDocumentData();

  PdfDocumentData(
      const ::url::Origin& origin,
      std::optional<std::vector<uint8_t>> pdf_data,
      bool pdf_size_limit_exceeded);


  ~PdfDocumentData();

  // 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 = PdfDocumentDataPtr>
  PdfDocumentDataPtr 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, PdfDocumentData::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, PdfDocumentData::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, PdfDocumentData::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<
        PdfDocumentData::DataView, std::vector<uint8_t>, send_validation>(input);
  }

  template <typename UserType>
  static std::vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        PdfDocumentData::DataView, std::vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        PdfDocumentData::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::PdfDocumentData_UnserializedMessageContext<
            UserType, PdfDocumentData::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<PdfDocumentData::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(base::span<const uint8_t> input,
                          UserType* output) {
    return PdfDocumentData::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::PdfDocumentData_UnserializedMessageContext<
            UserType, PdfDocumentData::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<PdfDocumentData::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
  ::url::Origin origin;
  
  std::optional<std::vector<uint8_t>> pdf_data;
  
  bool pdf_size_limit_exceeded;

  // 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, PdfDocumentData::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, PdfDocumentData::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {
  return !(rhs < lhs);
}

template <typename T, PdfDocumentData::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
  return rhs < lhs;
}

template <typename T, PdfDocumentData::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
  return !(lhs < rhs);
}





class  TabData {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<TabData, T>::value>;
  using DataView = TabDataDataView;
  using Data_ = internal::TabData_Data;

  template <typename... Args>
  static TabDataPtr New(Args&&... args) {
    return TabDataPtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static TabDataPtr From(const U& u) {
    return mojo::TypeConverter<TabDataPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, TabData>::Convert(*this);
  }


  TabData();

  TabData(
      int32_t tab_id,
      int32_t window_id,
      const ::GURL& url,
      const std::optional<std::string>& title,
      const ::SkBitmap& favicon,
      const std::optional<::GURL>& favicon_url,
      const std::string& document_mime_type,
      std::optional<bool> is_observable,
      std::optional<bool> is_media_active,
      std::optional<bool> is_tab_content_captured,
      std::optional<bool> is_active_in_window,
      std::optional<bool> is_window_active,
      std::optional<std::vector<LightweightPageFeature>> lightweight_page_features);


  ~TabData();

  // 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 = TabDataPtr>
  TabDataPtr 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, TabData::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, TabData::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, TabData::EnableIfSame<T>* = nullptr>
  bool operator!=(const T& rhs) const { return !operator==(rhs); }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        TabData::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::TabData_UnserializedMessageContext<
            UserType, TabData::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<TabData::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(base::span<const uint8_t> input,
                          UserType* output) {
    return TabData::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::TabData_UnserializedMessageContext<
            UserType, TabData::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<TabData::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
  int32_t tab_id;
  
  int32_t window_id;
  
  ::GURL url;
  
  std::optional<std::string> title;
  
  ::SkBitmap favicon;
  
  std::optional<::GURL> favicon_url;
  
  std::string document_mime_type;
  
  std::optional<bool> is_observable;
  
  std::optional<bool> is_media_active;
  
  std::optional<bool> is_tab_content_captured;
  
  std::optional<bool> is_active_in_window;
  
  std::optional<bool> is_window_active;
  
  std::optional<std::vector<LightweightPageFeature>> lightweight_page_features;

  // 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, TabData::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, TabData::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {
  return !(rhs < lhs);
}

template <typename T, TabData::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
  return rhs < lhs;
}

template <typename T, TabData::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
  return !(lhs < rhs);
}





class  NoFocusedTabData {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<NoFocusedTabData, T>::value>;
  using DataView = NoFocusedTabDataDataView;
  using Data_ = internal::NoFocusedTabData_Data;

  template <typename... Args>
  static NoFocusedTabDataPtr New(Args&&... args) {
    return NoFocusedTabDataPtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static NoFocusedTabDataPtr From(const U& u) {
    return mojo::TypeConverter<NoFocusedTabDataPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, NoFocusedTabData>::Convert(*this);
  }


  NoFocusedTabData();

  NoFocusedTabData(
      TabDataPtr active_tab_data,
      const std::string& no_focus_reason);

NoFocusedTabData(const NoFocusedTabData&) = delete;
NoFocusedTabData& operator=(const NoFocusedTabData&) = delete;

  ~NoFocusedTabData();

  // 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 = NoFocusedTabDataPtr>
  NoFocusedTabDataPtr 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, NoFocusedTabData::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, NoFocusedTabData::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, NoFocusedTabData::EnableIfSame<T>* = nullptr>
  bool operator!=(const T& rhs) const { return !operator==(rhs); }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        NoFocusedTabData::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::NoFocusedTabData_UnserializedMessageContext<
            UserType, NoFocusedTabData::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<NoFocusedTabData::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(base::span<const uint8_t> input,
                          UserType* output) {
    return NoFocusedTabData::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::NoFocusedTabData_UnserializedMessageContext<
            UserType, NoFocusedTabData::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<NoFocusedTabData::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
  TabDataPtr active_tab_data;
  
  std::string no_focus_reason;

  // 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, NoFocusedTabData::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, NoFocusedTabData::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {
  return !(rhs < lhs);
}

template <typename T, NoFocusedTabData::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
  return rhs < lhs;
}

template <typename T, NoFocusedTabData::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
  return !(lhs < rhs);
}





class  AnnotatedPageData {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<AnnotatedPageData, T>::value>;
  using DataView = AnnotatedPageDataDataView;
  using Data_ = internal::AnnotatedPageData_Data;

  template <typename... Args>
  static AnnotatedPageDataPtr New(Args&&... args) {
    return AnnotatedPageDataPtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static AnnotatedPageDataPtr From(const U& u) {
    return mojo::TypeConverter<AnnotatedPageDataPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, AnnotatedPageData>::Convert(*this);
  }


  AnnotatedPageData();

  AnnotatedPageData(
      std::optional<::mojo_base::ProtoWrapper> annotated_page_content,
      ::blink::mojom::PageMetadataPtr metadata);

AnnotatedPageData(const AnnotatedPageData&) = delete;
AnnotatedPageData& operator=(const AnnotatedPageData&) = delete;

  ~AnnotatedPageData();

  // 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 = AnnotatedPageDataPtr>
  AnnotatedPageDataPtr 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, AnnotatedPageData::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, AnnotatedPageData::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, AnnotatedPageData::EnableIfSame<T>* = nullptr>
  bool operator!=(const T& rhs) const { return !operator==(rhs); }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        AnnotatedPageData::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::AnnotatedPageData_UnserializedMessageContext<
            UserType, AnnotatedPageData::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<AnnotatedPageData::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(base::span<const uint8_t> input,
                          UserType* output) {
    return AnnotatedPageData::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::AnnotatedPageData_UnserializedMessageContext<
            UserType, AnnotatedPageData::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<AnnotatedPageData::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
  std::optional<::mojo_base::ProtoWrapper> annotated_page_content;
  
  ::blink::mojom::PageMetadataPtr metadata;

  // 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, AnnotatedPageData::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, AnnotatedPageData::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {
  return !(rhs < lhs);
}

template <typename T, AnnotatedPageData::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
  return rhs < lhs;
}

template <typename T, AnnotatedPageData::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
  return !(lhs < rhs);
}






class  Journal {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<Journal, T>::value>;
  using DataView = JournalDataView;
  using Data_ = internal::Journal_Data;

  template <typename... Args>
  static JournalPtr New(Args&&... args) {
    return JournalPtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static JournalPtr From(const U& u) {
    return mojo::TypeConverter<JournalPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, Journal>::Convert(*this);
  }


  Journal();

  explicit Journal(
      std::vector<uint8_t> data);


  ~Journal();

  // 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 = JournalPtr>
  JournalPtr 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, Journal::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, Journal::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, Journal::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<
        Journal::DataView, std::vector<uint8_t>, send_validation>(input);
  }

  template <typename UserType>
  static std::vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        Journal::DataView, std::vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        Journal::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::Journal_UnserializedMessageContext<
            UserType, Journal::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<Journal::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(base::span<const uint8_t> input,
                          UserType* output) {
    return Journal::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::Journal_UnserializedMessageContext<
            UserType, Journal::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<Journal::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
  std::vector<uint8_t> 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, Journal::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, Journal::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {
  return !(rhs < lhs);
}

template <typename T, Journal::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
  return rhs < lhs;
}

template <typename T, Journal::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
  return !(lhs < rhs);
}





class  PendingCapturedRegion {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<PendingCapturedRegion, T>::value>;
  using DataView = PendingCapturedRegionDataView;
  using Data_ = internal::PendingCapturedRegion_Data;

  template <typename... Args>
  static PendingCapturedRegionPtr New(Args&&... args) {
    return PendingCapturedRegionPtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static PendingCapturedRegionPtr From(const U& u) {
    return mojo::TypeConverter<PendingCapturedRegionPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, PendingCapturedRegion>::Convert(*this);
  }


  PendingCapturedRegion();

  PendingCapturedRegion(
      const ::base::UnguessableToken& id,
      CapturedRegionPtr region);

PendingCapturedRegion(const PendingCapturedRegion&) = delete;
PendingCapturedRegion& operator=(const PendingCapturedRegion&) = delete;

  ~PendingCapturedRegion();

  // 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 = PendingCapturedRegionPtr>
  PendingCapturedRegionPtr 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, PendingCapturedRegion::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, PendingCapturedRegion::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, PendingCapturedRegion::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<
        PendingCapturedRegion::DataView, std::vector<uint8_t>, send_validation>(input);
  }

  template <typename UserType>
  static std::vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        PendingCapturedRegion::DataView, std::vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        PendingCapturedRegion::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::PendingCapturedRegion_UnserializedMessageContext<
            UserType, PendingCapturedRegion::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<PendingCapturedRegion::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(base::span<const uint8_t> input,
                          UserType* output) {
    return PendingCapturedRegion::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::PendingCapturedRegion_UnserializedMessageContext<
            UserType, PendingCapturedRegion::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<PendingCapturedRegion::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
  ::base::UnguessableToken id;
  
  CapturedRegionPtr region;

  // 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, PendingCapturedRegion::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, PendingCapturedRegion::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {
  return !(rhs < lhs);
}

template <typename T, PendingCapturedRegion::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
  return rhs < lhs;
}

template <typename T, PendingCapturedRegion::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
  return !(lhs < rhs);
}





class  CaptureRegionResult {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<CaptureRegionResult, T>::value>;
  using DataView = CaptureRegionResultDataView;
  using Data_ = internal::CaptureRegionResult_Data;

  template <typename... Args>
  static CaptureRegionResultPtr New(Args&&... args) {
    return CaptureRegionResultPtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static CaptureRegionResultPtr From(const U& u) {
    return mojo::TypeConverter<CaptureRegionResultPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, CaptureRegionResult>::Convert(*this);
  }


  CaptureRegionResult();

  CaptureRegionResult(
      int32_t tab_id,
      CapturedRegionPtr region);

CaptureRegionResult(const CaptureRegionResult&) = delete;
CaptureRegionResult& operator=(const CaptureRegionResult&) = delete;

  ~CaptureRegionResult();

  // 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 = CaptureRegionResultPtr>
  CaptureRegionResultPtr 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, CaptureRegionResult::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, CaptureRegionResult::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, CaptureRegionResult::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<
        CaptureRegionResult::DataView, std::vector<uint8_t>, send_validation>(input);
  }

  template <typename UserType>
  static std::vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        CaptureRegionResult::DataView, std::vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        CaptureRegionResult::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::CaptureRegionResult_UnserializedMessageContext<
            UserType, CaptureRegionResult::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<CaptureRegionResult::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(base::span<const uint8_t> input,
                          UserType* output) {
    return CaptureRegionResult::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::CaptureRegionResult_UnserializedMessageContext<
            UserType, CaptureRegionResult::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<CaptureRegionResult::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
  int32_t tab_id;
  
  CapturedRegionPtr region;

  // 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, CaptureRegionResult::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, CaptureRegionResult::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {
  return !(rhs < lhs);
}

template <typename T, CaptureRegionResult::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
  return rhs < lhs;
}

template <typename T, CaptureRegionResult::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
  return !(lhs < rhs);
}





class  Screenshot {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<Screenshot, T>::value>;
  using DataView = ScreenshotDataView;
  using Data_ = internal::Screenshot_Data;

  template <typename... Args>
  static ScreenshotPtr New(Args&&... args) {
    return ScreenshotPtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static ScreenshotPtr From(const U& u) {
    return mojo::TypeConverter<ScreenshotPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, Screenshot>::Convert(*this);
  }


  Screenshot();

  Screenshot(
      uint32_t width_pixels,
      uint32_t height_pixels,
      std::vector<uint8_t> data,
      const std::string& mime_type,
      ImageOriginAnnotationsPtr origin_annotations,
      ScreenshotEncryptionScheme encryption_scheme);

Screenshot(const Screenshot&) = delete;
Screenshot& operator=(const Screenshot&) = delete;

  ~Screenshot();

  // 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 = ScreenshotPtr>
  ScreenshotPtr 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, Screenshot::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, Screenshot::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, Screenshot::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<
        Screenshot::DataView, std::vector<uint8_t>, send_validation>(input);
  }

  template <typename UserType>
  static std::vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        Screenshot::DataView, std::vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        Screenshot::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::Screenshot_UnserializedMessageContext<
            UserType, Screenshot::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<Screenshot::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(base::span<const uint8_t> input,
                          UserType* output) {
    return Screenshot::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::Screenshot_UnserializedMessageContext<
            UserType, Screenshot::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<Screenshot::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
  uint32_t width_pixels;
  
  uint32_t height_pixels;
  
  std::vector<uint8_t> data;
  
  std::string mime_type;
  
  ImageOriginAnnotationsPtr origin_annotations;
  
  ScreenshotEncryptionScheme encryption_scheme;

  // 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, Screenshot::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, Screenshot::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {
  return !(rhs < lhs);
}

template <typename T, Screenshot::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
  return rhs < lhs;
}

template <typename T, Screenshot::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
  return !(lhs < rhs);
}





class  ImageInfo {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<ImageInfo, T>::value>;
  using DataView = ImageInfoDataView;
  using Data_ = internal::ImageInfo_Data;

  template <typename... Args>
  static ImageInfoPtr New(Args&&... args) {
    return ImageInfoPtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static ImageInfoPtr From(const U& u) {
    return mojo::TypeConverter<ImageInfoPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, ImageInfo>::Convert(*this);
  }


  ImageInfo();

  ImageInfo(
      const std::optional<std::string>& caption,
      const std::optional<::url::Origin>& source_origin,
      const ::GURL& url,
      const std::optional<std::string>& mime_type);


  ~ImageInfo();

  // 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 = ImageInfoPtr>
  ImageInfoPtr 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, ImageInfo::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, ImageInfo::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, ImageInfo::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<
        ImageInfo::DataView, std::vector<uint8_t>, send_validation>(input);
  }

  template <typename UserType>
  static std::vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        ImageInfo::DataView, std::vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        ImageInfo::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::ImageInfo_UnserializedMessageContext<
            UserType, ImageInfo::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<ImageInfo::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(base::span<const uint8_t> input,
                          UserType* output) {
    return ImageInfo::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::ImageInfo_UnserializedMessageContext<
            UserType, ImageInfo::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<ImageInfo::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
  std::optional<std::string> caption;
  
  std::optional<::url::Origin> source_origin;
  
  ::GURL url;
  
  std::optional<std::string> mime_type;

  // Serialise this struct into a trace.
  void WriteIntoTrace(perfetto::TracedValue traced_context) const;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
};

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, ImageInfo::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, ImageInfo::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {
  return !(rhs < lhs);
}

template <typename T, ImageInfo::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
  return rhs < lhs;
}

template <typename T, ImageInfo::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
  return !(lhs < rhs);
}





class  ImageBytesResult {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<ImageBytesResult, T>::value>;
  using DataView = ImageBytesResultDataView;
  using Data_ = internal::ImageBytesResult_Data;

  template <typename... Args>
  static ImageBytesResultPtr New(Args&&... args) {
    return ImageBytesResultPtr(
        std::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static ImageBytesResultPtr From(const U& u) {
    return mojo::TypeConverter<ImageBytesResultPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, ImageBytesResult>::Convert(*this);
  }


  ImageBytesResult();

  ImageBytesResult(
      ::mojo_base::BigBuffer bytes,
      ImageInfoPtr image_info);

ImageBytesResult(const ImageBytesResult&) = delete;
ImageBytesResult& operator=(const ImageBytesResult&) = delete;

  ~ImageBytesResult();

  // 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 = ImageBytesResultPtr>
  ImageBytesResultPtr 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, ImageBytesResult::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, ImageBytesResult::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }

  template <typename T, ImageBytesResult::EnableIfSame<T>* = nullptr>
  bool operator!=(const T& rhs) const { return !operator==(rhs); }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        ImageBytesResult::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::ImageBytesResult_UnserializedMessageContext<
            UserType, ImageBytesResult::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<ImageBytesResult::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(base::span<const uint8_t> input,
                          UserType* output) {
    return ImageBytesResult::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::ImageBytesResult_UnserializedMessageContext<
            UserType, ImageBytesResult::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<ImageBytesResult::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
  ::mojo_base::BigBuffer bytes;
  
  ImageInfoPtr image_info;

  // 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, ImageBytesResult::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, ImageBytesResult::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {
  return !(rhs < lhs);
}

template <typename T, ImageBytesResult::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
  return rhs < lhs;
}

template <typename T, ImageBytesResult::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
  return !(lhs < rhs);
}


template <typename UnionPtrType>
InvokeConversationSelectionPtr InvokeConversationSelection::Clone() const {
  switch (tag_) {
    case Tag::kDefaultConversation:
      return NewDefaultConversation(
          mojo::Clone(data_.default_conversation));
    case Tag::kNewConversation:
      return NewNewConversation(
          mojo::Clone(data_.new_conversation));
    case Tag::kConversationId:
      return NewConversationId(
          mojo::Clone(data_.conversation_id));
  }
  return nullptr;
}

template <typename T,
          typename std::enable_if<std::is_same<
              T, InvokeConversationSelection>::value>::type*>
bool InvokeConversationSelection::Equals(const T& other) const {
  if (tag_ != other.which())
    return false;

  switch (tag_) {
    case Tag::kDefaultConversation:
      return mojo::Equals(data_.default_conversation, other.data_.default_conversation);
    case Tag::kNewConversation:
      return mojo::Equals(data_.new_conversation, other.data_.new_conversation);
    case Tag::kConversationId:
      return mojo::Equals(data_.conversation_id, other.data_.conversation_id);
  }

  return false;
}
template <typename UnionPtrType>
InvokeTargetSurfacePtr InvokeTargetSurface::Clone() const {
  switch (tag_) {
    case Tag::kDefaultSurface:
      return NewDefaultSurface(
          mojo::Clone(data_.default_surface));
    case Tag::kNewTab:
      return NewNewTab(
          mojo::Clone(data_.new_tab));
  }
  return nullptr;
}

template <typename T,
          typename std::enable_if<std::is_same<
              T, InvokeTargetSurface>::value>::type*>
bool InvokeTargetSurface::Equals(const T& other) const {
  if (tag_ != other.which())
    return false;

  switch (tag_) {
    case Tag::kDefaultSurface:
      return mojo::Equals(data_.default_surface, other.data_.default_surface);
    case Tag::kNewTab:
      return mojo::Equals(data_.new_tab, other.data_.new_tab);
  }

  return false;
}
template <typename UnionPtrType>
GetContextResultPtr GetContextResult::Clone() const {
  switch (tag_) {
    case Tag::kErrorReason:
      return NewErrorReason(
          mojo::Clone(data_.error_reason));
    case Tag::kTabContext:
      return NewTabContext(
          mojo::Clone(data_.tab_context));
  }
  return nullptr;
}

template <typename T,
          typename std::enable_if<std::is_same<
              T, GetContextResult>::value>::type*>
bool GetContextResult::Equals(const T& other) const {
  if (tag_ != other.which())
    return false;

  switch (tag_) {
    case Tag::kErrorReason:
      return mojo::Equals(data_.error_reason, other.data_.error_reason);
    case Tag::kTabContext:
      return mojo::Equals(data_.tab_context, other.data_.tab_context);
  }

  return false;
}
template <typename UnionPtrType>
CaptureScreenshotResultPtr CaptureScreenshotResult::Clone() const {
  switch (tag_) {
    case Tag::kErrorReason:
      return NewErrorReason(
          mojo::Clone(data_.error_reason));
    case Tag::kScreenshot:
      return NewScreenshot(
          mojo::Clone(data_.screenshot));
  }
  return nullptr;
}

template <typename T,
          typename std::enable_if<std::is_same<
              T, CaptureScreenshotResult>::value>::type*>
bool CaptureScreenshotResult::Equals(const T& other) const {
  if (tag_ != other.which())
    return false;

  switch (tag_) {
    case Tag::kErrorReason:
      return mojo::Equals(data_.error_reason, other.data_.error_reason);
    case Tag::kScreenshot:
      return mojo::Equals(data_.screenshot, other.data_.screenshot);
  }

  return false;
}
template <typename UnionPtrType>
ScrollToSelectorPtr ScrollToSelector::Clone() const {
  switch (tag_) {
    case Tag::kExactText:
      return NewExactText(
          mojo::Clone(data_.exact_text));
    case Tag::kTextFragment:
      return NewTextFragment(
          mojo::Clone(data_.text_fragment));
    case Tag::kNode:
      return NewNode(
          mojo::Clone(data_.node));
  }
  return nullptr;
}

template <typename T,
          typename std::enable_if<std::is_same<
              T, ScrollToSelector>::value>::type*>
bool ScrollToSelector::Equals(const T& other) const {
  if (tag_ != other.which())
    return false;

  switch (tag_) {
    case Tag::kExactText:
      return mojo::Equals(data_.exact_text, other.data_.exact_text);
    case Tag::kTextFragment:
      return mojo::Equals(data_.text_fragment, other.data_.text_fragment);
    case Tag::kNode:
      return mojo::Equals(data_.node, other.data_.node);
  }

  return false;
}
template <typename UnionPtrType>
InvocationPayloadPtr InvocationPayload::Clone() const {
  switch (tag_) {
    case Tag::kUniversalCart:
      return NewUniversalCart(
          mojo::Clone(data_.universal_cart));
    case Tag::kSkillsPayload:
      return NewSkillsPayload(
          mojo::Clone(data_.skills_payload));
  }
  return nullptr;
}

template <typename T,
          typename std::enable_if<std::is_same<
              T, InvocationPayload>::value>::type*>
bool InvocationPayload::Equals(const T& other) const {
  if (tag_ != other.which())
    return false;

  switch (tag_) {
    case Tag::kUniversalCart:
      return mojo::Equals(data_.universal_cart, other.data_.universal_cart);
    case Tag::kSkillsPayload:
      return mojo::Equals(data_.skills_payload, other.data_.skills_payload);
  }

  return false;
}
template <typename UnionPtrType>
AdditionalContextPartPtr AdditionalContextPart::Clone() const {
  switch (tag_) {
    case Tag::kData:
      return NewData(
          mojo::Clone(data_.data));
    case Tag::kScreenshot:
      return NewScreenshot(
          mojo::Clone(data_.screenshot));
    case Tag::kWebPageData:
      return NewWebPageData(
          mojo::Clone(data_.web_page_data));
    case Tag::kAnnotatedPageData:
      return NewAnnotatedPageData(
          mojo::Clone(data_.annotated_page_data));
    case Tag::kPdfDocumentData:
      return NewPdfDocumentData(
          mojo::Clone(data_.pdf_document_data));
    case Tag::kTabContext:
      return NewTabContext(
          mojo::Clone(data_.tab_context));
    case Tag::kRegion:
      return NewRegion(
          mojo::Clone(data_.region));
    case Tag::kPendingRegion:
      return NewPendingRegion(
          mojo::Clone(data_.pending_region));
    case Tag::kParentConversationMetadata:
      return NewParentConversationMetadata(
          mojo::Clone(data_.parent_conversation_metadata));
  }
  return nullptr;
}

template <typename T,
          typename std::enable_if<std::is_same<
              T, AdditionalContextPart>::value>::type*>
bool AdditionalContextPart::Equals(const T& other) const {
  if (tag_ != other.which())
    return false;

  switch (tag_) {
    case Tag::kData:
      return mojo::Equals(data_.data, other.data_.data);
    case Tag::kScreenshot:
      return mojo::Equals(data_.screenshot, other.data_.screenshot);
    case Tag::kWebPageData:
      return mojo::Equals(data_.web_page_data, other.data_.web_page_data);
    case Tag::kAnnotatedPageData:
      return mojo::Equals(data_.annotated_page_data, other.data_.annotated_page_data);
    case Tag::kPdfDocumentData:
      return mojo::Equals(data_.pdf_document_data, other.data_.pdf_document_data);
    case Tag::kTabContext:
      return mojo::Equals(data_.tab_context, other.data_.tab_context);
    case Tag::kRegion:
      return mojo::Equals(data_.region, other.data_.region);
    case Tag::kPendingRegion:
      return mojo::Equals(data_.pending_region, other.data_.pending_region);
    case Tag::kParentConversationMetadata:
      return mojo::Equals(data_.parent_conversation_metadata, other.data_.parent_conversation_metadata);
  }

  return false;
}
template <typename UnionPtrType>
FocusedTabDataPtr FocusedTabData::Clone() const {
  switch (tag_) {
    case Tag::kFocusedTab:
      return NewFocusedTab(
          mojo::Clone(data_.focused_tab));
    case Tag::kNoFocusedTabData:
      return NewNoFocusedTabData(
          mojo::Clone(data_.no_focused_tab_data));
  }
  return nullptr;
}

template <typename T,
          typename std::enable_if<std::is_same<
              T, FocusedTabData>::value>::type*>
bool FocusedTabData::Equals(const T& other) const {
  if (tag_ != other.which())
    return false;

  switch (tag_) {
    case Tag::kFocusedTab:
      return mojo::Equals(data_.focused_tab, other.data_.focused_tab);
    case Tag::kNoFocusedTabData:
      return mojo::Equals(data_.no_focused_tab_data, other.data_.no_focused_tab_data);
  }

  return false;
}
template <typename UnionPtrType>
CapturedRegionPtr CapturedRegion::Clone() const {
  switch (tag_) {
    case Tag::kRect:
      return NewRect(
          mojo::Clone(data_.rect));
    case Tag::kPolyline:
      return NewPolyline(
          mojo::Clone(data_.polyline));
  }
  return nullptr;
}

template <typename T,
          typename std::enable_if<std::is_same<
              T, CapturedRegion>::value>::type*>
bool CapturedRegion::Equals(const T& other) const {
  if (tag_ != other.which())
    return false;

  switch (tag_) {
    case Tag::kRect:
      return mojo::Equals(data_.rect, other.data_.rect);
    case Tag::kPolyline:
      return mojo::Equals(data_.polyline, other.data_.polyline);
  }

  return false;
}
template <typename UnionPtrType>
GetImageBytesResultPtr GetImageBytesResult::Clone() const {
  switch (tag_) {
    case Tag::kImageBytes:
      return NewImageBytes(
          mojo::Clone(data_.image_bytes));
    case Tag::kErrorReason:
      return NewErrorReason(
          mojo::Clone(data_.error_reason));
  }
  return nullptr;
}

template <typename T,
          typename std::enable_if<std::is_same<
              T, GetImageBytesResult>::value>::type*>
bool GetImageBytesResult::Equals(const T& other) const {
  if (tag_ != other.which())
    return false;

  switch (tag_) {
    case Tag::kImageBytes:
      return mojo::Equals(data_.image_bytes, other.data_.image_bytes);
    case Tag::kErrorReason:
      return mojo::Equals(data_.error_reason, other.data_.error_reason);
  }

  return false;
}
template <typename UnionPtrType>
ActorHandler_CreateTask_ResponseParam_ResultPtr ActorHandler_CreateTask_ResponseParam_Result::Clone() const {
  switch (tag_) {
    case Tag::kSuccess:
      return NewSuccess(
          mojo::Clone(data_.success));
    case Tag::kFailure:
      return NewFailure(
          mojo::Clone(data_.failure));
  }
  return nullptr;
}

template <typename T,
          typename std::enable_if<std::is_same<
              T, ActorHandler_CreateTask_ResponseParam_Result>::value>::type*>
bool ActorHandler_CreateTask_ResponseParam_Result::Equals(const T& other) const {
  if (tag_ != other.which())
    return false;

  switch (tag_) {
    case Tag::kSuccess:
      return mojo::Equals(data_.success, other.data_.success);
    case Tag::kFailure:
      return mojo::Equals(data_.failure, other.data_.failure);
  }

  return false;
}
template <typename UnionPtrType>
ActorHandler_PerformActions_ResponseParam_ResultPtr ActorHandler_PerformActions_ResponseParam_Result::Clone() const {
  switch (tag_) {
    case Tag::kSuccess:
      return NewSuccess(
          mojo::Clone(data_.success));
    case Tag::kFailure:
      return NewFailure(
          mojo::Clone(data_.failure));
  }
  return nullptr;
}

template <typename T,
          typename std::enable_if<std::is_same<
              T, ActorHandler_PerformActions_ResponseParam_Result>::value>::type*>
bool ActorHandler_PerformActions_ResponseParam_Result::Equals(const T& other) const {
  if (tag_ != other.which())
    return false;

  switch (tag_) {
    case Tag::kSuccess:
      return mojo::Equals(data_.success, other.data_.success);
    case Tag::kFailure:
      return mojo::Equals(data_.failure, other.data_.failure);
  }

  return false;
}
template <typename StructPtrType>
GeminiEnterpriseSettingsPtr GeminiEnterpriseSettings::Clone() const {
  return New(
      mojo::Clone(project_id),
      mojo::Clone(app_id),
      mojo::Clone(location)
  );
}

template <typename T, GeminiEnterpriseSettings::EnableIfSame<T>*>
bool GeminiEnterpriseSettings::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->project_id, other_struct.project_id))
    return false;
  if (!mojo::Equals(this->app_id, other_struct.app_id))
    return false;
  if (!mojo::Equals(this->location, other_struct.location))
    return false;
  return true;
}

template <typename T, GeminiEnterpriseSettings::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.project_id < rhs.project_id)
    return true;
  if (rhs.project_id < lhs.project_id)
    return false;
  if (lhs.app_id < rhs.app_id)
    return true;
  if (rhs.app_id < lhs.app_id)
    return false;
  if (lhs.location < rhs.location)
    return true;
  if (rhs.location < lhs.location)
    return false;
  return false;
}
template <typename StructPtrType>
ProfileEnablementPtr ProfileEnablement::Clone() const {
  return New(
      mojo::Clone(feature_enabled),
      mojo::Clone(is_regular_profile),
      mojo::Clone(is_rolled_out),
      mojo::Clone(primary_account_is_capable),
      mojo::Clone(primary_account_is_fully_signed_in),
      mojo::Clone(allowed_by_chrome_policy),
      mojo::Clone(allowed_by_remote_admin),
      mojo::Clone(allowed_by_remote_other),
      mojo::Clone(fre_is_consented),
      mojo::Clone(allowed_by_country_filter),
      mojo::Clone(allowed_by_locale_filter),
      mojo::Clone(actuation_is_consented),
      mojo::Clone(live_allowed),
      mojo::Clone(share_image_allowed),
      mojo::Clone(gemini_enterprise_settings),
      mojo::Clone(actuation_eligibility),
      mojo::Clone(glic_api_actuation_eligibility),
      mojo::Clone(glic_experimental_triggering_state)
  );
}

template <typename T, ProfileEnablement::EnableIfSame<T>*>
bool ProfileEnablement::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->feature_enabled, other_struct.feature_enabled))
    return false;
  if (!mojo::Equals(this->is_regular_profile, other_struct.is_regular_profile))
    return false;
  if (!mojo::Equals(this->is_rolled_out, other_struct.is_rolled_out))
    return false;
  if (!mojo::Equals(this->primary_account_is_capable, other_struct.primary_account_is_capable))
    return false;
  if (!mojo::Equals(this->primary_account_is_fully_signed_in, other_struct.primary_account_is_fully_signed_in))
    return false;
  if (!mojo::Equals(this->allowed_by_chrome_policy, other_struct.allowed_by_chrome_policy))
    return false;
  if (!mojo::Equals(this->allowed_by_remote_admin, other_struct.allowed_by_remote_admin))
    return false;
  if (!mojo::Equals(this->allowed_by_remote_other, other_struct.allowed_by_remote_other))
    return false;
  if (!mojo::Equals(this->fre_is_consented, other_struct.fre_is_consented))
    return false;
  if (!mojo::Equals(this->allowed_by_country_filter, other_struct.allowed_by_country_filter))
    return false;
  if (!mojo::Equals(this->allowed_by_locale_filter, other_struct.allowed_by_locale_filter))
    return false;
  if (!mojo::Equals(this->actuation_is_consented, other_struct.actuation_is_consented))
    return false;
  if (!mojo::Equals(this->live_allowed, other_struct.live_allowed))
    return false;
  if (!mojo::Equals(this->share_image_allowed, other_struct.share_image_allowed))
    return false;
  if (!mojo::Equals(this->gemini_enterprise_settings, other_struct.gemini_enterprise_settings))
    return false;
  if (!mojo::Equals(this->actuation_eligibility, other_struct.actuation_eligibility))
    return false;
  if (!mojo::Equals(this->glic_api_actuation_eligibility, other_struct.glic_api_actuation_eligibility))
    return false;
  if (!mojo::Equals(this->glic_experimental_triggering_state, other_struct.glic_experimental_triggering_state))
    return false;
  return true;
}

template <typename T, ProfileEnablement::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.feature_enabled < rhs.feature_enabled)
    return true;
  if (rhs.feature_enabled < lhs.feature_enabled)
    return false;
  if (lhs.is_regular_profile < rhs.is_regular_profile)
    return true;
  if (rhs.is_regular_profile < lhs.is_regular_profile)
    return false;
  if (lhs.is_rolled_out < rhs.is_rolled_out)
    return true;
  if (rhs.is_rolled_out < lhs.is_rolled_out)
    return false;
  if (lhs.primary_account_is_capable < rhs.primary_account_is_capable)
    return true;
  if (rhs.primary_account_is_capable < lhs.primary_account_is_capable)
    return false;
  if (lhs.primary_account_is_fully_signed_in < rhs.primary_account_is_fully_signed_in)
    return true;
  if (rhs.primary_account_is_fully_signed_in < lhs.primary_account_is_fully_signed_in)
    return false;
  if (lhs.allowed_by_chrome_policy < rhs.allowed_by_chrome_policy)
    return true;
  if (rhs.allowed_by_chrome_policy < lhs.allowed_by_chrome_policy)
    return false;
  if (lhs.allowed_by_remote_admin < rhs.allowed_by_remote_admin)
    return true;
  if (rhs.allowed_by_remote_admin < lhs.allowed_by_remote_admin)
    return false;
  if (lhs.allowed_by_remote_other < rhs.allowed_by_remote_other)
    return true;
  if (rhs.allowed_by_remote_other < lhs.allowed_by_remote_other)
    return false;
  if (lhs.fre_is_consented < rhs.fre_is_consented)
    return true;
  if (rhs.fre_is_consented < lhs.fre_is_consented)
    return false;
  if (lhs.allowed_by_country_filter < rhs.allowed_by_country_filter)
    return true;
  if (rhs.allowed_by_country_filter < lhs.allowed_by_country_filter)
    return false;
  if (lhs.allowed_by_locale_filter < rhs.allowed_by_locale_filter)
    return true;
  if (rhs.allowed_by_locale_filter < lhs.allowed_by_locale_filter)
    return false;
  if (lhs.actuation_is_consented < rhs.actuation_is_consented)
    return true;
  if (rhs.actuation_is_consented < lhs.actuation_is_consented)
    return false;
  if (lhs.live_allowed < rhs.live_allowed)
    return true;
  if (rhs.live_allowed < lhs.live_allowed)
    return false;
  if (lhs.share_image_allowed < rhs.share_image_allowed)
    return true;
  if (rhs.share_image_allowed < lhs.share_image_allowed)
    return false;
  if (lhs.gemini_enterprise_settings < rhs.gemini_enterprise_settings)
    return true;
  if (rhs.gemini_enterprise_settings < lhs.gemini_enterprise_settings)
    return false;
  if (lhs.actuation_eligibility < rhs.actuation_eligibility)
    return true;
  if (rhs.actuation_eligibility < lhs.actuation_eligibility)
    return false;
  if (lhs.glic_api_actuation_eligibility < rhs.glic_api_actuation_eligibility)
    return true;
  if (rhs.glic_api_actuation_eligibility < lhs.glic_api_actuation_eligibility)
    return false;
  if (lhs.glic_experimental_triggering_state < rhs.glic_experimental_triggering_state)
    return true;
  if (rhs.glic_experimental_triggering_state < lhs.glic_experimental_triggering_state)
    return false;
  return false;
}
template <typename StructPtrType>
ConfigInfoPtr ConfigInfo::Clone() const {
  return New(
      mojo::Clone(guest_url),
      mojo::Clone(autopush_guest_url),
      mojo::Clone(staging_guest_url),
      mojo::Clone(preprod_guest_url),
      mojo::Clone(prod_guest_url),
      mojo::Clone(web_continuity_originating_host_url)
  );
}

template <typename T, ConfigInfo::EnableIfSame<T>*>
bool ConfigInfo::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->guest_url, other_struct.guest_url))
    return false;
  if (!mojo::Equals(this->autopush_guest_url, other_struct.autopush_guest_url))
    return false;
  if (!mojo::Equals(this->staging_guest_url, other_struct.staging_guest_url))
    return false;
  if (!mojo::Equals(this->preprod_guest_url, other_struct.preprod_guest_url))
    return false;
  if (!mojo::Equals(this->prod_guest_url, other_struct.prod_guest_url))
    return false;
  if (!mojo::Equals(this->web_continuity_originating_host_url, other_struct.web_continuity_originating_host_url))
    return false;
  return true;
}

template <typename T, ConfigInfo::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.guest_url < rhs.guest_url)
    return true;
  if (rhs.guest_url < lhs.guest_url)
    return false;
  if (lhs.autopush_guest_url < rhs.autopush_guest_url)
    return true;
  if (rhs.autopush_guest_url < lhs.autopush_guest_url)
    return false;
  if (lhs.staging_guest_url < rhs.staging_guest_url)
    return true;
  if (rhs.staging_guest_url < lhs.staging_guest_url)
    return false;
  if (lhs.preprod_guest_url < rhs.preprod_guest_url)
    return true;
  if (rhs.preprod_guest_url < lhs.preprod_guest_url)
    return false;
  if (lhs.prod_guest_url < rhs.prod_guest_url)
    return true;
  if (rhs.prod_guest_url < lhs.prod_guest_url)
    return false;
  if (lhs.web_continuity_originating_host_url < rhs.web_continuity_originating_host_url)
    return true;
  if (rhs.web_continuity_originating_host_url < lhs.web_continuity_originating_host_url)
    return false;
  return false;
}
template <typename StructPtrType>
DefaultConversationPtr DefaultConversation::Clone() const {
  return New(
  );
}

template <typename T, DefaultConversation::EnableIfSame<T>*>
bool DefaultConversation::Equals(const T& other_struct) const {
  return true;
}

template <typename T, DefaultConversation::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  return false;
}
template <typename StructPtrType>
NewConversationPtr NewConversation::Clone() const {
  return New(
  );
}

template <typename T, NewConversation::EnableIfSame<T>*>
bool NewConversation::Equals(const T& other_struct) const {
  return true;
}

template <typename T, NewConversation::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  return false;
}
template <typename StructPtrType>
DefaultSurfaceMojoPtr DefaultSurfaceMojo::Clone() const {
  return New(
  );
}

template <typename T, DefaultSurfaceMojo::EnableIfSame<T>*>
bool DefaultSurfaceMojo::Equals(const T& other_struct) const {
  return true;
}

template <typename T, DefaultSurfaceMojo::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  return false;
}
template <typename StructPtrType>
NewTabMojoPtr NewTabMojo::Clone() const {
  return New(
      mojo::Clone(open_in_foreground)
  );
}

template <typename T, NewTabMojo::EnableIfSame<T>*>
bool NewTabMojo::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->open_in_foreground, other_struct.open_in_foreground))
    return false;
  return true;
}

template <typename T, NewTabMojo::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.open_in_foreground < rhs.open_in_foreground)
    return true;
  if (rhs.open_in_foreground < lhs.open_in_foreground)
    return false;
  return false;
}
template <typename StructPtrType>
ZssConfigPtr ZssConfig::Clone() const {
  return New(
      mojo::Clone(additional_content)
  );
}

template <typename T, ZssConfig::EnableIfSame<T>*>
bool ZssConfig::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->additional_content, other_struct.additional_content))
    return false;
  return true;
}

template <typename T, ZssConfig::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.additional_content < rhs.additional_content)
    return true;
  if (rhs.additional_content < lhs.additional_content)
    return false;
  return false;
}
template <typename StructPtrType>
GetContextResultWithActionResultCodePtr GetContextResultWithActionResultCode::Clone() const {
  return New(
      mojo::Clone(get_context_result),
      mojo::Clone(action_result)
  );
}

template <typename T, GetContextResultWithActionResultCode::EnableIfSame<T>*>
bool GetContextResultWithActionResultCode::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->get_context_result, other_struct.get_context_result))
    return false;
  if (!mojo::Equals(this->action_result, other_struct.action_result))
    return false;
  return true;
}

template <typename T, GetContextResultWithActionResultCode::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.get_context_result < rhs.get_context_result)
    return true;
  if (rhs.get_context_result < lhs.get_context_result)
    return false;
  if (lhs.action_result < rhs.action_result)
    return true;
  if (rhs.action_result < lhs.action_result)
    return false;
  return false;
}
template <typename StructPtrType>
UserProfileInfoPtr UserProfileInfo::Clone() const {
  return New(
      mojo::Clone(avatar_icon),
      mojo::Clone(display_name),
      mojo::Clone(given_name),
      mojo::Clone(local_profile_name),
      mojo::Clone(email),
      mojo::Clone(is_managed)
  );
}

template <typename T, UserProfileInfo::EnableIfSame<T>*>
bool UserProfileInfo::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->avatar_icon, other_struct.avatar_icon))
    return false;
  if (!mojo::Equals(this->display_name, other_struct.display_name))
    return false;
  if (!mojo::Equals(this->given_name, other_struct.given_name))
    return false;
  if (!mojo::Equals(this->local_profile_name, other_struct.local_profile_name))
    return false;
  if (!mojo::Equals(this->email, other_struct.email))
    return false;
  if (!mojo::Equals(this->is_managed, other_struct.is_managed))
    return false;
  return true;
}

template <typename T, UserProfileInfo::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.avatar_icon < rhs.avatar_icon)
    return true;
  if (rhs.avatar_icon < lhs.avatar_icon)
    return false;
  if (lhs.display_name < rhs.display_name)
    return true;
  if (rhs.display_name < lhs.display_name)
    return false;
  if (lhs.given_name < rhs.given_name)
    return true;
  if (rhs.given_name < lhs.given_name)
    return false;
  if (lhs.local_profile_name < rhs.local_profile_name)
    return true;
  if (rhs.local_profile_name < lhs.local_profile_name)
    return false;
  if (lhs.email < rhs.email)
    return true;
  if (rhs.email < lhs.email)
    return false;
  if (lhs.is_managed < rhs.is_managed)
    return true;
  if (rhs.is_managed < lhs.is_managed)
    return false;
  return false;
}
template <typename StructPtrType>
SafeBrowsingVerdictPtr SafeBrowsingVerdict::Clone() const {
  return New(
      mojo::Clone(url),
      mojo::Clone(threat_type),
      mojo::Clone(show_interstitial)
  );
}

template <typename T, SafeBrowsingVerdict::EnableIfSame<T>*>
bool SafeBrowsingVerdict::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->url, other_struct.url))
    return false;
  if (!mojo::Equals(this->threat_type, other_struct.threat_type))
    return false;
  if (!mojo::Equals(this->show_interstitial, other_struct.show_interstitial))
    return false;
  return true;
}

template <typename T, SafeBrowsingVerdict::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.url < rhs.url)
    return true;
  if (rhs.url < lhs.url)
    return false;
  if (lhs.threat_type < rhs.threat_type)
    return true;
  if (rhs.threat_type < lhs.threat_type)
    return false;
  if (lhs.show_interstitial < rhs.show_interstitial)
    return true;
  if (rhs.show_interstitial < lhs.show_interstitial)
    return false;
  return false;
}
template <typename StructPtrType>
CounterAbuseVerdictPtr CounterAbuseVerdict::Clone() const {
  return New(
      mojo::Clone(sb_verdict_result)
  );
}

template <typename T, CounterAbuseVerdict::EnableIfSame<T>*>
bool CounterAbuseVerdict::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->sb_verdict_result, other_struct.sb_verdict_result))
    return false;
  return true;
}

template <typename T, CounterAbuseVerdict::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.sb_verdict_result < rhs.sb_verdict_result)
    return true;
  if (rhs.sb_verdict_result < lhs.sb_verdict_result)
    return false;
  return false;
}
template <typename StructPtrType>
WebClientInitialStatePtr WebClientInitialState::Clone() const {
  return New(
      mojo::Clone(panel_state),
      mojo::Clone(focused_tab_data),
      mojo::Clone(microphone_permission_enabled),
      mojo::Clone(location_permission_enabled),
      mojo::Clone(tab_context_permission_enabled),
      mojo::Clone(os_location_permission_enabled),
      mojo::Clone(zoom_factor),
      mojo::Clone(hotkey),
      mojo::Clone(chrome_version),
      mojo::Clone(platform),
      mojo::Clone(form_factor),
      mojo::Clone(can_attach),
      mojo::Clone(panel_is_active),
      mojo::Clone(browser_is_open),
      mojo::Clone(instance_is_active),
      mojo::Clone(enable_zero_state_suggestions),
      mojo::Clone(enable_cached_get_user_profile_info),
      mojo::Clone(enable_act_in_focused_tab),
      mojo::Clone(enable_scroll_to),
      mojo::Clone(enable_default_tab_context_setting_feature),
      mojo::Clone(default_tab_context_setting_enabled),
      mojo::Clone(closed_captioning_setting_enabled),
      mojo::Clone(enable_maybe_refresh_user_status),
      mojo::Clone(enable_multi_tab),
      mojo::Clone(enable_get_context_actor),
      mojo::Clone(host_capabilities),
      mojo::Clone(enable_get_page_metadata),
      mojo::Clone(enable_capture_region),
      mojo::Clone(enable_web_actuation_setting_feature),
      mojo::Clone(actuation_on_web_setting_enabled),
      mojo::Clone(can_act_on_web),
      mojo::Clone(enable_activate_tab),
      mojo::Clone(enable_get_tab_by_id),
      mojo::Clone(enable_open_password_manager_settings_page),
      mojo::Clone(enable_trust_first_onboarding),
      mojo::Clone(onboarding_completed),
      mojo::Clone(enable_skills),
      mojo::Clone(enable_get_tab_favicon_by_id),
      mojo::Clone(enable_process_counter_abuse_verdict),
      mojo::Clone(gemini_enterprise_settings),
      mojo::Clone(enable_gmail_otp_opt_in),
      mojo::Clone(enable_gmail_otp_confirmation),
      mojo::Clone(file_upload_policy_state)
  );
}

template <typename T, WebClientInitialState::EnableIfSame<T>*>
bool WebClientInitialState::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->panel_state, other_struct.panel_state))
    return false;
  if (!mojo::Equals(this->focused_tab_data, other_struct.focused_tab_data))
    return false;
  if (!mojo::Equals(this->microphone_permission_enabled, other_struct.microphone_permission_enabled))
    return false;
  if (!mojo::Equals(this->location_permission_enabled, other_struct.location_permission_enabled))
    return false;
  if (!mojo::Equals(this->tab_context_permission_enabled, other_struct.tab_context_permission_enabled))
    return false;
  if (!mojo::Equals(this->os_location_permission_enabled, other_struct.os_location_permission_enabled))
    return false;
  if (!mojo::Equals(this->zoom_factor, other_struct.zoom_factor))
    return false;
  if (!mojo::Equals(this->hotkey, other_struct.hotkey))
    return false;
  if (!mojo::Equals(this->chrome_version, other_struct.chrome_version))
    return false;
  if (!mojo::Equals(this->platform, other_struct.platform))
    return false;
  if (!mojo::Equals(this->form_factor, other_struct.form_factor))
    return false;
  if (!mojo::Equals(this->can_attach, other_struct.can_attach))
    return false;
  if (!mojo::Equals(this->panel_is_active, other_struct.panel_is_active))
    return false;
  if (!mojo::Equals(this->browser_is_open, other_struct.browser_is_open))
    return false;
  if (!mojo::Equals(this->instance_is_active, other_struct.instance_is_active))
    return false;
  if (!mojo::Equals(this->enable_zero_state_suggestions, other_struct.enable_zero_state_suggestions))
    return false;
  if (!mojo::Equals(this->enable_cached_get_user_profile_info, other_struct.enable_cached_get_user_profile_info))
    return false;
  if (!mojo::Equals(this->enable_act_in_focused_tab, other_struct.enable_act_in_focused_tab))
    return false;
  if (!mojo::Equals(this->enable_scroll_to, other_struct.enable_scroll_to))
    return false;
  if (!mojo::Equals(this->enable_default_tab_context_setting_feature, other_struct.enable_default_tab_context_setting_feature))
    return false;
  if (!mojo::Equals(this->default_tab_context_setting_enabled, other_struct.default_tab_context_setting_enabled))
    return false;
  if (!mojo::Equals(this->closed_captioning_setting_enabled, other_struct.closed_captioning_setting_enabled))
    return false;
  if (!mojo::Equals(this->enable_maybe_refresh_user_status, other_struct.enable_maybe_refresh_user_status))
    return false;
  if (!mojo::Equals(this->enable_multi_tab, other_struct.enable_multi_tab))
    return false;
  if (!mojo::Equals(this->enable_get_context_actor, other_struct.enable_get_context_actor))
    return false;
  if (!mojo::Equals(this->host_capabilities, other_struct.host_capabilities))
    return false;
  if (!mojo::Equals(this->enable_get_page_metadata, other_struct.enable_get_page_metadata))
    return false;
  if (!mojo::Equals(this->enable_capture_region, other_struct.enable_capture_region))
    return false;
  if (!mojo::Equals(this->enable_web_actuation_setting_feature, other_struct.enable_web_actuation_setting_feature))
    return false;
  if (!mojo::Equals(this->actuation_on_web_setting_enabled, other_struct.actuation_on_web_setting_enabled))
    return false;
  if (!mojo::Equals(this->can_act_on_web, other_struct.can_act_on_web))
    return false;
  if (!mojo::Equals(this->enable_activate_tab, other_struct.enable_activate_tab))
    return false;
  if (!mojo::Equals(this->enable_get_tab_by_id, other_struct.enable_get_tab_by_id))
    return false;
  if (!mojo::Equals(this->enable_open_password_manager_settings_page, other_struct.enable_open_password_manager_settings_page))
    return false;
  if (!mojo::Equals(this->enable_trust_first_onboarding, other_struct.enable_trust_first_onboarding))
    return false;
  if (!mojo::Equals(this->onboarding_completed, other_struct.onboarding_completed))
    return false;
  if (!mojo::Equals(this->enable_skills, other_struct.enable_skills))
    return false;
  if (!mojo::Equals(this->enable_get_tab_favicon_by_id, other_struct.enable_get_tab_favicon_by_id))
    return false;
  if (!mojo::Equals(this->enable_process_counter_abuse_verdict, other_struct.enable_process_counter_abuse_verdict))
    return false;
  if (!mojo::Equals(this->gemini_enterprise_settings, other_struct.gemini_enterprise_settings))
    return false;
  if (!mojo::Equals(this->enable_gmail_otp_opt_in, other_struct.enable_gmail_otp_opt_in))
    return false;
  if (!mojo::Equals(this->enable_gmail_otp_confirmation, other_struct.enable_gmail_otp_confirmation))
    return false;
  if (!mojo::Equals(this->file_upload_policy_state, other_struct.file_upload_policy_state))
    return false;
  return true;
}

template <typename T, WebClientInitialState::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.panel_state < rhs.panel_state)
    return true;
  if (rhs.panel_state < lhs.panel_state)
    return false;
  if (lhs.focused_tab_data < rhs.focused_tab_data)
    return true;
  if (rhs.focused_tab_data < lhs.focused_tab_data)
    return false;
  if (lhs.microphone_permission_enabled < rhs.microphone_permission_enabled)
    return true;
  if (rhs.microphone_permission_enabled < lhs.microphone_permission_enabled)
    return false;
  if (lhs.location_permission_enabled < rhs.location_permission_enabled)
    return true;
  if (rhs.location_permission_enabled < lhs.location_permission_enabled)
    return false;
  if (lhs.tab_context_permission_enabled < rhs.tab_context_permission_enabled)
    return true;
  if (rhs.tab_context_permission_enabled < lhs.tab_context_permission_enabled)
    return false;
  if (lhs.os_location_permission_enabled < rhs.os_location_permission_enabled)
    return true;
  if (rhs.os_location_permission_enabled < lhs.os_location_permission_enabled)
    return false;
  if (lhs.zoom_factor < rhs.zoom_factor)
    return true;
  if (rhs.zoom_factor < lhs.zoom_factor)
    return false;
  if (lhs.hotkey < rhs.hotkey)
    return true;
  if (rhs.hotkey < lhs.hotkey)
    return false;
  if (lhs.chrome_version < rhs.chrome_version)
    return true;
  if (rhs.chrome_version < lhs.chrome_version)
    return false;
  if (lhs.platform < rhs.platform)
    return true;
  if (rhs.platform < lhs.platform)
    return false;
  if (lhs.form_factor < rhs.form_factor)
    return true;
  if (rhs.form_factor < lhs.form_factor)
    return false;
  if (lhs.can_attach < rhs.can_attach)
    return true;
  if (rhs.can_attach < lhs.can_attach)
    return false;
  if (lhs.panel_is_active < rhs.panel_is_active)
    return true;
  if (rhs.panel_is_active < lhs.panel_is_active)
    return false;
  if (lhs.browser_is_open < rhs.browser_is_open)
    return true;
  if (rhs.browser_is_open < lhs.browser_is_open)
    return false;
  if (lhs.instance_is_active < rhs.instance_is_active)
    return true;
  if (rhs.instance_is_active < lhs.instance_is_active)
    return false;
  if (lhs.enable_zero_state_suggestions < rhs.enable_zero_state_suggestions)
    return true;
  if (rhs.enable_zero_state_suggestions < lhs.enable_zero_state_suggestions)
    return false;
  if (lhs.enable_cached_get_user_profile_info < rhs.enable_cached_get_user_profile_info)
    return true;
  if (rhs.enable_cached_get_user_profile_info < lhs.enable_cached_get_user_profile_info)
    return false;
  if (lhs.enable_act_in_focused_tab < rhs.enable_act_in_focused_tab)
    return true;
  if (rhs.enable_act_in_focused_tab < lhs.enable_act_in_focused_tab)
    return false;
  if (lhs.enable_scroll_to < rhs.enable_scroll_to)
    return true;
  if (rhs.enable_scroll_to < lhs.enable_scroll_to)
    return false;
  if (lhs.enable_default_tab_context_setting_feature < rhs.enable_default_tab_context_setting_feature)
    return true;
  if (rhs.enable_default_tab_context_setting_feature < lhs.enable_default_tab_context_setting_feature)
    return false;
  if (lhs.default_tab_context_setting_enabled < rhs.default_tab_context_setting_enabled)
    return true;
  if (rhs.default_tab_context_setting_enabled < lhs.default_tab_context_setting_enabled)
    return false;
  if (lhs.closed_captioning_setting_enabled < rhs.closed_captioning_setting_enabled)
    return true;
  if (rhs.closed_captioning_setting_enabled < lhs.closed_captioning_setting_enabled)
    return false;
  if (lhs.enable_maybe_refresh_user_status < rhs.enable_maybe_refresh_user_status)
    return true;
  if (rhs.enable_maybe_refresh_user_status < lhs.enable_maybe_refresh_user_status)
    return false;
  if (lhs.enable_multi_tab < rhs.enable_multi_tab)
    return true;
  if (rhs.enable_multi_tab < lhs.enable_multi_tab)
    return false;
  if (lhs.enable_get_context_actor < rhs.enable_get_context_actor)
    return true;
  if (rhs.enable_get_context_actor < lhs.enable_get_context_actor)
    return false;
  if (lhs.host_capabilities < rhs.host_capabilities)
    return true;
  if (rhs.host_capabilities < lhs.host_capabilities)
    return false;
  if (lhs.enable_get_page_metadata < rhs.enable_get_page_metadata)
    return true;
  if (rhs.enable_get_page_metadata < lhs.enable_get_page_metadata)
    return false;
  if (lhs.enable_capture_region < rhs.enable_capture_region)
    return true;
  if (rhs.enable_capture_region < lhs.enable_capture_region)
    return false;
  if (lhs.enable_web_actuation_setting_feature < rhs.enable_web_actuation_setting_feature)
    return true;
  if (rhs.enable_web_actuation_setting_feature < lhs.enable_web_actuation_setting_feature)
    return false;
  if (lhs.actuation_on_web_setting_enabled < rhs.actuation_on_web_setting_enabled)
    return true;
  if (rhs.actuation_on_web_setting_enabled < lhs.actuation_on_web_setting_enabled)
    return false;
  if (lhs.can_act_on_web < rhs.can_act_on_web)
    return true;
  if (rhs.can_act_on_web < lhs.can_act_on_web)
    return false;
  if (lhs.enable_activate_tab < rhs.enable_activate_tab)
    return true;
  if (rhs.enable_activate_tab < lhs.enable_activate_tab)
    return false;
  if (lhs.enable_get_tab_by_id < rhs.enable_get_tab_by_id)
    return true;
  if (rhs.enable_get_tab_by_id < lhs.enable_get_tab_by_id)
    return false;
  if (lhs.enable_open_password_manager_settings_page < rhs.enable_open_password_manager_settings_page)
    return true;
  if (rhs.enable_open_password_manager_settings_page < lhs.enable_open_password_manager_settings_page)
    return false;
  if (lhs.enable_trust_first_onboarding < rhs.enable_trust_first_onboarding)
    return true;
  if (rhs.enable_trust_first_onboarding < lhs.enable_trust_first_onboarding)
    return false;
  if (lhs.onboarding_completed < rhs.onboarding_completed)
    return true;
  if (rhs.onboarding_completed < lhs.onboarding_completed)
    return false;
  if (lhs.enable_skills < rhs.enable_skills)
    return true;
  if (rhs.enable_skills < lhs.enable_skills)
    return false;
  if (lhs.enable_get_tab_favicon_by_id < rhs.enable_get_tab_favicon_by_id)
    return true;
  if (rhs.enable_get_tab_favicon_by_id < lhs.enable_get_tab_favicon_by_id)
    return false;
  if (lhs.enable_process_counter_abuse_verdict < rhs.enable_process_counter_abuse_verdict)
    return true;
  if (rhs.enable_process_counter_abuse_verdict < lhs.enable_process_counter_abuse_verdict)
    return false;
  if (lhs.gemini_enterprise_settings < rhs.gemini_enterprise_settings)
    return true;
  if (rhs.gemini_enterprise_settings < lhs.gemini_enterprise_settings)
    return false;
  if (lhs.enable_gmail_otp_opt_in < rhs.enable_gmail_otp_opt_in)
    return true;
  if (rhs.enable_gmail_otp_opt_in < lhs.enable_gmail_otp_opt_in)
    return false;
  if (lhs.enable_gmail_otp_confirmation < rhs.enable_gmail_otp_confirmation)
    return true;
  if (rhs.enable_gmail_otp_confirmation < lhs.enable_gmail_otp_confirmation)
    return false;
  if (lhs.file_upload_policy_state < rhs.file_upload_policy_state)
    return true;
  if (rhs.file_upload_policy_state < lhs.file_upload_policy_state)
    return false;
  return false;
}
template <typename StructPtrType>
ScreenshotCollectionOptionsPtr ScreenshotCollectionOptions::Clone() const {
  return New(
      mojo::Clone(max_width),
      mojo::Clone(max_height),
      mojo::Clone(screenshot_image_format),
      mojo::Clone(screenshot_compression_quality)
  );
}

template <typename T, ScreenshotCollectionOptions::EnableIfSame<T>*>
bool ScreenshotCollectionOptions::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->max_width, other_struct.max_width))
    return false;
  if (!mojo::Equals(this->max_height, other_struct.max_height))
    return false;
  if (!mojo::Equals(this->screenshot_image_format, other_struct.screenshot_image_format))
    return false;
  if (!mojo::Equals(this->screenshot_compression_quality, other_struct.screenshot_compression_quality))
    return false;
  return true;
}

template <typename T, ScreenshotCollectionOptions::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.max_width < rhs.max_width)
    return true;
  if (rhs.max_width < lhs.max_width)
    return false;
  if (lhs.max_height < rhs.max_height)
    return true;
  if (rhs.max_height < lhs.max_height)
    return false;
  if (lhs.screenshot_image_format < rhs.screenshot_image_format)
    return true;
  if (rhs.screenshot_image_format < lhs.screenshot_image_format)
    return false;
  if (lhs.screenshot_compression_quality < rhs.screenshot_compression_quality)
    return true;
  if (rhs.screenshot_compression_quality < lhs.screenshot_compression_quality)
    return false;
  return false;
}
template <typename StructPtrType>
TabContextOptionsPtr TabContextOptions::Clone() const {
  return New(
      mojo::Clone(inner_text),
      mojo::Clone(inner_text_bytes_limit),
      mojo::Clone(viewport_screenshot),
      mojo::Clone(annotated_page_content),
      mojo::Clone(max_meta_tags),
      mojo::Clone(pdf_data),
      mojo::Clone(pdf_size_limit),
      mojo::Clone(annotated_page_content_mode),
      mojo::Clone(screenshot_collection_options)
  );
}

template <typename T, TabContextOptions::EnableIfSame<T>*>
bool TabContextOptions::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->inner_text, other_struct.inner_text))
    return false;
  if (!mojo::Equals(this->inner_text_bytes_limit, other_struct.inner_text_bytes_limit))
    return false;
  if (!mojo::Equals(this->viewport_screenshot, other_struct.viewport_screenshot))
    return false;
  if (!mojo::Equals(this->annotated_page_content, other_struct.annotated_page_content))
    return false;
  if (!mojo::Equals(this->max_meta_tags, other_struct.max_meta_tags))
    return false;
  if (!mojo::Equals(this->pdf_data, other_struct.pdf_data))
    return false;
  if (!mojo::Equals(this->pdf_size_limit, other_struct.pdf_size_limit))
    return false;
  if (!mojo::Equals(this->annotated_page_content_mode, other_struct.annotated_page_content_mode))
    return false;
  if (!mojo::Equals(this->screenshot_collection_options, other_struct.screenshot_collection_options))
    return false;
  return true;
}

template <typename T, TabContextOptions::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.inner_text < rhs.inner_text)
    return true;
  if (rhs.inner_text < lhs.inner_text)
    return false;
  if (lhs.inner_text_bytes_limit < rhs.inner_text_bytes_limit)
    return true;
  if (rhs.inner_text_bytes_limit < lhs.inner_text_bytes_limit)
    return false;
  if (lhs.viewport_screenshot < rhs.viewport_screenshot)
    return true;
  if (rhs.viewport_screenshot < lhs.viewport_screenshot)
    return false;
  if (lhs.annotated_page_content < rhs.annotated_page_content)
    return true;
  if (rhs.annotated_page_content < lhs.annotated_page_content)
    return false;
  if (lhs.max_meta_tags < rhs.max_meta_tags)
    return true;
  if (rhs.max_meta_tags < lhs.max_meta_tags)
    return false;
  if (lhs.pdf_data < rhs.pdf_data)
    return true;
  if (rhs.pdf_data < lhs.pdf_data)
    return false;
  if (lhs.pdf_size_limit < rhs.pdf_size_limit)
    return true;
  if (rhs.pdf_size_limit < lhs.pdf_size_limit)
    return false;
  if (lhs.annotated_page_content_mode < rhs.annotated_page_content_mode)
    return true;
  if (rhs.annotated_page_content_mode < lhs.annotated_page_content_mode)
    return false;
  if (lhs.screenshot_collection_options < rhs.screenshot_collection_options)
    return true;
  if (rhs.screenshot_collection_options < lhs.screenshot_collection_options)
    return false;
  return false;
}
template <typename StructPtrType>
GetPinCandidatesOptionsPtr GetPinCandidatesOptions::Clone() const {
  return New(
      mojo::Clone(max_candidates),
      mojo::Clone(query)
  );
}

template <typename T, GetPinCandidatesOptions::EnableIfSame<T>*>
bool GetPinCandidatesOptions::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->max_candidates, other_struct.max_candidates))
    return false;
  if (!mojo::Equals(this->query, other_struct.query))
    return false;
  return true;
}

template <typename T, GetPinCandidatesOptions::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.max_candidates < rhs.max_candidates)
    return true;
  if (rhs.max_candidates < lhs.max_candidates)
    return false;
  if (lhs.query < rhs.query)
    return true;
  if (rhs.query < lhs.query)
    return false;
  return false;
}
template <typename StructPtrType>
ScrollToParamsPtr ScrollToParams::Clone() const {
  return New(
      mojo::Clone(selector),
      mojo::Clone(highlight),
      mojo::Clone(document_id),
      mojo::Clone(url)
  );
}

template <typename T, ScrollToParams::EnableIfSame<T>*>
bool ScrollToParams::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->selector, other_struct.selector))
    return false;
  if (!mojo::Equals(this->highlight, other_struct.highlight))
    return false;
  if (!mojo::Equals(this->document_id, other_struct.document_id))
    return false;
  if (!mojo::Equals(this->url, other_struct.url))
    return false;
  return true;
}

template <typename T, ScrollToParams::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.selector < rhs.selector)
    return true;
  if (rhs.selector < lhs.selector)
    return false;
  if (lhs.highlight < rhs.highlight)
    return true;
  if (rhs.highlight < lhs.highlight)
    return false;
  if (lhs.document_id < rhs.document_id)
    return true;
  if (rhs.document_id < lhs.document_id)
    return false;
  if (lhs.url < rhs.url)
    return true;
  if (rhs.url < lhs.url)
    return false;
  return false;
}
template <typename StructPtrType>
ScrollToTextSelectorPtr ScrollToTextSelector::Clone() const {
  return New(
      mojo::Clone(text),
      mojo::Clone(search_range_start_node_id)
  );
}

template <typename T, ScrollToTextSelector::EnableIfSame<T>*>
bool ScrollToTextSelector::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->text, other_struct.text))
    return false;
  if (!mojo::Equals(this->search_range_start_node_id, other_struct.search_range_start_node_id))
    return false;
  return true;
}

template <typename T, ScrollToTextSelector::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.text < rhs.text)
    return true;
  if (rhs.text < lhs.text)
    return false;
  if (lhs.search_range_start_node_id < rhs.search_range_start_node_id)
    return true;
  if (rhs.search_range_start_node_id < lhs.search_range_start_node_id)
    return false;
  return false;
}
template <typename StructPtrType>
ScrollToTextFragmentSelectorPtr ScrollToTextFragmentSelector::Clone() const {
  return New(
      mojo::Clone(text_start),
      mojo::Clone(text_end),
      mojo::Clone(search_range_start_node_id)
  );
}

template <typename T, ScrollToTextFragmentSelector::EnableIfSame<T>*>
bool ScrollToTextFragmentSelector::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->text_start, other_struct.text_start))
    return false;
  if (!mojo::Equals(this->text_end, other_struct.text_end))
    return false;
  if (!mojo::Equals(this->search_range_start_node_id, other_struct.search_range_start_node_id))
    return false;
  return true;
}

template <typename T, ScrollToTextFragmentSelector::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.text_start < rhs.text_start)
    return true;
  if (rhs.text_start < lhs.text_start)
    return false;
  if (lhs.text_end < rhs.text_end)
    return true;
  if (rhs.text_end < lhs.text_end)
    return false;
  if (lhs.search_range_start_node_id < rhs.search_range_start_node_id)
    return true;
  if (rhs.search_range_start_node_id < lhs.search_range_start_node_id)
    return false;
  return false;
}
template <typename StructPtrType>
ScrollToNodeSelectorPtr ScrollToNodeSelector::Clone() const {
  return New(
      mojo::Clone(node_id)
  );
}

template <typename T, ScrollToNodeSelector::EnableIfSame<T>*>
bool ScrollToNodeSelector::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->node_id, other_struct.node_id))
    return false;
  return true;
}

template <typename T, ScrollToNodeSelector::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.node_id < rhs.node_id)
    return true;
  if (rhs.node_id < lhs.node_id)
    return false;
  return false;
}
template <typename StructPtrType>
SuggestionContentPtr SuggestionContent::Clone() const {
  return New(
      mojo::Clone(suggestion)
  );
}

template <typename T, SuggestionContent::EnableIfSame<T>*>
bool SuggestionContent::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->suggestion, other_struct.suggestion))
    return false;
  return true;
}

template <typename T, SuggestionContent::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.suggestion < rhs.suggestion)
    return true;
  if (rhs.suggestion < lhs.suggestion)
    return false;
  return false;
}
template <typename StructPtrType>
SkillPreviewPtr SkillPreview::Clone() const {
  return New(
      mojo::Clone(id),
      mojo::Clone(name),
      mojo::Clone(icon),
      mojo::Clone(source),
      mojo::Clone(description),
      mojo::Clone(curated_by),
      mojo::Clone(image_url),
      mojo::Clone(category),
      mojo::Clone(creation_time)
  );
}

template <typename T, SkillPreview::EnableIfSame<T>*>
bool SkillPreview::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->id, other_struct.id))
    return false;
  if (!mojo::Equals(this->name, other_struct.name))
    return false;
  if (!mojo::Equals(this->icon, other_struct.icon))
    return false;
  if (!mojo::Equals(this->source, other_struct.source))
    return false;
  if (!mojo::Equals(this->description, other_struct.description))
    return false;
  if (!mojo::Equals(this->curated_by, other_struct.curated_by))
    return false;
  if (!mojo::Equals(this->image_url, other_struct.image_url))
    return false;
  if (!mojo::Equals(this->category, other_struct.category))
    return false;
  if (!mojo::Equals(this->creation_time, other_struct.creation_time))
    return false;
  return true;
}

template <typename T, SkillPreview::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.name < rhs.name)
    return true;
  if (rhs.name < lhs.name)
    return false;
  if (lhs.icon < rhs.icon)
    return true;
  if (rhs.icon < lhs.icon)
    return false;
  if (lhs.source < rhs.source)
    return true;
  if (rhs.source < lhs.source)
    return false;
  if (lhs.description < rhs.description)
    return true;
  if (rhs.description < lhs.description)
    return false;
  if (lhs.curated_by < rhs.curated_by)
    return true;
  if (rhs.curated_by < lhs.curated_by)
    return false;
  if (lhs.image_url < rhs.image_url)
    return true;
  if (rhs.image_url < lhs.image_url)
    return false;
  if (lhs.category < rhs.category)
    return true;
  if (rhs.category < lhs.category)
    return false;
  if (lhs.creation_time < rhs.creation_time)
    return true;
  if (rhs.creation_time < lhs.creation_time)
    return false;
  return false;
}
template <typename StructPtrType>
SkillPtr Skill::Clone() const {
  return New(
      mojo::Clone(preview),
      mojo::Clone(prompt),
      mojo::Clone(source_skill_id)
  );
}

template <typename T, Skill::EnableIfSame<T>*>
bool Skill::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->preview, other_struct.preview))
    return false;
  if (!mojo::Equals(this->prompt, other_struct.prompt))
    return false;
  if (!mojo::Equals(this->source_skill_id, other_struct.source_skill_id))
    return false;
  return true;
}

template <typename T, Skill::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.preview < rhs.preview)
    return true;
  if (rhs.preview < lhs.preview)
    return false;
  if (lhs.prompt < rhs.prompt)
    return true;
  if (rhs.prompt < lhs.prompt)
    return false;
  if (lhs.source_skill_id < rhs.source_skill_id)
    return true;
  if (rhs.source_skill_id < lhs.source_skill_id)
    return false;
  return false;
}
template <typename StructPtrType>
CreateSkillRequestPtr CreateSkillRequest::Clone() const {
  return New(
      mojo::Clone(id),
      mojo::Clone(name),
      mojo::Clone(icon),
      mojo::Clone(source),
      mojo::Clone(prompt),
      mojo::Clone(description)
  );
}

template <typename T, CreateSkillRequest::EnableIfSame<T>*>
bool CreateSkillRequest::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->id, other_struct.id))
    return false;
  if (!mojo::Equals(this->name, other_struct.name))
    return false;
  if (!mojo::Equals(this->icon, other_struct.icon))
    return false;
  if (!mojo::Equals(this->source, other_struct.source))
    return false;
  if (!mojo::Equals(this->prompt, other_struct.prompt))
    return false;
  if (!mojo::Equals(this->description, other_struct.description))
    return false;
  return true;
}

template <typename T, CreateSkillRequest::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.name < rhs.name)
    return true;
  if (rhs.name < lhs.name)
    return false;
  if (lhs.icon < rhs.icon)
    return true;
  if (rhs.icon < lhs.icon)
    return false;
  if (lhs.source < rhs.source)
    return true;
  if (rhs.source < lhs.source)
    return false;
  if (lhs.prompt < rhs.prompt)
    return true;
  if (rhs.prompt < lhs.prompt)
    return false;
  if (lhs.description < rhs.description)
    return true;
  if (rhs.description < lhs.description)
    return false;
  return false;
}
template <typename StructPtrType>
UpdateSkillRequestPtr UpdateSkillRequest::Clone() const {
  return New(
      mojo::Clone(id)
  );
}

template <typename T, UpdateSkillRequest::EnableIfSame<T>*>
bool UpdateSkillRequest::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->id, other_struct.id))
    return false;
  return true;
}

template <typename T, UpdateSkillRequest::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.id < rhs.id)
    return true;
  if (rhs.id < lhs.id)
    return false;
  return false;
}
template <typename StructPtrType>
ZeroStateSuggestionsPtr ZeroStateSuggestions::Clone() const {
  return New(
      mojo::Clone(suggestions),
      mojo::Clone(tab_id),
      mojo::Clone(url)
  );
}

template <typename T, ZeroStateSuggestions::EnableIfSame<T>*>
bool ZeroStateSuggestions::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->suggestions, other_struct.suggestions))
    return false;
  if (!mojo::Equals(this->tab_id, other_struct.tab_id))
    return false;
  if (!mojo::Equals(this->url, other_struct.url))
    return false;
  return true;
}

template <typename T, ZeroStateSuggestions::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.suggestions < rhs.suggestions)
    return true;
  if (rhs.suggestions < lhs.suggestions)
    return false;
  if (lhs.tab_id < rhs.tab_id)
    return true;
  if (rhs.tab_id < lhs.tab_id)
    return false;
  if (lhs.url < rhs.url)
    return true;
  if (rhs.url < lhs.url)
    return false;
  return false;
}
template <typename StructPtrType>
ZeroStateSuggestionsV2Ptr ZeroStateSuggestionsV2::Clone() const {
  return New(
      mojo::Clone(suggestions),
      mojo::Clone(is_pending),
      mojo::Clone(invocation_source)
  );
}

template <typename T, ZeroStateSuggestionsV2::EnableIfSame<T>*>
bool ZeroStateSuggestionsV2::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->suggestions, other_struct.suggestions))
    return false;
  if (!mojo::Equals(this->is_pending, other_struct.is_pending))
    return false;
  if (!mojo::Equals(this->invocation_source, other_struct.invocation_source))
    return false;
  return true;
}

template <typename T, ZeroStateSuggestionsV2::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.suggestions < rhs.suggestions)
    return true;
  if (rhs.suggestions < lhs.suggestions)
    return false;
  if (lhs.is_pending < rhs.is_pending)
    return true;
  if (rhs.is_pending < lhs.is_pending)
    return false;
  if (lhs.invocation_source < rhs.invocation_source)
    return true;
  if (rhs.invocation_source < lhs.invocation_source)
    return false;
  return false;
}
template <typename StructPtrType>
ZeroStateSuggestionsOptionsPtr ZeroStateSuggestionsOptions::Clone() const {
  return New(
      mojo::Clone(is_first_run),
      mojo::Clone(supported_tools)
  );
}

template <typename T, ZeroStateSuggestionsOptions::EnableIfSame<T>*>
bool ZeroStateSuggestionsOptions::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->is_first_run, other_struct.is_first_run))
    return false;
  if (!mojo::Equals(this->supported_tools, other_struct.supported_tools))
    return false;
  return true;
}

template <typename T, ZeroStateSuggestionsOptions::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.is_first_run < rhs.is_first_run)
    return true;
  if (rhs.is_first_run < lhs.is_first_run)
    return false;
  if (lhs.supported_tools < rhs.supported_tools)
    return true;
  if (rhs.supported_tools < lhs.supported_tools)
    return false;
  return false;
}
template <typename StructPtrType>
PinCandidatePtr PinCandidate::Clone() const {
  return New(
      mojo::Clone(tab_data)
  );
}

template <typename T, PinCandidate::EnableIfSame<T>*>
bool PinCandidate::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->tab_data, other_struct.tab_data))
    return false;
  return true;
}

template <typename T, PinCandidate::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.tab_data < rhs.tab_data)
    return true;
  if (rhs.tab_data < lhs.tab_data)
    return false;
  return false;
}
template <typename StructPtrType>
PinTabsOptionsPtr PinTabsOptions::Clone() const {
  return New(
      mojo::Clone(pin_trigger)
  );
}

template <typename T, PinTabsOptions::EnableIfSame<T>*>
bool PinTabsOptions::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->pin_trigger, other_struct.pin_trigger))
    return false;
  return true;
}

template <typename T, PinTabsOptions::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.pin_trigger < rhs.pin_trigger)
    return true;
  if (rhs.pin_trigger < lhs.pin_trigger)
    return false;
  return false;
}
template <typename StructPtrType>
UnpinTabsOptionsPtr UnpinTabsOptions::Clone() const {
  return New(
      mojo::Clone(unpin_trigger)
  );
}

template <typename T, UnpinTabsOptions::EnableIfSame<T>*>
bool UnpinTabsOptions::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->unpin_trigger, other_struct.unpin_trigger))
    return false;
  return true;
}

template <typename T, UnpinTabsOptions::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.unpin_trigger < rhs.unpin_trigger)
    return true;
  if (rhs.unpin_trigger < lhs.unpin_trigger)
    return false;
  return false;
}
template <typename StructPtrType>
OpenPinnedTabPickerOptionsPtr OpenPinnedTabPickerOptions::Clone() const {
  return New(
  );
}

template <typename T, OpenPinnedTabPickerOptions::EnableIfSame<T>*>
bool OpenPinnedTabPickerOptions::Equals(const T& other_struct) const {
  return true;
}

template <typename T, OpenPinnedTabPickerOptions::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  return false;
}
template <typename StructPtrType>
CreateActorTabOptionsPtr CreateActorTabOptions::Clone() const {
  return New(
      mojo::Clone(initiator_tab_id),
      mojo::Clone(initiator_window_id),
      mojo::Clone(open_in_background)
  );
}

template <typename T, CreateActorTabOptions::EnableIfSame<T>*>
bool CreateActorTabOptions::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->initiator_tab_id, other_struct.initiator_tab_id))
    return false;
  if (!mojo::Equals(this->initiator_window_id, other_struct.initiator_window_id))
    return false;
  if (!mojo::Equals(this->open_in_background, other_struct.open_in_background))
    return false;
  return true;
}

template <typename T, CreateActorTabOptions::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.initiator_tab_id < rhs.initiator_tab_id)
    return true;
  if (rhs.initiator_tab_id < lhs.initiator_tab_id)
    return false;
  if (lhs.initiator_window_id < rhs.initiator_window_id)
    return true;
  if (rhs.initiator_window_id < lhs.initiator_window_id)
    return false;
  if (lhs.open_in_background < rhs.open_in_background)
    return true;
  if (rhs.open_in_background < lhs.open_in_background)
    return false;
  return false;
}
template <typename StructPtrType>
CaptureRegionParamsPtr CaptureRegionParams::Clone() const {
  return New(
      mojo::Clone(tab_id),
      mojo::Clone(options)
  );
}

template <typename T, CaptureRegionParams::EnableIfSame<T>*>
bool CaptureRegionParams::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->tab_id, other_struct.tab_id))
    return false;
  if (!mojo::Equals(this->options, other_struct.options))
    return false;
  return true;
}

template <typename T, CaptureRegionParams::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.tab_id < rhs.tab_id)
    return true;
  if (rhs.tab_id < lhs.tab_id)
    return false;
  if (lhs.options < rhs.options)
    return true;
  if (rhs.options < lhs.options)
    return false;
  return false;
}
template <typename StructPtrType>
ActivateTabOptionsPtr ActivateTabOptions::Clone() const {
  return New(
      mojo::Clone(pattern),
      mojo::Clone(fallback_window_id)
  );
}

template <typename T, ActivateTabOptions::EnableIfSame<T>*>
bool ActivateTabOptions::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->pattern, other_struct.pattern))
    return false;
  if (!mojo::Equals(this->fallback_window_id, other_struct.fallback_window_id))
    return false;
  return true;
}

template <typename T, ActivateTabOptions::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.pattern < rhs.pattern)
    return true;
  if (rhs.pattern < lhs.pattern)
    return false;
  if (lhs.fallback_window_id < rhs.fallback_window_id)
    return true;
  if (rhs.fallback_window_id < lhs.fallback_window_id)
    return false;
  return false;
}
template <typename StructPtrType>
CreateTabOptionsPtr CreateTabOptions::Clone() const {
  return New(
      mojo::Clone(open_in_background),
      mojo::Clone(window_id)
  );
}

template <typename T, CreateTabOptions::EnableIfSame<T>*>
bool CreateTabOptions::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->open_in_background, other_struct.open_in_background))
    return false;
  if (!mojo::Equals(this->window_id, other_struct.window_id))
    return false;
  return true;
}

template <typename T, CreateTabOptions::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.open_in_background < rhs.open_in_background)
    return true;
  if (rhs.open_in_background < lhs.open_in_background)
    return false;
  if (lhs.window_id < rhs.window_id)
    return true;
  if (rhs.window_id < lhs.window_id)
    return false;
  return false;
}
template <typename StructPtrType>
ConversationInfoPtr ConversationInfo::Clone() const {
  return New(
      mojo::Clone(conversation_id),
      mojo::Clone(conversation_title),
      mojo::Clone(client_data),
      mojo::Clone(turn_id)
  );
}

template <typename T, ConversationInfo::EnableIfSame<T>*>
bool ConversationInfo::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->conversation_id, other_struct.conversation_id))
    return false;
  if (!mojo::Equals(this->conversation_title, other_struct.conversation_title))
    return false;
  if (!mojo::Equals(this->client_data, other_struct.client_data))
    return false;
  if (!mojo::Equals(this->turn_id, other_struct.turn_id))
    return false;
  return true;
}

template <typename T, ConversationInfo::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.conversation_id < rhs.conversation_id)
    return true;
  if (rhs.conversation_id < lhs.conversation_id)
    return false;
  if (lhs.conversation_title < rhs.conversation_title)
    return true;
  if (rhs.conversation_title < lhs.conversation_title)
    return false;
  if (lhs.client_data < rhs.client_data)
    return true;
  if (rhs.client_data < lhs.client_data)
    return false;
  if (lhs.turn_id < rhs.turn_id)
    return true;
  if (rhs.turn_id < lhs.turn_id)
    return false;
  return false;
}
template <typename StructPtrType>
PanelOpeningDataPtr PanelOpeningData::Clone() const {
  return New(
      mojo::Clone(panel_state),
      mojo::Clone(invocation_source),
      mojo::Clone(prompt_suggestion),
      mojo::Clone(auto_send),
      mojo::Clone(skill_to_invoke),
      mojo::Clone(recently_active_conversations),
      mojo::Clone(conversation_info),
      mojo::Clone(fre_override)
  );
}

template <typename T, PanelOpeningData::EnableIfSame<T>*>
bool PanelOpeningData::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->panel_state, other_struct.panel_state))
    return false;
  if (!mojo::Equals(this->invocation_source, other_struct.invocation_source))
    return false;
  if (!mojo::Equals(this->prompt_suggestion, other_struct.prompt_suggestion))
    return false;
  if (!mojo::Equals(this->auto_send, other_struct.auto_send))
    return false;
  if (!mojo::Equals(this->skill_to_invoke, other_struct.skill_to_invoke))
    return false;
  if (!mojo::Equals(this->recently_active_conversations, other_struct.recently_active_conversations))
    return false;
  if (!mojo::Equals(this->conversation_info, other_struct.conversation_info))
    return false;
  if (!mojo::Equals(this->fre_override, other_struct.fre_override))
    return false;
  return true;
}

template <typename T, PanelOpeningData::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.panel_state < rhs.panel_state)
    return true;
  if (rhs.panel_state < lhs.panel_state)
    return false;
  if (lhs.invocation_source < rhs.invocation_source)
    return true;
  if (rhs.invocation_source < lhs.invocation_source)
    return false;
  if (lhs.prompt_suggestion < rhs.prompt_suggestion)
    return true;
  if (rhs.prompt_suggestion < lhs.prompt_suggestion)
    return false;
  if (lhs.auto_send < rhs.auto_send)
    return true;
  if (rhs.auto_send < lhs.auto_send)
    return false;
  if (lhs.skill_to_invoke < rhs.skill_to_invoke)
    return true;
  if (rhs.skill_to_invoke < lhs.skill_to_invoke)
    return false;
  if (lhs.recently_active_conversations < rhs.recently_active_conversations)
    return true;
  if (rhs.recently_active_conversations < lhs.recently_active_conversations)
    return false;
  if (lhs.conversation_info < rhs.conversation_info)
    return true;
  if (rhs.conversation_info < lhs.conversation_info)
    return false;
  if (lhs.fre_override < rhs.fre_override)
    return true;
  if (rhs.fre_override < lhs.fre_override)
    return false;
  return false;
}
template <typename StructPtrType>
PanelStatePtr PanelState::Clone() const {
  return New(
      mojo::Clone(kind),
      mojo::Clone(window_id)
  );
}

template <typename T, PanelState::EnableIfSame<T>*>
bool PanelState::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->kind, other_struct.kind))
    return false;
  if (!mojo::Equals(this->window_id, other_struct.window_id))
    return false;
  return true;
}

template <typename T, PanelState::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.kind < rhs.kind)
    return true;
  if (rhs.kind < lhs.kind)
    return false;
  if (lhs.window_id < rhs.window_id)
    return true;
  if (rhs.window_id < lhs.window_id)
    return false;
  return false;
}
template <typename StructPtrType>
SkillsPayloadPtr SkillsPayload::Clone() const {
  return New(
      mojo::Clone(skill_id),
      mojo::Clone(skill_name),
      mojo::Clone(skill_icon)
  );
}

template <typename T, SkillsPayload::EnableIfSame<T>*>
bool SkillsPayload::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->skill_id, other_struct.skill_id))
    return false;
  if (!mojo::Equals(this->skill_name, other_struct.skill_name))
    return false;
  if (!mojo::Equals(this->skill_icon, other_struct.skill_icon))
    return false;
  return true;
}

template <typename T, SkillsPayload::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.skill_id < rhs.skill_id)
    return true;
  if (rhs.skill_id < lhs.skill_id)
    return false;
  if (lhs.skill_name < rhs.skill_name)
    return true;
  if (rhs.skill_name < lhs.skill_name)
    return false;
  if (lhs.skill_icon < rhs.skill_icon)
    return true;
  if (rhs.skill_icon < lhs.skill_icon)
    return false;
  return false;
}
template <typename StructPtrType>
UniversalCartPayloadPtr UniversalCartPayload::Clone() const {
  return New(
      mojo::Clone(serialized_metadata)
  );
}

template <typename T, UniversalCartPayload::EnableIfSame<T>*>
bool UniversalCartPayload::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->serialized_metadata, other_struct.serialized_metadata))
    return false;
  return true;
}

template <typename T, UniversalCartPayload::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.serialized_metadata < rhs.serialized_metadata)
    return true;
  if (rhs.serialized_metadata < lhs.serialized_metadata)
    return false;
  return false;
}
template <typename StructPtrType>
InvokeOptionsPtr InvokeOptions::Clone() const {
  return New(
      mojo::Clone(invocation_source),
      mojo::Clone(prompts),
      mojo::Clone(context),
      mojo::Clone(auto_submit),
      mojo::Clone(feature_mode),
      mojo::Clone(actuation_target),
      mojo::Clone(disable_zero_state_suggestions),
      mojo::Clone(skill_id),
      mojo::Clone(zss_config),
      mojo::Clone(payload),
      mojo::Clone(actuation_tab_id)
  );
}

template <typename T, InvokeOptions::EnableIfSame<T>*>
bool InvokeOptions::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->invocation_source, other_struct.invocation_source))
    return false;
  if (!mojo::Equals(this->prompts, other_struct.prompts))
    return false;
  if (!mojo::Equals(this->context, other_struct.context))
    return false;
  if (!mojo::Equals(this->auto_submit, other_struct.auto_submit))
    return false;
  if (!mojo::Equals(this->feature_mode, other_struct.feature_mode))
    return false;
  if (!mojo::Equals(this->actuation_target, other_struct.actuation_target))
    return false;
  if (!mojo::Equals(this->disable_zero_state_suggestions, other_struct.disable_zero_state_suggestions))
    return false;
  if (!mojo::Equals(this->skill_id, other_struct.skill_id))
    return false;
  if (!mojo::Equals(this->zss_config, other_struct.zss_config))
    return false;
  if (!mojo::Equals(this->payload, other_struct.payload))
    return false;
  if (!mojo::Equals(this->actuation_tab_id, other_struct.actuation_tab_id))
    return false;
  return true;
}

template <typename T, InvokeOptions::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.invocation_source < rhs.invocation_source)
    return true;
  if (rhs.invocation_source < lhs.invocation_source)
    return false;
  if (lhs.prompts < rhs.prompts)
    return true;
  if (rhs.prompts < lhs.prompts)
    return false;
  if (lhs.context < rhs.context)
    return true;
  if (rhs.context < lhs.context)
    return false;
  if (lhs.auto_submit < rhs.auto_submit)
    return true;
  if (rhs.auto_submit < lhs.auto_submit)
    return false;
  if (lhs.feature_mode < rhs.feature_mode)
    return true;
  if (rhs.feature_mode < lhs.feature_mode)
    return false;
  if (lhs.actuation_target < rhs.actuation_target)
    return true;
  if (rhs.actuation_target < lhs.actuation_target)
    return false;
  if (lhs.disable_zero_state_suggestions < rhs.disable_zero_state_suggestions)
    return true;
  if (rhs.disable_zero_state_suggestions < lhs.disable_zero_state_suggestions)
    return false;
  if (lhs.skill_id < rhs.skill_id)
    return true;
  if (rhs.skill_id < lhs.skill_id)
    return false;
  if (lhs.zss_config < rhs.zss_config)
    return true;
  if (rhs.zss_config < lhs.zss_config)
    return false;
  if (lhs.payload < rhs.payload)
    return true;
  if (rhs.payload < lhs.payload)
    return false;
  if (lhs.actuation_tab_id < rhs.actuation_tab_id)
    return true;
  if (rhs.actuation_tab_id < lhs.actuation_tab_id)
    return false;
  return false;
}
template <typename StructPtrType>
OnResponseStoppedDetailsPtr OnResponseStoppedDetails::Clone() const {
  return New(
      mojo::Clone(cause)
  );
}

template <typename T, OnResponseStoppedDetails::EnableIfSame<T>*>
bool OnResponseStoppedDetails::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->cause, other_struct.cause))
    return false;
  return true;
}

template <typename T, OnResponseStoppedDetails::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.cause < rhs.cause)
    return true;
  if (rhs.cause < lhs.cause)
    return false;
  return false;
}
template <typename StructPtrType>
OpenPanelInfoPtr OpenPanelInfo::Clone() const {
  return New(
      mojo::Clone(web_client_mode),
      mojo::Clone(panelSize),
      mojo::Clone(resizeDuration),
      mojo::Clone(can_user_resize)
  );
}

template <typename T, OpenPanelInfo::EnableIfSame<T>*>
bool OpenPanelInfo::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->web_client_mode, other_struct.web_client_mode))
    return false;
  if (!mojo::Equals(this->panelSize, other_struct.panelSize))
    return false;
  if (!mojo::Equals(this->resizeDuration, other_struct.resizeDuration))
    return false;
  if (!mojo::Equals(this->can_user_resize, other_struct.can_user_resize))
    return false;
  return true;
}

template <typename T, OpenPanelInfo::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.web_client_mode < rhs.web_client_mode)
    return true;
  if (rhs.web_client_mode < lhs.web_client_mode)
    return false;
  if (lhs.panelSize < rhs.panelSize)
    return true;
  if (rhs.panelSize < lhs.panelSize)
    return false;
  if (lhs.resizeDuration < rhs.resizeDuration)
    return true;
  if (rhs.resizeDuration < lhs.resizeDuration)
    return false;
  if (lhs.can_user_resize < rhs.can_user_resize)
    return true;
  if (rhs.can_user_resize < lhs.can_user_resize)
    return false;
  return false;
}
template <typename StructPtrType>
ContextDataPtr ContextData::Clone() const {
  return New(
      mojo::Clone(mime_type),
      mojo::Clone(data),
      mojo::Clone(filename)
  );
}

template <typename T, ContextData::EnableIfSame<T>*>
bool ContextData::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->mime_type, other_struct.mime_type))
    return false;
  if (!mojo::Equals(this->data, other_struct.data))
    return false;
  if (!mojo::Equals(this->filename, other_struct.filename))
    return false;
  return true;
}

template <typename T, ContextData::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.mime_type < rhs.mime_type)
    return true;
  if (rhs.mime_type < lhs.mime_type)
    return false;
  if (lhs.data < rhs.data)
    return true;
  if (rhs.data < lhs.data)
    return false;
  if (lhs.filename < rhs.filename)
    return true;
  if (rhs.filename < lhs.filename)
    return false;
  return false;
}
template <typename StructPtrType>
ParentConversationMetadataPtr ParentConversationMetadata::Clone() const {
  return New(
      mojo::Clone(conversation_id),
      mojo::Clone(conversation_title)
  );
}

template <typename T, ParentConversationMetadata::EnableIfSame<T>*>
bool ParentConversationMetadata::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->conversation_id, other_struct.conversation_id))
    return false;
  if (!mojo::Equals(this->conversation_title, other_struct.conversation_title))
    return false;
  return true;
}

template <typename T, ParentConversationMetadata::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.conversation_id < rhs.conversation_id)
    return true;
  if (rhs.conversation_id < lhs.conversation_id)
    return false;
  if (lhs.conversation_title < rhs.conversation_title)
    return true;
  if (rhs.conversation_title < lhs.conversation_title)
    return false;
  return false;
}
template <typename StructPtrType>
AdditionalContextPtr AdditionalContext::Clone() const {
  return New(
      mojo::Clone(source),
      mojo::Clone(name),
      mojo::Clone(tab_id),
      mojo::Clone(origin),
      mojo::Clone(frameUrl),
      mojo::Clone(parts)
  );
}

template <typename T, AdditionalContext::EnableIfSame<T>*>
bool AdditionalContext::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->source, other_struct.source))
    return false;
  if (!mojo::Equals(this->name, other_struct.name))
    return false;
  if (!mojo::Equals(this->tab_id, other_struct.tab_id))
    return false;
  if (!mojo::Equals(this->origin, other_struct.origin))
    return false;
  if (!mojo::Equals(this->frameUrl, other_struct.frameUrl))
    return false;
  if (!mojo::Equals(this->parts, other_struct.parts))
    return false;
  return true;
}

template <typename T, AdditionalContext::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.source < rhs.source)
    return true;
  if (rhs.source < lhs.source)
    return false;
  if (lhs.name < rhs.name)
    return true;
  if (rhs.name < lhs.name)
    return false;
  if (lhs.tab_id < rhs.tab_id)
    return true;
  if (rhs.tab_id < lhs.tab_id)
    return false;
  if (lhs.origin < rhs.origin)
    return true;
  if (rhs.origin < lhs.origin)
    return false;
  if (lhs.frameUrl < rhs.frameUrl)
    return true;
  if (rhs.frameUrl < lhs.frameUrl)
    return false;
  if (lhs.parts < rhs.parts)
    return true;
  if (rhs.parts < lhs.parts)
    return false;
  return false;
}
template <typename StructPtrType>
ExperimentalTriggeringUpdatePtr ExperimentalTriggeringUpdate::Clone() const {
  return New(
      mojo::Clone(type),
      mojo::Clone(data),
      mojo::Clone(metadata)
  );
}

template <typename T, ExperimentalTriggeringUpdate::EnableIfSame<T>*>
bool ExperimentalTriggeringUpdate::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->type, other_struct.type))
    return false;
  if (!mojo::Equals(this->data, other_struct.data))
    return false;
  if (!mojo::Equals(this->metadata, other_struct.metadata))
    return false;
  return true;
}

template <typename T, ExperimentalTriggeringUpdate::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.type < rhs.type)
    return true;
  if (rhs.type < lhs.type)
    return false;
  if (lhs.data < rhs.data)
    return true;
  if (rhs.data < lhs.data)
    return false;
  if (lhs.metadata < rhs.metadata)
    return true;
  if (rhs.metadata < lhs.metadata)
    return false;
  return false;
}
template <typename StructPtrType>
TabContextResultPtr TabContextResult::Clone() const {
  return New(
      mojo::Clone(tab_data),
      mojo::Clone(web_page_data),
      mojo::Clone(viewport_screenshot),
      mojo::Clone(screenshot_info),
      mojo::Clone(pdf_document_data),
      mojo::Clone(annotated_page_data)
  );
}

template <typename T, TabContextResult::EnableIfSame<T>*>
bool TabContextResult::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->tab_data, other_struct.tab_data))
    return false;
  if (!mojo::Equals(this->web_page_data, other_struct.web_page_data))
    return false;
  if (!mojo::Equals(this->viewport_screenshot, other_struct.viewport_screenshot))
    return false;
  if (!mojo::Equals(this->screenshot_info, other_struct.screenshot_info))
    return false;
  if (!mojo::Equals(this->pdf_document_data, other_struct.pdf_document_data))
    return false;
  if (!mojo::Equals(this->annotated_page_data, other_struct.annotated_page_data))
    return false;
  return true;
}

template <typename T, TabContextResult::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.tab_data < rhs.tab_data)
    return true;
  if (rhs.tab_data < lhs.tab_data)
    return false;
  if (lhs.web_page_data < rhs.web_page_data)
    return true;
  if (rhs.web_page_data < lhs.web_page_data)
    return false;
  if (lhs.viewport_screenshot < rhs.viewport_screenshot)
    return true;
  if (rhs.viewport_screenshot < lhs.viewport_screenshot)
    return false;
  if (lhs.screenshot_info < rhs.screenshot_info)
    return true;
  if (rhs.screenshot_info < lhs.screenshot_info)
    return false;
  if (lhs.pdf_document_data < rhs.pdf_document_data)
    return true;
  if (rhs.pdf_document_data < lhs.pdf_document_data)
    return false;
  if (lhs.annotated_page_data < rhs.annotated_page_data)
    return true;
  if (rhs.annotated_page_data < lhs.annotated_page_data)
    return false;
  return false;
}
template <typename StructPtrType>
WebPageDataPtr WebPageData::Clone() const {
  return New(
      mojo::Clone(main_document)
  );
}

template <typename T, WebPageData::EnableIfSame<T>*>
bool WebPageData::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->main_document, other_struct.main_document))
    return false;
  return true;
}

template <typename T, WebPageData::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.main_document < rhs.main_document)
    return true;
  if (rhs.main_document < lhs.main_document)
    return false;
  return false;
}
template <typename StructPtrType>
DocumentDataPtr DocumentData::Clone() const {
  return New(
      mojo::Clone(origin),
      mojo::Clone(inner_text),
      mojo::Clone(inner_text_truncated)
  );
}

template <typename T, DocumentData::EnableIfSame<T>*>
bool DocumentData::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->origin, other_struct.origin))
    return false;
  if (!mojo::Equals(this->inner_text, other_struct.inner_text))
    return false;
  if (!mojo::Equals(this->inner_text_truncated, other_struct.inner_text_truncated))
    return false;
  return true;
}

template <typename T, DocumentData::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.origin < rhs.origin)
    return true;
  if (rhs.origin < lhs.origin)
    return false;
  if (lhs.inner_text < rhs.inner_text)
    return true;
  if (rhs.inner_text < lhs.inner_text)
    return false;
  if (lhs.inner_text_truncated < rhs.inner_text_truncated)
    return true;
  if (rhs.inner_text_truncated < lhs.inner_text_truncated)
    return false;
  return false;
}
template <typename StructPtrType>
PdfDocumentDataPtr PdfDocumentData::Clone() const {
  return New(
      mojo::Clone(origin),
      mojo::Clone(pdf_data),
      mojo::Clone(pdf_size_limit_exceeded)
  );
}

template <typename T, PdfDocumentData::EnableIfSame<T>*>
bool PdfDocumentData::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->origin, other_struct.origin))
    return false;
  if (!mojo::Equals(this->pdf_data, other_struct.pdf_data))
    return false;
  if (!mojo::Equals(this->pdf_size_limit_exceeded, other_struct.pdf_size_limit_exceeded))
    return false;
  return true;
}

template <typename T, PdfDocumentData::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.origin < rhs.origin)
    return true;
  if (rhs.origin < lhs.origin)
    return false;
  if (lhs.pdf_data < rhs.pdf_data)
    return true;
  if (rhs.pdf_data < lhs.pdf_data)
    return false;
  if (lhs.pdf_size_limit_exceeded < rhs.pdf_size_limit_exceeded)
    return true;
  if (rhs.pdf_size_limit_exceeded < lhs.pdf_size_limit_exceeded)
    return false;
  return false;
}
template <typename StructPtrType>
TabDataPtr TabData::Clone() const {
  return New(
      mojo::Clone(tab_id),
      mojo::Clone(window_id),
      mojo::Clone(url),
      mojo::Clone(title),
      mojo::Clone(favicon),
      mojo::Clone(favicon_url),
      mojo::Clone(document_mime_type),
      mojo::Clone(is_observable),
      mojo::Clone(is_media_active),
      mojo::Clone(is_tab_content_captured),
      mojo::Clone(is_active_in_window),
      mojo::Clone(is_window_active),
      mojo::Clone(lightweight_page_features)
  );
}

template <typename T, TabData::EnableIfSame<T>*>
bool TabData::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->tab_id, other_struct.tab_id))
    return false;
  if (!mojo::Equals(this->window_id, other_struct.window_id))
    return false;
  if (!mojo::Equals(this->url, other_struct.url))
    return false;
  if (!mojo::Equals(this->title, other_struct.title))
    return false;
  if (!mojo::Equals(this->favicon, other_struct.favicon))
    return false;
  if (!mojo::Equals(this->favicon_url, other_struct.favicon_url))
    return false;
  if (!mojo::Equals(this->document_mime_type, other_struct.document_mime_type))
    return false;
  if (!mojo::Equals(this->is_observable, other_struct.is_observable))
    return false;
  if (!mojo::Equals(this->is_media_active, other_struct.is_media_active))
    return false;
  if (!mojo::Equals(this->is_tab_content_captured, other_struct.is_tab_content_captured))
    return false;
  if (!mojo::Equals(this->is_active_in_window, other_struct.is_active_in_window))
    return false;
  if (!mojo::Equals(this->is_window_active, other_struct.is_window_active))
    return false;
  if (!mojo::Equals(this->lightweight_page_features, other_struct.lightweight_page_features))
    return false;
  return true;
}

template <typename T, TabData::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.tab_id < rhs.tab_id)
    return true;
  if (rhs.tab_id < lhs.tab_id)
    return false;
  if (lhs.window_id < rhs.window_id)
    return true;
  if (rhs.window_id < lhs.window_id)
    return false;
  if (lhs.url < rhs.url)
    return true;
  if (rhs.url < lhs.url)
    return false;
  if (lhs.title < rhs.title)
    return true;
  if (rhs.title < lhs.title)
    return false;
  if (lhs.favicon < rhs.favicon)
    return true;
  if (rhs.favicon < lhs.favicon)
    return false;
  if (lhs.favicon_url < rhs.favicon_url)
    return true;
  if (rhs.favicon_url < lhs.favicon_url)
    return false;
  if (lhs.document_mime_type < rhs.document_mime_type)
    return true;
  if (rhs.document_mime_type < lhs.document_mime_type)
    return false;
  if (lhs.is_observable < rhs.is_observable)
    return true;
  if (rhs.is_observable < lhs.is_observable)
    return false;
  if (lhs.is_media_active < rhs.is_media_active)
    return true;
  if (rhs.is_media_active < lhs.is_media_active)
    return false;
  if (lhs.is_tab_content_captured < rhs.is_tab_content_captured)
    return true;
  if (rhs.is_tab_content_captured < lhs.is_tab_content_captured)
    return false;
  if (lhs.is_active_in_window < rhs.is_active_in_window)
    return true;
  if (rhs.is_active_in_window < lhs.is_active_in_window)
    return false;
  if (lhs.is_window_active < rhs.is_window_active)
    return true;
  if (rhs.is_window_active < lhs.is_window_active)
    return false;
  if (lhs.lightweight_page_features < rhs.lightweight_page_features)
    return true;
  if (rhs.lightweight_page_features < lhs.lightweight_page_features)
    return false;
  return false;
}
template <typename StructPtrType>
NoFocusedTabDataPtr NoFocusedTabData::Clone() const {
  return New(
      mojo::Clone(active_tab_data),
      mojo::Clone(no_focus_reason)
  );
}

template <typename T, NoFocusedTabData::EnableIfSame<T>*>
bool NoFocusedTabData::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->active_tab_data, other_struct.active_tab_data))
    return false;
  if (!mojo::Equals(this->no_focus_reason, other_struct.no_focus_reason))
    return false;
  return true;
}

template <typename T, NoFocusedTabData::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.active_tab_data < rhs.active_tab_data)
    return true;
  if (rhs.active_tab_data < lhs.active_tab_data)
    return false;
  if (lhs.no_focus_reason < rhs.no_focus_reason)
    return true;
  if (rhs.no_focus_reason < lhs.no_focus_reason)
    return false;
  return false;
}
template <typename StructPtrType>
AnnotatedPageDataPtr AnnotatedPageData::Clone() const {
  return New(
      mojo::Clone(annotated_page_content),
      mojo::Clone(metadata)
  );
}

template <typename T, AnnotatedPageData::EnableIfSame<T>*>
bool AnnotatedPageData::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->annotated_page_content, other_struct.annotated_page_content))
    return false;
  if (!mojo::Equals(this->metadata, other_struct.metadata))
    return false;
  return true;
}

template <typename T, AnnotatedPageData::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.annotated_page_content < rhs.annotated_page_content)
    return true;
  if (rhs.annotated_page_content < lhs.annotated_page_content)
    return false;
  if (lhs.metadata < rhs.metadata)
    return true;
  if (rhs.metadata < lhs.metadata)
    return false;
  return false;
}
template <typename StructPtrType>
ImageOriginAnnotationsPtr ImageOriginAnnotations::Clone() const {
  return New(
  );
}

template <typename T, ImageOriginAnnotations::EnableIfSame<T>*>
bool ImageOriginAnnotations::Equals(const T& other_struct) const {
  return true;
}

template <typename T, ImageOriginAnnotations::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  return false;
}
template <typename StructPtrType>
JournalPtr Journal::Clone() const {
  return New(
      mojo::Clone(data)
  );
}

template <typename T, Journal::EnableIfSame<T>*>
bool Journal::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->data, other_struct.data))
    return false;
  return true;
}

template <typename T, Journal::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>
PendingCapturedRegionPtr PendingCapturedRegion::Clone() const {
  return New(
      mojo::Clone(id),
      mojo::Clone(region)
  );
}

template <typename T, PendingCapturedRegion::EnableIfSame<T>*>
bool PendingCapturedRegion::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->id, other_struct.id))
    return false;
  if (!mojo::Equals(this->region, other_struct.region))
    return false;
  return true;
}

template <typename T, PendingCapturedRegion::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.region < rhs.region)
    return true;
  if (rhs.region < lhs.region)
    return false;
  return false;
}
template <typename StructPtrType>
CaptureRegionResultPtr CaptureRegionResult::Clone() const {
  return New(
      mojo::Clone(tab_id),
      mojo::Clone(region)
  );
}

template <typename T, CaptureRegionResult::EnableIfSame<T>*>
bool CaptureRegionResult::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->tab_id, other_struct.tab_id))
    return false;
  if (!mojo::Equals(this->region, other_struct.region))
    return false;
  return true;
}

template <typename T, CaptureRegionResult::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.tab_id < rhs.tab_id)
    return true;
  if (rhs.tab_id < lhs.tab_id)
    return false;
  if (lhs.region < rhs.region)
    return true;
  if (rhs.region < lhs.region)
    return false;
  return false;
}
template <typename StructPtrType>
ScreenshotPtr Screenshot::Clone() const {
  return New(
      mojo::Clone(width_pixels),
      mojo::Clone(height_pixels),
      mojo::Clone(data),
      mojo::Clone(mime_type),
      mojo::Clone(origin_annotations),
      mojo::Clone(encryption_scheme)
  );
}

template <typename T, Screenshot::EnableIfSame<T>*>
bool Screenshot::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->width_pixels, other_struct.width_pixels))
    return false;
  if (!mojo::Equals(this->height_pixels, other_struct.height_pixels))
    return false;
  if (!mojo::Equals(this->data, other_struct.data))
    return false;
  if (!mojo::Equals(this->mime_type, other_struct.mime_type))
    return false;
  if (!mojo::Equals(this->origin_annotations, other_struct.origin_annotations))
    return false;
  if (!mojo::Equals(this->encryption_scheme, other_struct.encryption_scheme))
    return false;
  return true;
}

template <typename T, Screenshot::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.width_pixels < rhs.width_pixels)
    return true;
  if (rhs.width_pixels < lhs.width_pixels)
    return false;
  if (lhs.height_pixels < rhs.height_pixels)
    return true;
  if (rhs.height_pixels < lhs.height_pixels)
    return false;
  if (lhs.data < rhs.data)
    return true;
  if (rhs.data < lhs.data)
    return false;
  if (lhs.mime_type < rhs.mime_type)
    return true;
  if (rhs.mime_type < lhs.mime_type)
    return false;
  if (lhs.origin_annotations < rhs.origin_annotations)
    return true;
  if (rhs.origin_annotations < lhs.origin_annotations)
    return false;
  if (lhs.encryption_scheme < rhs.encryption_scheme)
    return true;
  if (rhs.encryption_scheme < lhs.encryption_scheme)
    return false;
  return false;
}
template <typename StructPtrType>
ImageInfoPtr ImageInfo::Clone() const {
  return New(
      mojo::Clone(caption),
      mojo::Clone(source_origin),
      mojo::Clone(url),
      mojo::Clone(mime_type)
  );
}

template <typename T, ImageInfo::EnableIfSame<T>*>
bool ImageInfo::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->caption, other_struct.caption))
    return false;
  if (!mojo::Equals(this->source_origin, other_struct.source_origin))
    return false;
  if (!mojo::Equals(this->url, other_struct.url))
    return false;
  if (!mojo::Equals(this->mime_type, other_struct.mime_type))
    return false;
  return true;
}

template <typename T, ImageInfo::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.caption < rhs.caption)
    return true;
  if (rhs.caption < lhs.caption)
    return false;
  if (lhs.source_origin < rhs.source_origin)
    return true;
  if (rhs.source_origin < lhs.source_origin)
    return false;
  if (lhs.url < rhs.url)
    return true;
  if (rhs.url < lhs.url)
    return false;
  if (lhs.mime_type < rhs.mime_type)
    return true;
  if (rhs.mime_type < lhs.mime_type)
    return false;
  return false;
}
template <typename StructPtrType>
ImageBytesResultPtr ImageBytesResult::Clone() const {
  return New(
      mojo::Clone(bytes),
      mojo::Clone(image_info)
  );
}

template <typename T, ImageBytesResult::EnableIfSame<T>*>
bool ImageBytesResult::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->bytes, other_struct.bytes))
    return false;
  if (!mojo::Equals(this->image_info, other_struct.image_info))
    return false;
  return true;
}

template <typename T, ImageBytesResult::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.bytes < rhs.bytes)
    return true;
  if (rhs.bytes < lhs.bytes)
    return false;
  if (lhs.image_info < rhs.image_info)
    return true;
  if (rhs.image_info < lhs.image_info)
    return false;
  return false;
}
template <typename StructPtrType>
OpenSettingsOptionsPtr OpenSettingsOptions::Clone() const {
  return New(
      mojo::Clone(highlightField)
  );
}

template <typename T, OpenSettingsOptions::EnableIfSame<T>*>
bool OpenSettingsOptions::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->highlightField, other_struct.highlightField))
    return false;
  return true;
}

template <typename T, OpenSettingsOptions::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.highlightField < rhs.highlightField)
    return true;
  if (rhs.highlightField < lhs.highlightField)
    return false;
  return false;
}


}  // glic::mojom

namespace mojo {


template <>
struct  StructTraits<::glic::mojom::GeminiEnterpriseSettings::DataView,
                                         ::glic::mojom::GeminiEnterpriseSettingsPtr> {
  static bool IsNull(const ::glic::mojom::GeminiEnterpriseSettingsPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::GeminiEnterpriseSettingsPtr* output) { output->reset(); }

  static const decltype(::glic::mojom::GeminiEnterpriseSettings::project_id)& project_id(
      const ::glic::mojom::GeminiEnterpriseSettingsPtr& input) {
    return input->project_id;
  }

  static const decltype(::glic::mojom::GeminiEnterpriseSettings::app_id)& app_id(
      const ::glic::mojom::GeminiEnterpriseSettingsPtr& input) {
    return input->app_id;
  }

  static const decltype(::glic::mojom::GeminiEnterpriseSettings::location)& location(
      const ::glic::mojom::GeminiEnterpriseSettingsPtr& input) {
    return input->location;
  }

  static bool Read(::glic::mojom::GeminiEnterpriseSettings::DataView input, ::glic::mojom::GeminiEnterpriseSettingsPtr* output);
};


template <>
struct  StructTraits<::glic::mojom::ProfileEnablement::DataView,
                                         ::glic::mojom::ProfileEnablementPtr> {
  static bool IsNull(const ::glic::mojom::ProfileEnablementPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::ProfileEnablementPtr* output) { output->reset(); }

  static decltype(::glic::mojom::ProfileEnablement::feature_enabled) feature_enabled(
      const ::glic::mojom::ProfileEnablementPtr& input) {
    return input->feature_enabled;
  }

  static decltype(::glic::mojom::ProfileEnablement::is_regular_profile) is_regular_profile(
      const ::glic::mojom::ProfileEnablementPtr& input) {
    return input->is_regular_profile;
  }

  static decltype(::glic::mojom::ProfileEnablement::is_rolled_out) is_rolled_out(
      const ::glic::mojom::ProfileEnablementPtr& input) {
    return input->is_rolled_out;
  }

  static decltype(::glic::mojom::ProfileEnablement::primary_account_is_capable) primary_account_is_capable(
      const ::glic::mojom::ProfileEnablementPtr& input) {
    return input->primary_account_is_capable;
  }

  static decltype(::glic::mojom::ProfileEnablement::primary_account_is_fully_signed_in) primary_account_is_fully_signed_in(
      const ::glic::mojom::ProfileEnablementPtr& input) {
    return input->primary_account_is_fully_signed_in;
  }

  static decltype(::glic::mojom::ProfileEnablement::allowed_by_chrome_policy) allowed_by_chrome_policy(
      const ::glic::mojom::ProfileEnablementPtr& input) {
    return input->allowed_by_chrome_policy;
  }

  static decltype(::glic::mojom::ProfileEnablement::allowed_by_remote_admin) allowed_by_remote_admin(
      const ::glic::mojom::ProfileEnablementPtr& input) {
    return input->allowed_by_remote_admin;
  }

  static decltype(::glic::mojom::ProfileEnablement::allowed_by_remote_other) allowed_by_remote_other(
      const ::glic::mojom::ProfileEnablementPtr& input) {
    return input->allowed_by_remote_other;
  }

  static decltype(::glic::mojom::ProfileEnablement::fre_is_consented) fre_is_consented(
      const ::glic::mojom::ProfileEnablementPtr& input) {
    return input->fre_is_consented;
  }

  static decltype(::glic::mojom::ProfileEnablement::allowed_by_country_filter) allowed_by_country_filter(
      const ::glic::mojom::ProfileEnablementPtr& input) {
    return input->allowed_by_country_filter;
  }

  static decltype(::glic::mojom::ProfileEnablement::allowed_by_locale_filter) allowed_by_locale_filter(
      const ::glic::mojom::ProfileEnablementPtr& input) {
    return input->allowed_by_locale_filter;
  }

  static decltype(::glic::mojom::ProfileEnablement::actuation_is_consented) actuation_is_consented(
      const ::glic::mojom::ProfileEnablementPtr& input) {
    return input->actuation_is_consented;
  }

  static decltype(::glic::mojom::ProfileEnablement::live_allowed) live_allowed(
      const ::glic::mojom::ProfileEnablementPtr& input) {
    return input->live_allowed;
  }

  static decltype(::glic::mojom::ProfileEnablement::share_image_allowed) share_image_allowed(
      const ::glic::mojom::ProfileEnablementPtr& input) {
    return input->share_image_allowed;
  }

  static const decltype(::glic::mojom::ProfileEnablement::gemini_enterprise_settings)& gemini_enterprise_settings(
      const ::glic::mojom::ProfileEnablementPtr& input) {
    return input->gemini_enterprise_settings;
  }

  static decltype(::glic::mojom::ProfileEnablement::actuation_eligibility) actuation_eligibility(
      const ::glic::mojom::ProfileEnablementPtr& input) {
    return input->actuation_eligibility;
  }

  static decltype(::glic::mojom::ProfileEnablement::glic_api_actuation_eligibility) glic_api_actuation_eligibility(
      const ::glic::mojom::ProfileEnablementPtr& input) {
    return input->glic_api_actuation_eligibility;
  }

  static decltype(::glic::mojom::ProfileEnablement::glic_experimental_triggering_state) glic_experimental_triggering_state(
      const ::glic::mojom::ProfileEnablementPtr& input) {
    return input->glic_experimental_triggering_state;
  }

  static bool Read(::glic::mojom::ProfileEnablement::DataView input, ::glic::mojom::ProfileEnablementPtr* output);
};


template <>
struct  StructTraits<::glic::mojom::ConfigInfo::DataView,
                                         ::glic::mojom::ConfigInfoPtr> {
  static bool IsNull(const ::glic::mojom::ConfigInfoPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::ConfigInfoPtr* output) { output->reset(); }

  static const decltype(::glic::mojom::ConfigInfo::guest_url)& guest_url(
      const ::glic::mojom::ConfigInfoPtr& input) {
    return input->guest_url;
  }

  static const decltype(::glic::mojom::ConfigInfo::autopush_guest_url)& autopush_guest_url(
      const ::glic::mojom::ConfigInfoPtr& input) {
    return input->autopush_guest_url;
  }

  static const decltype(::glic::mojom::ConfigInfo::staging_guest_url)& staging_guest_url(
      const ::glic::mojom::ConfigInfoPtr& input) {
    return input->staging_guest_url;
  }

  static const decltype(::glic::mojom::ConfigInfo::preprod_guest_url)& preprod_guest_url(
      const ::glic::mojom::ConfigInfoPtr& input) {
    return input->preprod_guest_url;
  }

  static const decltype(::glic::mojom::ConfigInfo::prod_guest_url)& prod_guest_url(
      const ::glic::mojom::ConfigInfoPtr& input) {
    return input->prod_guest_url;
  }

  static const decltype(::glic::mojom::ConfigInfo::web_continuity_originating_host_url)& web_continuity_originating_host_url(
      const ::glic::mojom::ConfigInfoPtr& input) {
    return input->web_continuity_originating_host_url;
  }

  static bool Read(::glic::mojom::ConfigInfo::DataView input, ::glic::mojom::ConfigInfoPtr* output);
};


template <>
struct  StructTraits<::glic::mojom::DefaultConversation::DataView,
                                         ::glic::mojom::DefaultConversationPtr> {
  static bool IsNull(const ::glic::mojom::DefaultConversationPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::DefaultConversationPtr* output) { output->reset(); }

  static bool Read(::glic::mojom::DefaultConversation::DataView input, ::glic::mojom::DefaultConversationPtr* output);
};


template <>
struct  StructTraits<::glic::mojom::NewConversation::DataView,
                                         ::glic::mojom::NewConversationPtr> {
  static bool IsNull(const ::glic::mojom::NewConversationPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::NewConversationPtr* output) { output->reset(); }

  static bool Read(::glic::mojom::NewConversation::DataView input, ::glic::mojom::NewConversationPtr* output);
};


template <>
struct  StructTraits<::glic::mojom::DefaultSurfaceMojo::DataView,
                                         ::glic::mojom::DefaultSurfaceMojoPtr> {
  static bool IsNull(const ::glic::mojom::DefaultSurfaceMojoPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::DefaultSurfaceMojoPtr* output) { output->reset(); }

  static bool Read(::glic::mojom::DefaultSurfaceMojo::DataView input, ::glic::mojom::DefaultSurfaceMojoPtr* output);
};


template <>
struct  StructTraits<::glic::mojom::NewTabMojo::DataView,
                                         ::glic::mojom::NewTabMojoPtr> {
  static bool IsNull(const ::glic::mojom::NewTabMojoPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::NewTabMojoPtr* output) { output->reset(); }

  static decltype(::glic::mojom::NewTabMojo::open_in_foreground) open_in_foreground(
      const ::glic::mojom::NewTabMojoPtr& input) {
    return input->open_in_foreground;
  }

  static bool Read(::glic::mojom::NewTabMojo::DataView input, ::glic::mojom::NewTabMojoPtr* output);
};


template <>
struct  StructTraits<::glic::mojom::ZssConfig::DataView,
                                         ::glic::mojom::ZssConfigPtr> {
  static bool IsNull(const ::glic::mojom::ZssConfigPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::ZssConfigPtr* output) { output->reset(); }

  static const decltype(::glic::mojom::ZssConfig::additional_content)& additional_content(
      const ::glic::mojom::ZssConfigPtr& input) {
    return input->additional_content;
  }

  static bool Read(::glic::mojom::ZssConfig::DataView input, ::glic::mojom::ZssConfigPtr* output);
};


template <>
struct  StructTraits<::glic::mojom::GetContextResultWithActionResultCode::DataView,
                                         ::glic::mojom::GetContextResultWithActionResultCodePtr> {
  static bool IsNull(const ::glic::mojom::GetContextResultWithActionResultCodePtr& input) { return !input; }
  static void SetToNull(::glic::mojom::GetContextResultWithActionResultCodePtr* output) { output->reset(); }

  static  decltype(::glic::mojom::GetContextResultWithActionResultCode::get_context_result)& get_context_result(
       ::glic::mojom::GetContextResultWithActionResultCodePtr& input) {
    return input->get_context_result;
  }

  static decltype(::glic::mojom::GetContextResultWithActionResultCode::action_result) action_result(
      const ::glic::mojom::GetContextResultWithActionResultCodePtr& input) {
    return input->action_result;
  }

  static bool Read(::glic::mojom::GetContextResultWithActionResultCode::DataView input, ::glic::mojom::GetContextResultWithActionResultCodePtr* output);
};


template <>
struct  StructTraits<::glic::mojom::UserProfileInfo::DataView,
                                         ::glic::mojom::UserProfileInfoPtr> {
  static bool IsNull(const ::glic::mojom::UserProfileInfoPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::UserProfileInfoPtr* output) { output->reset(); }

  static  decltype(::glic::mojom::UserProfileInfo::avatar_icon)& avatar_icon(
       ::glic::mojom::UserProfileInfoPtr& input) {
    return input->avatar_icon;
  }

  static const decltype(::glic::mojom::UserProfileInfo::display_name)& display_name(
      const ::glic::mojom::UserProfileInfoPtr& input) {
    return input->display_name;
  }

  static const decltype(::glic::mojom::UserProfileInfo::given_name)& given_name(
      const ::glic::mojom::UserProfileInfoPtr& input) {
    return input->given_name;
  }

  static const decltype(::glic::mojom::UserProfileInfo::local_profile_name)& local_profile_name(
      const ::glic::mojom::UserProfileInfoPtr& input) {
    return input->local_profile_name;
  }

  static const decltype(::glic::mojom::UserProfileInfo::email)& email(
      const ::glic::mojom::UserProfileInfoPtr& input) {
    return input->email;
  }

  static decltype(::glic::mojom::UserProfileInfo::is_managed) is_managed(
      const ::glic::mojom::UserProfileInfoPtr& input) {
    return input->is_managed;
  }

  static bool Read(::glic::mojom::UserProfileInfo::DataView input, ::glic::mojom::UserProfileInfoPtr* output);
};


template <>
struct  StructTraits<::glic::mojom::SafeBrowsingVerdict::DataView,
                                         ::glic::mojom::SafeBrowsingVerdictPtr> {
  static bool IsNull(const ::glic::mojom::SafeBrowsingVerdictPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::SafeBrowsingVerdictPtr* output) { output->reset(); }

  static const decltype(::glic::mojom::SafeBrowsingVerdict::url)& url(
      const ::glic::mojom::SafeBrowsingVerdictPtr& input) {
    return input->url;
  }

  static decltype(::glic::mojom::SafeBrowsingVerdict::threat_type) threat_type(
      const ::glic::mojom::SafeBrowsingVerdictPtr& input) {
    return input->threat_type;
  }

  static decltype(::glic::mojom::SafeBrowsingVerdict::show_interstitial) show_interstitial(
      const ::glic::mojom::SafeBrowsingVerdictPtr& input) {
    return input->show_interstitial;
  }

  static bool Read(::glic::mojom::SafeBrowsingVerdict::DataView input, ::glic::mojom::SafeBrowsingVerdictPtr* output);
};


template <>
struct  StructTraits<::glic::mojom::CounterAbuseVerdict::DataView,
                                         ::glic::mojom::CounterAbuseVerdictPtr> {
  static bool IsNull(const ::glic::mojom::CounterAbuseVerdictPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::CounterAbuseVerdictPtr* output) { output->reset(); }

  static const decltype(::glic::mojom::CounterAbuseVerdict::sb_verdict_result)& sb_verdict_result(
      const ::glic::mojom::CounterAbuseVerdictPtr& input) {
    return input->sb_verdict_result;
  }

  static bool Read(::glic::mojom::CounterAbuseVerdict::DataView input, ::glic::mojom::CounterAbuseVerdictPtr* output);
};


template <>
struct  StructTraits<::glic::mojom::WebClientInitialState::DataView,
                                         ::glic::mojom::WebClientInitialStatePtr> {
  static bool IsNull(const ::glic::mojom::WebClientInitialStatePtr& input) { return !input; }
  static void SetToNull(::glic::mojom::WebClientInitialStatePtr* output) { output->reset(); }

  static const decltype(::glic::mojom::WebClientInitialState::panel_state)& panel_state(
      const ::glic::mojom::WebClientInitialStatePtr& input) {
    return input->panel_state;
  }

  static  decltype(::glic::mojom::WebClientInitialState::focused_tab_data)& focused_tab_data(
       ::glic::mojom::WebClientInitialStatePtr& input) {
    return input->focused_tab_data;
  }

  static decltype(::glic::mojom::WebClientInitialState::microphone_permission_enabled) microphone_permission_enabled(
      const ::glic::mojom::WebClientInitialStatePtr& input) {
    return input->microphone_permission_enabled;
  }

  static decltype(::glic::mojom::WebClientInitialState::location_permission_enabled) location_permission_enabled(
      const ::glic::mojom::WebClientInitialStatePtr& input) {
    return input->location_permission_enabled;
  }

  static decltype(::glic::mojom::WebClientInitialState::tab_context_permission_enabled) tab_context_permission_enabled(
      const ::glic::mojom::WebClientInitialStatePtr& input) {
    return input->tab_context_permission_enabled;
  }

  static decltype(::glic::mojom::WebClientInitialState::os_location_permission_enabled) os_location_permission_enabled(
      const ::glic::mojom::WebClientInitialStatePtr& input) {
    return input->os_location_permission_enabled;
  }

  static decltype(::glic::mojom::WebClientInitialState::zoom_factor) zoom_factor(
      const ::glic::mojom::WebClientInitialStatePtr& input) {
    return input->zoom_factor;
  }

  static const decltype(::glic::mojom::WebClientInitialState::hotkey)& hotkey(
      const ::glic::mojom::WebClientInitialStatePtr& input) {
    return input->hotkey;
  }

  static const decltype(::glic::mojom::WebClientInitialState::chrome_version)& chrome_version(
      const ::glic::mojom::WebClientInitialStatePtr& input) {
    return input->chrome_version;
  }

  static decltype(::glic::mojom::WebClientInitialState::platform) platform(
      const ::glic::mojom::WebClientInitialStatePtr& input) {
    return input->platform;
  }

  static decltype(::glic::mojom::WebClientInitialState::form_factor) form_factor(
      const ::glic::mojom::WebClientInitialStatePtr& input) {
    return input->form_factor;
  }

  static decltype(::glic::mojom::WebClientInitialState::can_attach) can_attach(
      const ::glic::mojom::WebClientInitialStatePtr& input) {
    return input->can_attach;
  }

  static decltype(::glic::mojom::WebClientInitialState::panel_is_active) panel_is_active(
      const ::glic::mojom::WebClientInitialStatePtr& input) {
    return input->panel_is_active;
  }

  static decltype(::glic::mojom::WebClientInitialState::browser_is_open) browser_is_open(
      const ::glic::mojom::WebClientInitialStatePtr& input) {
    return input->browser_is_open;
  }

  static decltype(::glic::mojom::WebClientInitialState::instance_is_active) instance_is_active(
      const ::glic::mojom::WebClientInitialStatePtr& input) {
    return input->instance_is_active;
  }

  static decltype(::glic::mojom::WebClientInitialState::enable_zero_state_suggestions) enable_zero_state_suggestions(
      const ::glic::mojom::WebClientInitialStatePtr& input) {
    return input->enable_zero_state_suggestions;
  }

  static decltype(::glic::mojom::WebClientInitialState::enable_cached_get_user_profile_info) enable_cached_get_user_profile_info(
      const ::glic::mojom::WebClientInitialStatePtr& input) {
    return input->enable_cached_get_user_profile_info;
  }

  static decltype(::glic::mojom::WebClientInitialState::enable_act_in_focused_tab) enable_act_in_focused_tab(
      const ::glic::mojom::WebClientInitialStatePtr& input) {
    return input->enable_act_in_focused_tab;
  }

  static decltype(::glic::mojom::WebClientInitialState::enable_scroll_to) enable_scroll_to(
      const ::glic::mojom::WebClientInitialStatePtr& input) {
    return input->enable_scroll_to;
  }

  static decltype(::glic::mojom::WebClientInitialState::enable_default_tab_context_setting_feature) enable_default_tab_context_setting_feature(
      const ::glic::mojom::WebClientInitialStatePtr& input) {
    return input->enable_default_tab_context_setting_feature;
  }

  static decltype(::glic::mojom::WebClientInitialState::default_tab_context_setting_enabled) default_tab_context_setting_enabled(
      const ::glic::mojom::WebClientInitialStatePtr& input) {
    return input->default_tab_context_setting_enabled;
  }

  static decltype(::glic::mojom::WebClientInitialState::closed_captioning_setting_enabled) closed_captioning_setting_enabled(
      const ::glic::mojom::WebClientInitialStatePtr& input) {
    return input->closed_captioning_setting_enabled;
  }

  static decltype(::glic::mojom::WebClientInitialState::enable_maybe_refresh_user_status) enable_maybe_refresh_user_status(
      const ::glic::mojom::WebClientInitialStatePtr& input) {
    return input->enable_maybe_refresh_user_status;
  }

  static decltype(::glic::mojom::WebClientInitialState::enable_multi_tab) enable_multi_tab(
      const ::glic::mojom::WebClientInitialStatePtr& input) {
    return input->enable_multi_tab;
  }

  static decltype(::glic::mojom::WebClientInitialState::enable_get_context_actor) enable_get_context_actor(
      const ::glic::mojom::WebClientInitialStatePtr& input) {
    return input->enable_get_context_actor;
  }

  static const decltype(::glic::mojom::WebClientInitialState::host_capabilities)& host_capabilities(
      const ::glic::mojom::WebClientInitialStatePtr& input) {
    return input->host_capabilities;
  }

  static decltype(::glic::mojom::WebClientInitialState::enable_get_page_metadata) enable_get_page_metadata(
      const ::glic::mojom::WebClientInitialStatePtr& input) {
    return input->enable_get_page_metadata;
  }

  static decltype(::glic::mojom::WebClientInitialState::enable_capture_region) enable_capture_region(
      const ::glic::mojom::WebClientInitialStatePtr& input) {
    return input->enable_capture_region;
  }

  static decltype(::glic::mojom::WebClientInitialState::enable_web_actuation_setting_feature) enable_web_actuation_setting_feature(
      const ::glic::mojom::WebClientInitialStatePtr& input) {
    return input->enable_web_actuation_setting_feature;
  }

  static decltype(::glic::mojom::WebClientInitialState::actuation_on_web_setting_enabled) actuation_on_web_setting_enabled(
      const ::glic::mojom::WebClientInitialStatePtr& input) {
    return input->actuation_on_web_setting_enabled;
  }

  static decltype(::glic::mojom::WebClientInitialState::can_act_on_web) can_act_on_web(
      const ::glic::mojom::WebClientInitialStatePtr& input) {
    return input->can_act_on_web;
  }

  static decltype(::glic::mojom::WebClientInitialState::enable_activate_tab) enable_activate_tab(
      const ::glic::mojom::WebClientInitialStatePtr& input) {
    return input->enable_activate_tab;
  }

  static decltype(::glic::mojom::WebClientInitialState::enable_get_tab_by_id) enable_get_tab_by_id(
      const ::glic::mojom::WebClientInitialStatePtr& input) {
    return input->enable_get_tab_by_id;
  }

  static decltype(::glic::mojom::WebClientInitialState::enable_open_password_manager_settings_page) enable_open_password_manager_settings_page(
      const ::glic::mojom::WebClientInitialStatePtr& input) {
    return input->enable_open_password_manager_settings_page;
  }

  static decltype(::glic::mojom::WebClientInitialState::enable_trust_first_onboarding) enable_trust_first_onboarding(
      const ::glic::mojom::WebClientInitialStatePtr& input) {
    return input->enable_trust_first_onboarding;
  }

  static decltype(::glic::mojom::WebClientInitialState::onboarding_completed) onboarding_completed(
      const ::glic::mojom::WebClientInitialStatePtr& input) {
    return input->onboarding_completed;
  }

  static decltype(::glic::mojom::WebClientInitialState::enable_skills) enable_skills(
      const ::glic::mojom::WebClientInitialStatePtr& input) {
    return input->enable_skills;
  }

  static decltype(::glic::mojom::WebClientInitialState::enable_get_tab_favicon_by_id) enable_get_tab_favicon_by_id(
      const ::glic::mojom::WebClientInitialStatePtr& input) {
    return input->enable_get_tab_favicon_by_id;
  }

  static decltype(::glic::mojom::WebClientInitialState::enable_process_counter_abuse_verdict) enable_process_counter_abuse_verdict(
      const ::glic::mojom::WebClientInitialStatePtr& input) {
    return input->enable_process_counter_abuse_verdict;
  }

  static const decltype(::glic::mojom::WebClientInitialState::gemini_enterprise_settings)& gemini_enterprise_settings(
      const ::glic::mojom::WebClientInitialStatePtr& input) {
    return input->gemini_enterprise_settings;
  }

  static decltype(::glic::mojom::WebClientInitialState::enable_gmail_otp_opt_in) enable_gmail_otp_opt_in(
      const ::glic::mojom::WebClientInitialStatePtr& input) {
    return input->enable_gmail_otp_opt_in;
  }

  static decltype(::glic::mojom::WebClientInitialState::enable_gmail_otp_confirmation) enable_gmail_otp_confirmation(
      const ::glic::mojom::WebClientInitialStatePtr& input) {
    return input->enable_gmail_otp_confirmation;
  }

  static decltype(::glic::mojom::WebClientInitialState::file_upload_policy_state) file_upload_policy_state(
      const ::glic::mojom::WebClientInitialStatePtr& input) {
    return input->file_upload_policy_state;
  }

  static bool Read(::glic::mojom::WebClientInitialState::DataView input, ::glic::mojom::WebClientInitialStatePtr* output);
};


template <>
struct  StructTraits<::glic::mojom::ScreenshotCollectionOptions::DataView,
                                         ::glic::mojom::ScreenshotCollectionOptionsPtr> {
  static bool IsNull(const ::glic::mojom::ScreenshotCollectionOptionsPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::ScreenshotCollectionOptionsPtr* output) { output->reset(); }

  static decltype(::glic::mojom::ScreenshotCollectionOptions::max_width) max_width(
      const ::glic::mojom::ScreenshotCollectionOptionsPtr& input) {
    return input->max_width;
  }

  static decltype(::glic::mojom::ScreenshotCollectionOptions::max_height) max_height(
      const ::glic::mojom::ScreenshotCollectionOptionsPtr& input) {
    return input->max_height;
  }

  static decltype(::glic::mojom::ScreenshotCollectionOptions::screenshot_image_format) screenshot_image_format(
      const ::glic::mojom::ScreenshotCollectionOptionsPtr& input) {
    return input->screenshot_image_format;
  }

  static decltype(::glic::mojom::ScreenshotCollectionOptions::screenshot_compression_quality) screenshot_compression_quality(
      const ::glic::mojom::ScreenshotCollectionOptionsPtr& input) {
    return input->screenshot_compression_quality;
  }

  static bool Read(::glic::mojom::ScreenshotCollectionOptions::DataView input, ::glic::mojom::ScreenshotCollectionOptionsPtr* output);
};


template <>
struct  StructTraits<::glic::mojom::TabContextOptions::DataView,
                                         ::glic::mojom::TabContextOptionsPtr> {
  static bool IsNull(const ::glic::mojom::TabContextOptionsPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::TabContextOptionsPtr* output) { output->reset(); }

  static decltype(::glic::mojom::TabContextOptions::inner_text) inner_text(
      const ::glic::mojom::TabContextOptionsPtr& input) {
    return input->inner_text;
  }

  static decltype(::glic::mojom::TabContextOptions::inner_text_bytes_limit) inner_text_bytes_limit(
      const ::glic::mojom::TabContextOptionsPtr& input) {
    return input->inner_text_bytes_limit;
  }

  static decltype(::glic::mojom::TabContextOptions::viewport_screenshot) viewport_screenshot(
      const ::glic::mojom::TabContextOptionsPtr& input) {
    return input->viewport_screenshot;
  }

  static decltype(::glic::mojom::TabContextOptions::annotated_page_content) annotated_page_content(
      const ::glic::mojom::TabContextOptionsPtr& input) {
    return input->annotated_page_content;
  }

  static decltype(::glic::mojom::TabContextOptions::max_meta_tags) max_meta_tags(
      const ::glic::mojom::TabContextOptionsPtr& input) {
    return input->max_meta_tags;
  }

  static decltype(::glic::mojom::TabContextOptions::pdf_data) pdf_data(
      const ::glic::mojom::TabContextOptionsPtr& input) {
    return input->pdf_data;
  }

  static decltype(::glic::mojom::TabContextOptions::pdf_size_limit) pdf_size_limit(
      const ::glic::mojom::TabContextOptionsPtr& input) {
    return input->pdf_size_limit;
  }

  static decltype(::glic::mojom::TabContextOptions::annotated_page_content_mode) annotated_page_content_mode(
      const ::glic::mojom::TabContextOptionsPtr& input) {
    return input->annotated_page_content_mode;
  }

  static const decltype(::glic::mojom::TabContextOptions::screenshot_collection_options)& screenshot_collection_options(
      const ::glic::mojom::TabContextOptionsPtr& input) {
    return input->screenshot_collection_options;
  }

  static bool Read(::glic::mojom::TabContextOptions::DataView input, ::glic::mojom::TabContextOptionsPtr* output);
};


template <>
struct  StructTraits<::glic::mojom::GetPinCandidatesOptions::DataView,
                                         ::glic::mojom::GetPinCandidatesOptionsPtr> {
  static bool IsNull(const ::glic::mojom::GetPinCandidatesOptionsPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::GetPinCandidatesOptionsPtr* output) { output->reset(); }

  static decltype(::glic::mojom::GetPinCandidatesOptions::max_candidates) max_candidates(
      const ::glic::mojom::GetPinCandidatesOptionsPtr& input) {
    return input->max_candidates;
  }

  static const decltype(::glic::mojom::GetPinCandidatesOptions::query)& query(
      const ::glic::mojom::GetPinCandidatesOptionsPtr& input) {
    return input->query;
  }

  static bool Read(::glic::mojom::GetPinCandidatesOptions::DataView input, ::glic::mojom::GetPinCandidatesOptionsPtr* output);
};


template <>
struct  StructTraits<::glic::mojom::ScrollToParams::DataView,
                                         ::glic::mojom::ScrollToParamsPtr> {
  static bool IsNull(const ::glic::mojom::ScrollToParamsPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::ScrollToParamsPtr* output) { output->reset(); }

  static const decltype(::glic::mojom::ScrollToParams::selector)& selector(
      const ::glic::mojom::ScrollToParamsPtr& input) {
    return input->selector;
  }

  static decltype(::glic::mojom::ScrollToParams::highlight) highlight(
      const ::glic::mojom::ScrollToParamsPtr& input) {
    return input->highlight;
  }

  static const decltype(::glic::mojom::ScrollToParams::document_id)& document_id(
      const ::glic::mojom::ScrollToParamsPtr& input) {
    return input->document_id;
  }

  static const decltype(::glic::mojom::ScrollToParams::url)& url(
      const ::glic::mojom::ScrollToParamsPtr& input) {
    return input->url;
  }

  static bool Read(::glic::mojom::ScrollToParams::DataView input, ::glic::mojom::ScrollToParamsPtr* output);
};


template <>
struct  StructTraits<::glic::mojom::ScrollToTextSelector::DataView,
                                         ::glic::mojom::ScrollToTextSelectorPtr> {
  static bool IsNull(const ::glic::mojom::ScrollToTextSelectorPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::ScrollToTextSelectorPtr* output) { output->reset(); }

  static const decltype(::glic::mojom::ScrollToTextSelector::text)& text(
      const ::glic::mojom::ScrollToTextSelectorPtr& input) {
    return input->text;
  }

  static decltype(::glic::mojom::ScrollToTextSelector::search_range_start_node_id) search_range_start_node_id(
      const ::glic::mojom::ScrollToTextSelectorPtr& input) {
    return input->search_range_start_node_id;
  }

  static bool Read(::glic::mojom::ScrollToTextSelector::DataView input, ::glic::mojom::ScrollToTextSelectorPtr* output);
};


template <>
struct  StructTraits<::glic::mojom::ScrollToTextFragmentSelector::DataView,
                                         ::glic::mojom::ScrollToTextFragmentSelectorPtr> {
  static bool IsNull(const ::glic::mojom::ScrollToTextFragmentSelectorPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::ScrollToTextFragmentSelectorPtr* output) { output->reset(); }

  static const decltype(::glic::mojom::ScrollToTextFragmentSelector::text_start)& text_start(
      const ::glic::mojom::ScrollToTextFragmentSelectorPtr& input) {
    return input->text_start;
  }

  static const decltype(::glic::mojom::ScrollToTextFragmentSelector::text_end)& text_end(
      const ::glic::mojom::ScrollToTextFragmentSelectorPtr& input) {
    return input->text_end;
  }

  static decltype(::glic::mojom::ScrollToTextFragmentSelector::search_range_start_node_id) search_range_start_node_id(
      const ::glic::mojom::ScrollToTextFragmentSelectorPtr& input) {
    return input->search_range_start_node_id;
  }

  static bool Read(::glic::mojom::ScrollToTextFragmentSelector::DataView input, ::glic::mojom::ScrollToTextFragmentSelectorPtr* output);
};


template <>
struct  StructTraits<::glic::mojom::ScrollToNodeSelector::DataView,
                                         ::glic::mojom::ScrollToNodeSelectorPtr> {
  static bool IsNull(const ::glic::mojom::ScrollToNodeSelectorPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::ScrollToNodeSelectorPtr* output) { output->reset(); }

  static decltype(::glic::mojom::ScrollToNodeSelector::node_id) node_id(
      const ::glic::mojom::ScrollToNodeSelectorPtr& input) {
    return input->node_id;
  }

  static bool Read(::glic::mojom::ScrollToNodeSelector::DataView input, ::glic::mojom::ScrollToNodeSelectorPtr* output);
};


template <>
struct  StructTraits<::glic::mojom::SuggestionContent::DataView,
                                         ::glic::mojom::SuggestionContentPtr> {
  static bool IsNull(const ::glic::mojom::SuggestionContentPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::SuggestionContentPtr* output) { output->reset(); }

  static const decltype(::glic::mojom::SuggestionContent::suggestion)& suggestion(
      const ::glic::mojom::SuggestionContentPtr& input) {
    return input->suggestion;
  }

  static bool Read(::glic::mojom::SuggestionContent::DataView input, ::glic::mojom::SuggestionContentPtr* output);
};


template <>
struct  StructTraits<::glic::mojom::SkillPreview::DataView,
                                         ::glic::mojom::SkillPreviewPtr> {
  static bool IsNull(const ::glic::mojom::SkillPreviewPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::SkillPreviewPtr* output) { output->reset(); }

  static const decltype(::glic::mojom::SkillPreview::id)& id(
      const ::glic::mojom::SkillPreviewPtr& input) {
    return input->id;
  }

  static const decltype(::glic::mojom::SkillPreview::name)& name(
      const ::glic::mojom::SkillPreviewPtr& input) {
    return input->name;
  }

  static const decltype(::glic::mojom::SkillPreview::icon)& icon(
      const ::glic::mojom::SkillPreviewPtr& input) {
    return input->icon;
  }

  static decltype(::glic::mojom::SkillPreview::source) source(
      const ::glic::mojom::SkillPreviewPtr& input) {
    return input->source;
  }

  static const decltype(::glic::mojom::SkillPreview::description)& description(
      const ::glic::mojom::SkillPreviewPtr& input) {
    return input->description;
  }

  static const decltype(::glic::mojom::SkillPreview::curated_by)& curated_by(
      const ::glic::mojom::SkillPreviewPtr& input) {
    return input->curated_by;
  }

  static const decltype(::glic::mojom::SkillPreview::image_url)& image_url(
      const ::glic::mojom::SkillPreviewPtr& input) {
    return input->image_url;
  }

  static const decltype(::glic::mojom::SkillPreview::category)& category(
      const ::glic::mojom::SkillPreviewPtr& input) {
    return input->category;
  }

  static const decltype(::glic::mojom::SkillPreview::creation_time)& creation_time(
      const ::glic::mojom::SkillPreviewPtr& input) {
    return input->creation_time;
  }

  static bool Read(::glic::mojom::SkillPreview::DataView input, ::glic::mojom::SkillPreviewPtr* output);
};


template <>
struct  StructTraits<::glic::mojom::Skill::DataView,
                                         ::glic::mojom::SkillPtr> {
  static bool IsNull(const ::glic::mojom::SkillPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::SkillPtr* output) { output->reset(); }

  static const decltype(::glic::mojom::Skill::preview)& preview(
      const ::glic::mojom::SkillPtr& input) {
    return input->preview;
  }

  static const decltype(::glic::mojom::Skill::prompt)& prompt(
      const ::glic::mojom::SkillPtr& input) {
    return input->prompt;
  }

  static const decltype(::glic::mojom::Skill::source_skill_id)& source_skill_id(
      const ::glic::mojom::SkillPtr& input) {
    return input->source_skill_id;
  }

  static bool Read(::glic::mojom::Skill::DataView input, ::glic::mojom::SkillPtr* output);
};


template <>
struct  StructTraits<::glic::mojom::CreateSkillRequest::DataView,
                                         ::glic::mojom::CreateSkillRequestPtr> {
  static bool IsNull(const ::glic::mojom::CreateSkillRequestPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::CreateSkillRequestPtr* output) { output->reset(); }

  static const decltype(::glic::mojom::CreateSkillRequest::id)& id(
      const ::glic::mojom::CreateSkillRequestPtr& input) {
    return input->id;
  }

  static const decltype(::glic::mojom::CreateSkillRequest::name)& name(
      const ::glic::mojom::CreateSkillRequestPtr& input) {
    return input->name;
  }

  static const decltype(::glic::mojom::CreateSkillRequest::icon)& icon(
      const ::glic::mojom::CreateSkillRequestPtr& input) {
    return input->icon;
  }

  static decltype(::glic::mojom::CreateSkillRequest::source) source(
      const ::glic::mojom::CreateSkillRequestPtr& input) {
    return input->source;
  }

  static const decltype(::glic::mojom::CreateSkillRequest::prompt)& prompt(
      const ::glic::mojom::CreateSkillRequestPtr& input) {
    return input->prompt;
  }

  static const decltype(::glic::mojom::CreateSkillRequest::description)& description(
      const ::glic::mojom::CreateSkillRequestPtr& input) {
    return input->description;
  }

  static bool Read(::glic::mojom::CreateSkillRequest::DataView input, ::glic::mojom::CreateSkillRequestPtr* output);
};


template <>
struct  StructTraits<::glic::mojom::UpdateSkillRequest::DataView,
                                         ::glic::mojom::UpdateSkillRequestPtr> {
  static bool IsNull(const ::glic::mojom::UpdateSkillRequestPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::UpdateSkillRequestPtr* output) { output->reset(); }

  static const decltype(::glic::mojom::UpdateSkillRequest::id)& id(
      const ::glic::mojom::UpdateSkillRequestPtr& input) {
    return input->id;
  }

  static bool Read(::glic::mojom::UpdateSkillRequest::DataView input, ::glic::mojom::UpdateSkillRequestPtr* output);
};


template <>
struct  StructTraits<::glic::mojom::ZeroStateSuggestions::DataView,
                                         ::glic::mojom::ZeroStateSuggestionsPtr> {
  static bool IsNull(const ::glic::mojom::ZeroStateSuggestionsPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::ZeroStateSuggestionsPtr* output) { output->reset(); }

  static const decltype(::glic::mojom::ZeroStateSuggestions::suggestions)& suggestions(
      const ::glic::mojom::ZeroStateSuggestionsPtr& input) {
    return input->suggestions;
  }

  static decltype(::glic::mojom::ZeroStateSuggestions::tab_id) tab_id(
      const ::glic::mojom::ZeroStateSuggestionsPtr& input) {
    return input->tab_id;
  }

  static const decltype(::glic::mojom::ZeroStateSuggestions::url)& url(
      const ::glic::mojom::ZeroStateSuggestionsPtr& input) {
    return input->url;
  }

  static bool Read(::glic::mojom::ZeroStateSuggestions::DataView input, ::glic::mojom::ZeroStateSuggestionsPtr* output);
};


template <>
struct  StructTraits<::glic::mojom::ZeroStateSuggestionsV2::DataView,
                                         ::glic::mojom::ZeroStateSuggestionsV2Ptr> {
  static bool IsNull(const ::glic::mojom::ZeroStateSuggestionsV2Ptr& input) { return !input; }
  static void SetToNull(::glic::mojom::ZeroStateSuggestionsV2Ptr* output) { output->reset(); }

  static const decltype(::glic::mojom::ZeroStateSuggestionsV2::suggestions)& suggestions(
      const ::glic::mojom::ZeroStateSuggestionsV2Ptr& input) {
    return input->suggestions;
  }

  static decltype(::glic::mojom::ZeroStateSuggestionsV2::is_pending) is_pending(
      const ::glic::mojom::ZeroStateSuggestionsV2Ptr& input) {
    return input->is_pending;
  }

  static decltype(::glic::mojom::ZeroStateSuggestionsV2::invocation_source) invocation_source(
      const ::glic::mojom::ZeroStateSuggestionsV2Ptr& input) {
    return input->invocation_source;
  }

  static bool Read(::glic::mojom::ZeroStateSuggestionsV2::DataView input, ::glic::mojom::ZeroStateSuggestionsV2Ptr* output);
};


template <>
struct  StructTraits<::glic::mojom::ZeroStateSuggestionsOptions::DataView,
                                         ::glic::mojom::ZeroStateSuggestionsOptionsPtr> {
  static bool IsNull(const ::glic::mojom::ZeroStateSuggestionsOptionsPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::ZeroStateSuggestionsOptionsPtr* output) { output->reset(); }

  static decltype(::glic::mojom::ZeroStateSuggestionsOptions::is_first_run) is_first_run(
      const ::glic::mojom::ZeroStateSuggestionsOptionsPtr& input) {
    return input->is_first_run;
  }

  static const decltype(::glic::mojom::ZeroStateSuggestionsOptions::supported_tools)& supported_tools(
      const ::glic::mojom::ZeroStateSuggestionsOptionsPtr& input) {
    return input->supported_tools;
  }

  static bool Read(::glic::mojom::ZeroStateSuggestionsOptions::DataView input, ::glic::mojom::ZeroStateSuggestionsOptionsPtr* output);
};


template <>
struct  StructTraits<::glic::mojom::PinCandidate::DataView,
                                         ::glic::mojom::PinCandidatePtr> {
  static bool IsNull(const ::glic::mojom::PinCandidatePtr& input) { return !input; }
  static void SetToNull(::glic::mojom::PinCandidatePtr* output) { output->reset(); }

  static  decltype(::glic::mojom::PinCandidate::tab_data)& tab_data(
       ::glic::mojom::PinCandidatePtr& input) {
    return input->tab_data;
  }

  static bool Read(::glic::mojom::PinCandidate::DataView input, ::glic::mojom::PinCandidatePtr* output);
};


template <>
struct  StructTraits<::glic::mojom::PinTabsOptions::DataView,
                                         ::glic::mojom::PinTabsOptionsPtr> {
  static bool IsNull(const ::glic::mojom::PinTabsOptionsPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::PinTabsOptionsPtr* output) { output->reset(); }

  static decltype(::glic::mojom::PinTabsOptions::pin_trigger) pin_trigger(
      const ::glic::mojom::PinTabsOptionsPtr& input) {
    return input->pin_trigger;
  }

  static bool Read(::glic::mojom::PinTabsOptions::DataView input, ::glic::mojom::PinTabsOptionsPtr* output);
};


template <>
struct  StructTraits<::glic::mojom::UnpinTabsOptions::DataView,
                                         ::glic::mojom::UnpinTabsOptionsPtr> {
  static bool IsNull(const ::glic::mojom::UnpinTabsOptionsPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::UnpinTabsOptionsPtr* output) { output->reset(); }

  static decltype(::glic::mojom::UnpinTabsOptions::unpin_trigger) unpin_trigger(
      const ::glic::mojom::UnpinTabsOptionsPtr& input) {
    return input->unpin_trigger;
  }

  static bool Read(::glic::mojom::UnpinTabsOptions::DataView input, ::glic::mojom::UnpinTabsOptionsPtr* output);
};


template <>
struct  StructTraits<::glic::mojom::OpenPinnedTabPickerOptions::DataView,
                                         ::glic::mojom::OpenPinnedTabPickerOptionsPtr> {
  static bool IsNull(const ::glic::mojom::OpenPinnedTabPickerOptionsPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::OpenPinnedTabPickerOptionsPtr* output) { output->reset(); }

  static bool Read(::glic::mojom::OpenPinnedTabPickerOptions::DataView input, ::glic::mojom::OpenPinnedTabPickerOptionsPtr* output);
};


template <>
struct  StructTraits<::glic::mojom::CreateActorTabOptions::DataView,
                                         ::glic::mojom::CreateActorTabOptionsPtr> {
  static bool IsNull(const ::glic::mojom::CreateActorTabOptionsPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::CreateActorTabOptionsPtr* output) { output->reset(); }

  static decltype(::glic::mojom::CreateActorTabOptions::initiator_tab_id) initiator_tab_id(
      const ::glic::mojom::CreateActorTabOptionsPtr& input) {
    return input->initiator_tab_id;
  }

  static decltype(::glic::mojom::CreateActorTabOptions::initiator_window_id) initiator_window_id(
      const ::glic::mojom::CreateActorTabOptionsPtr& input) {
    return input->initiator_window_id;
  }

  static decltype(::glic::mojom::CreateActorTabOptions::open_in_background) open_in_background(
      const ::glic::mojom::CreateActorTabOptionsPtr& input) {
    return input->open_in_background;
  }

  static bool Read(::glic::mojom::CreateActorTabOptions::DataView input, ::glic::mojom::CreateActorTabOptionsPtr* output);
};


template <>
struct  StructTraits<::glic::mojom::CaptureRegionParams::DataView,
                                         ::glic::mojom::CaptureRegionParamsPtr> {
  static bool IsNull(const ::glic::mojom::CaptureRegionParamsPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::CaptureRegionParamsPtr* output) { output->reset(); }

  static decltype(::glic::mojom::CaptureRegionParams::tab_id) tab_id(
      const ::glic::mojom::CaptureRegionParamsPtr& input) {
    return input->tab_id;
  }

  static const decltype(::glic::mojom::CaptureRegionParams::options)& options(
      const ::glic::mojom::CaptureRegionParamsPtr& input) {
    return input->options;
  }

  static bool Read(::glic::mojom::CaptureRegionParams::DataView input, ::glic::mojom::CaptureRegionParamsPtr* output);
};


template <>
struct  StructTraits<::glic::mojom::ActivateTabOptions::DataView,
                                         ::glic::mojom::ActivateTabOptionsPtr> {
  static bool IsNull(const ::glic::mojom::ActivateTabOptionsPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::ActivateTabOptionsPtr* output) { output->reset(); }

  static const decltype(::glic::mojom::ActivateTabOptions::pattern)& pattern(
      const ::glic::mojom::ActivateTabOptionsPtr& input) {
    return input->pattern;
  }

  static decltype(::glic::mojom::ActivateTabOptions::fallback_window_id) fallback_window_id(
      const ::glic::mojom::ActivateTabOptionsPtr& input) {
    return input->fallback_window_id;
  }

  static bool Read(::glic::mojom::ActivateTabOptions::DataView input, ::glic::mojom::ActivateTabOptionsPtr* output);
};


template <>
struct  StructTraits<::glic::mojom::CreateTabOptions::DataView,
                                         ::glic::mojom::CreateTabOptionsPtr> {
  static bool IsNull(const ::glic::mojom::CreateTabOptionsPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::CreateTabOptionsPtr* output) { output->reset(); }

  static decltype(::glic::mojom::CreateTabOptions::open_in_background) open_in_background(
      const ::glic::mojom::CreateTabOptionsPtr& input) {
    return input->open_in_background;
  }

  static decltype(::glic::mojom::CreateTabOptions::window_id) window_id(
      const ::glic::mojom::CreateTabOptionsPtr& input) {
    return input->window_id;
  }

  static bool Read(::glic::mojom::CreateTabOptions::DataView input, ::glic::mojom::CreateTabOptionsPtr* output);
};


template <>
struct  StructTraits<::glic::mojom::ConversationInfo::DataView,
                                         ::glic::mojom::ConversationInfoPtr> {
  static bool IsNull(const ::glic::mojom::ConversationInfoPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::ConversationInfoPtr* output) { output->reset(); }

  static const decltype(::glic::mojom::ConversationInfo::conversation_id)& conversation_id(
      const ::glic::mojom::ConversationInfoPtr& input) {
    return input->conversation_id;
  }

  static const decltype(::glic::mojom::ConversationInfo::conversation_title)& conversation_title(
      const ::glic::mojom::ConversationInfoPtr& input) {
    return input->conversation_title;
  }

  static const decltype(::glic::mojom::ConversationInfo::client_data)& client_data(
      const ::glic::mojom::ConversationInfoPtr& input) {
    return input->client_data;
  }

  static const decltype(::glic::mojom::ConversationInfo::turn_id)& turn_id(
      const ::glic::mojom::ConversationInfoPtr& input) {
    return input->turn_id;
  }

  static bool Read(::glic::mojom::ConversationInfo::DataView input, ::glic::mojom::ConversationInfoPtr* output);
};


template <>
struct  StructTraits<::glic::mojom::PanelOpeningData::DataView,
                                         ::glic::mojom::PanelOpeningDataPtr> {
  static bool IsNull(const ::glic::mojom::PanelOpeningDataPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::PanelOpeningDataPtr* output) { output->reset(); }

  static const decltype(::glic::mojom::PanelOpeningData::panel_state)& panel_state(
      const ::glic::mojom::PanelOpeningDataPtr& input) {
    return input->panel_state;
  }

  static decltype(::glic::mojom::PanelOpeningData::invocation_source) invocation_source(
      const ::glic::mojom::PanelOpeningDataPtr& input) {
    return input->invocation_source;
  }

  static const decltype(::glic::mojom::PanelOpeningData::prompt_suggestion)& prompt_suggestion(
      const ::glic::mojom::PanelOpeningDataPtr& input) {
    return input->prompt_suggestion;
  }

  static decltype(::glic::mojom::PanelOpeningData::auto_send) auto_send(
      const ::glic::mojom::PanelOpeningDataPtr& input) {
    return input->auto_send;
  }

  static const decltype(::glic::mojom::PanelOpeningData::skill_to_invoke)& skill_to_invoke(
      const ::glic::mojom::PanelOpeningDataPtr& input) {
    return input->skill_to_invoke;
  }

  static const decltype(::glic::mojom::PanelOpeningData::recently_active_conversations)& recently_active_conversations(
      const ::glic::mojom::PanelOpeningDataPtr& input) {
    return input->recently_active_conversations;
  }

  static const decltype(::glic::mojom::PanelOpeningData::conversation_info)& conversation_info(
      const ::glic::mojom::PanelOpeningDataPtr& input) {
    return input->conversation_info;
  }

  static decltype(::glic::mojom::PanelOpeningData::fre_override) fre_override(
      const ::glic::mojom::PanelOpeningDataPtr& input) {
    return input->fre_override;
  }

  static bool Read(::glic::mojom::PanelOpeningData::DataView input, ::glic::mojom::PanelOpeningDataPtr* output);
};


template <>
struct  StructTraits<::glic::mojom::PanelState::DataView,
                                         ::glic::mojom::PanelStatePtr> {
  static bool IsNull(const ::glic::mojom::PanelStatePtr& input) { return !input; }
  static void SetToNull(::glic::mojom::PanelStatePtr* output) { output->reset(); }

  static decltype(::glic::mojom::PanelState::kind) kind(
      const ::glic::mojom::PanelStatePtr& input) {
    return input->kind;
  }

  static decltype(::glic::mojom::PanelState::window_id) window_id(
      const ::glic::mojom::PanelStatePtr& input) {
    return input->window_id;
  }

  static bool Read(::glic::mojom::PanelState::DataView input, ::glic::mojom::PanelStatePtr* output);
};


template <>
struct  StructTraits<::glic::mojom::SkillsPayload::DataView,
                                         ::glic::mojom::SkillsPayloadPtr> {
  static bool IsNull(const ::glic::mojom::SkillsPayloadPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::SkillsPayloadPtr* output) { output->reset(); }

  static const decltype(::glic::mojom::SkillsPayload::skill_id)& skill_id(
      const ::glic::mojom::SkillsPayloadPtr& input) {
    return input->skill_id;
  }

  static const decltype(::glic::mojom::SkillsPayload::skill_name)& skill_name(
      const ::glic::mojom::SkillsPayloadPtr& input) {
    return input->skill_name;
  }

  static const decltype(::glic::mojom::SkillsPayload::skill_icon)& skill_icon(
      const ::glic::mojom::SkillsPayloadPtr& input) {
    return input->skill_icon;
  }

  static bool Read(::glic::mojom::SkillsPayload::DataView input, ::glic::mojom::SkillsPayloadPtr* output);
};


template <>
struct  StructTraits<::glic::mojom::UniversalCartPayload::DataView,
                                         ::glic::mojom::UniversalCartPayloadPtr> {
  static bool IsNull(const ::glic::mojom::UniversalCartPayloadPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::UniversalCartPayloadPtr* output) { output->reset(); }

  static const decltype(::glic::mojom::UniversalCartPayload::serialized_metadata)& serialized_metadata(
      const ::glic::mojom::UniversalCartPayloadPtr& input) {
    return input->serialized_metadata;
  }

  static bool Read(::glic::mojom::UniversalCartPayload::DataView input, ::glic::mojom::UniversalCartPayloadPtr* output);
};


template <>
struct  StructTraits<::glic::mojom::InvokeOptions::DataView,
                                         ::glic::mojom::InvokeOptionsPtr> {
  static bool IsNull(const ::glic::mojom::InvokeOptionsPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::InvokeOptionsPtr* output) { output->reset(); }

  static decltype(::glic::mojom::InvokeOptions::invocation_source) invocation_source(
      const ::glic::mojom::InvokeOptionsPtr& input) {
    return input->invocation_source;
  }

  static const decltype(::glic::mojom::InvokeOptions::prompts)& prompts(
      const ::glic::mojom::InvokeOptionsPtr& input) {
    return input->prompts;
  }

  static  decltype(::glic::mojom::InvokeOptions::context)& context(
       ::glic::mojom::InvokeOptionsPtr& input) {
    return input->context;
  }

  static decltype(::glic::mojom::InvokeOptions::auto_submit) auto_submit(
      const ::glic::mojom::InvokeOptionsPtr& input) {
    return input->auto_submit;
  }

  static decltype(::glic::mojom::InvokeOptions::feature_mode) feature_mode(
      const ::glic::mojom::InvokeOptionsPtr& input) {
    return input->feature_mode;
  }

  static decltype(::glic::mojom::InvokeOptions::actuation_target) actuation_target(
      const ::glic::mojom::InvokeOptionsPtr& input) {
    return input->actuation_target;
  }

  static decltype(::glic::mojom::InvokeOptions::disable_zero_state_suggestions) disable_zero_state_suggestions(
      const ::glic::mojom::InvokeOptionsPtr& input) {
    return input->disable_zero_state_suggestions;
  }

  static const decltype(::glic::mojom::InvokeOptions::skill_id)& skill_id(
      const ::glic::mojom::InvokeOptionsPtr& input) {
    return input->skill_id;
  }

  static const decltype(::glic::mojom::InvokeOptions::zss_config)& zss_config(
      const ::glic::mojom::InvokeOptionsPtr& input) {
    return input->zss_config;
  }

  static const decltype(::glic::mojom::InvokeOptions::payload)& payload(
      const ::glic::mojom::InvokeOptionsPtr& input) {
    return input->payload;
  }

  static decltype(::glic::mojom::InvokeOptions::actuation_tab_id) actuation_tab_id(
      const ::glic::mojom::InvokeOptionsPtr& input) {
    return input->actuation_tab_id;
  }

  static bool Read(::glic::mojom::InvokeOptions::DataView input, ::glic::mojom::InvokeOptionsPtr* output);
};


template <>
struct  StructTraits<::glic::mojom::OnResponseStoppedDetails::DataView,
                                         ::glic::mojom::OnResponseStoppedDetailsPtr> {
  static bool IsNull(const ::glic::mojom::OnResponseStoppedDetailsPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::OnResponseStoppedDetailsPtr* output) { output->reset(); }

  static decltype(::glic::mojom::OnResponseStoppedDetails::cause) cause(
      const ::glic::mojom::OnResponseStoppedDetailsPtr& input) {
    return input->cause;
  }

  static bool Read(::glic::mojom::OnResponseStoppedDetails::DataView input, ::glic::mojom::OnResponseStoppedDetailsPtr* output);
};


template <>
struct  StructTraits<::glic::mojom::OpenPanelInfo::DataView,
                                         ::glic::mojom::OpenPanelInfoPtr> {
  static bool IsNull(const ::glic::mojom::OpenPanelInfoPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::OpenPanelInfoPtr* output) { output->reset(); }

  static decltype(::glic::mojom::OpenPanelInfo::web_client_mode) web_client_mode(
      const ::glic::mojom::OpenPanelInfoPtr& input) {
    return input->web_client_mode;
  }

  static const decltype(::glic::mojom::OpenPanelInfo::panelSize)& panelSize(
      const ::glic::mojom::OpenPanelInfoPtr& input) {
    return input->panelSize;
  }

  static const decltype(::glic::mojom::OpenPanelInfo::resizeDuration)& resizeDuration(
      const ::glic::mojom::OpenPanelInfoPtr& input) {
    return input->resizeDuration;
  }

  static decltype(::glic::mojom::OpenPanelInfo::can_user_resize) can_user_resize(
      const ::glic::mojom::OpenPanelInfoPtr& input) {
    return input->can_user_resize;
  }

  static bool Read(::glic::mojom::OpenPanelInfo::DataView input, ::glic::mojom::OpenPanelInfoPtr* output);
};


template <>
struct  StructTraits<::glic::mojom::ContextData::DataView,
                                         ::glic::mojom::ContextDataPtr> {
  static bool IsNull(const ::glic::mojom::ContextDataPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::ContextDataPtr* output) { output->reset(); }

  static const decltype(::glic::mojom::ContextData::mime_type)& mime_type(
      const ::glic::mojom::ContextDataPtr& input) {
    return input->mime_type;
  }

  static  decltype(::glic::mojom::ContextData::data)& data(
       ::glic::mojom::ContextDataPtr& input) {
    return input->data;
  }

  static const decltype(::glic::mojom::ContextData::filename)& filename(
      const ::glic::mojom::ContextDataPtr& input) {
    return input->filename;
  }

  static bool Read(::glic::mojom::ContextData::DataView input, ::glic::mojom::ContextDataPtr* output);
};


template <>
struct  StructTraits<::glic::mojom::ParentConversationMetadata::DataView,
                                         ::glic::mojom::ParentConversationMetadataPtr> {
  static bool IsNull(const ::glic::mojom::ParentConversationMetadataPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::ParentConversationMetadataPtr* output) { output->reset(); }

  static const decltype(::glic::mojom::ParentConversationMetadata::conversation_id)& conversation_id(
      const ::glic::mojom::ParentConversationMetadataPtr& input) {
    return input->conversation_id;
  }

  static const decltype(::glic::mojom::ParentConversationMetadata::conversation_title)& conversation_title(
      const ::glic::mojom::ParentConversationMetadataPtr& input) {
    return input->conversation_title;
  }

  static bool Read(::glic::mojom::ParentConversationMetadata::DataView input, ::glic::mojom::ParentConversationMetadataPtr* output);
};


template <>
struct  StructTraits<::glic::mojom::AdditionalContext::DataView,
                                         ::glic::mojom::AdditionalContextPtr> {
  static bool IsNull(const ::glic::mojom::AdditionalContextPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::AdditionalContextPtr* output) { output->reset(); }

  static decltype(::glic::mojom::AdditionalContext::source) source(
      const ::glic::mojom::AdditionalContextPtr& input) {
    return input->source;
  }

  static const decltype(::glic::mojom::AdditionalContext::name)& name(
      const ::glic::mojom::AdditionalContextPtr& input) {
    return input->name;
  }

  static decltype(::glic::mojom::AdditionalContext::tab_id) tab_id(
      const ::glic::mojom::AdditionalContextPtr& input) {
    return input->tab_id;
  }

  static const decltype(::glic::mojom::AdditionalContext::origin)& origin(
      const ::glic::mojom::AdditionalContextPtr& input) {
    return input->origin;
  }

  static const decltype(::glic::mojom::AdditionalContext::frameUrl)& frameUrl(
      const ::glic::mojom::AdditionalContextPtr& input) {
    return input->frameUrl;
  }

  static  decltype(::glic::mojom::AdditionalContext::parts)& parts(
       ::glic::mojom::AdditionalContextPtr& input) {
    return input->parts;
  }

  static bool Read(::glic::mojom::AdditionalContext::DataView input, ::glic::mojom::AdditionalContextPtr* output);
};


template <>
struct  StructTraits<::glic::mojom::ExperimentalTriggeringUpdate::DataView,
                                         ::glic::mojom::ExperimentalTriggeringUpdatePtr> {
  static bool IsNull(const ::glic::mojom::ExperimentalTriggeringUpdatePtr& input) { return !input; }
  static void SetToNull(::glic::mojom::ExperimentalTriggeringUpdatePtr* output) { output->reset(); }

  static decltype(::glic::mojom::ExperimentalTriggeringUpdate::type) type(
      const ::glic::mojom::ExperimentalTriggeringUpdatePtr& input) {
    return input->type;
  }

  static const decltype(::glic::mojom::ExperimentalTriggeringUpdate::data)& data(
      const ::glic::mojom::ExperimentalTriggeringUpdatePtr& input) {
    return input->data;
  }

  static const decltype(::glic::mojom::ExperimentalTriggeringUpdate::metadata)& metadata(
      const ::glic::mojom::ExperimentalTriggeringUpdatePtr& input) {
    return input->metadata;
  }

  static bool Read(::glic::mojom::ExperimentalTriggeringUpdate::DataView input, ::glic::mojom::ExperimentalTriggeringUpdatePtr* output);
};


template <>
struct  StructTraits<::glic::mojom::TabContextResult::DataView,
                                         ::glic::mojom::TabContextResultPtr> {
  static bool IsNull(const ::glic::mojom::TabContextResultPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::TabContextResultPtr* output) { output->reset(); }

  static  decltype(::glic::mojom::TabContextResult::tab_data)& tab_data(
       ::glic::mojom::TabContextResultPtr& input) {
    return input->tab_data;
  }

  static const decltype(::glic::mojom::TabContextResult::web_page_data)& web_page_data(
      const ::glic::mojom::TabContextResultPtr& input) {
    return input->web_page_data;
  }

  static const decltype(::glic::mojom::TabContextResult::viewport_screenshot)& viewport_screenshot(
      const ::glic::mojom::TabContextResultPtr& input) {
    return input->viewport_screenshot;
  }

  static  decltype(::glic::mojom::TabContextResult::screenshot_info)& screenshot_info(
       ::glic::mojom::TabContextResultPtr& input) {
    return input->screenshot_info;
  }

  static const decltype(::glic::mojom::TabContextResult::pdf_document_data)& pdf_document_data(
      const ::glic::mojom::TabContextResultPtr& input) {
    return input->pdf_document_data;
  }

  static  decltype(::glic::mojom::TabContextResult::annotated_page_data)& annotated_page_data(
       ::glic::mojom::TabContextResultPtr& input) {
    return input->annotated_page_data;
  }

  static bool Read(::glic::mojom::TabContextResult::DataView input, ::glic::mojom::TabContextResultPtr* output);
};


template <>
struct  StructTraits<::glic::mojom::WebPageData::DataView,
                                         ::glic::mojom::WebPageDataPtr> {
  static bool IsNull(const ::glic::mojom::WebPageDataPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::WebPageDataPtr* output) { output->reset(); }

  static const decltype(::glic::mojom::WebPageData::main_document)& main_document(
      const ::glic::mojom::WebPageDataPtr& input) {
    return input->main_document;
  }

  static bool Read(::glic::mojom::WebPageData::DataView input, ::glic::mojom::WebPageDataPtr* output);
};


template <>
struct  StructTraits<::glic::mojom::DocumentData::DataView,
                                         ::glic::mojom::DocumentDataPtr> {
  static bool IsNull(const ::glic::mojom::DocumentDataPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::DocumentDataPtr* output) { output->reset(); }

  static const decltype(::glic::mojom::DocumentData::origin)& origin(
      const ::glic::mojom::DocumentDataPtr& input) {
    return input->origin;
  }

  static const decltype(::glic::mojom::DocumentData::inner_text)& inner_text(
      const ::glic::mojom::DocumentDataPtr& input) {
    return input->inner_text;
  }

  static decltype(::glic::mojom::DocumentData::inner_text_truncated) inner_text_truncated(
      const ::glic::mojom::DocumentDataPtr& input) {
    return input->inner_text_truncated;
  }

  static bool Read(::glic::mojom::DocumentData::DataView input, ::glic::mojom::DocumentDataPtr* output);
};


template <>
struct  StructTraits<::glic::mojom::PdfDocumentData::DataView,
                                         ::glic::mojom::PdfDocumentDataPtr> {
  static bool IsNull(const ::glic::mojom::PdfDocumentDataPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::PdfDocumentDataPtr* output) { output->reset(); }

  static const decltype(::glic::mojom::PdfDocumentData::origin)& origin(
      const ::glic::mojom::PdfDocumentDataPtr& input) {
    return input->origin;
  }

  static const decltype(::glic::mojom::PdfDocumentData::pdf_data)& pdf_data(
      const ::glic::mojom::PdfDocumentDataPtr& input) {
    return input->pdf_data;
  }

  static decltype(::glic::mojom::PdfDocumentData::pdf_size_limit_exceeded) pdf_size_limit_exceeded(
      const ::glic::mojom::PdfDocumentDataPtr& input) {
    return input->pdf_size_limit_exceeded;
  }

  static bool Read(::glic::mojom::PdfDocumentData::DataView input, ::glic::mojom::PdfDocumentDataPtr* output);
};


template <>
struct  StructTraits<::glic::mojom::TabData::DataView,
                                         ::glic::mojom::TabDataPtr> {
  static bool IsNull(const ::glic::mojom::TabDataPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::TabDataPtr* output) { output->reset(); }

  static decltype(::glic::mojom::TabData::tab_id) tab_id(
      const ::glic::mojom::TabDataPtr& input) {
    return input->tab_id;
  }

  static decltype(::glic::mojom::TabData::window_id) window_id(
      const ::glic::mojom::TabDataPtr& input) {
    return input->window_id;
  }

  static const decltype(::glic::mojom::TabData::url)& url(
      const ::glic::mojom::TabDataPtr& input) {
    return input->url;
  }

  static const decltype(::glic::mojom::TabData::title)& title(
      const ::glic::mojom::TabDataPtr& input) {
    return input->title;
  }

  static  decltype(::glic::mojom::TabData::favicon)& favicon(
       ::glic::mojom::TabDataPtr& input) {
    return input->favicon;
  }

  static const decltype(::glic::mojom::TabData::favicon_url)& favicon_url(
      const ::glic::mojom::TabDataPtr& input) {
    return input->favicon_url;
  }

  static const decltype(::glic::mojom::TabData::document_mime_type)& document_mime_type(
      const ::glic::mojom::TabDataPtr& input) {
    return input->document_mime_type;
  }

  static decltype(::glic::mojom::TabData::is_observable) is_observable(
      const ::glic::mojom::TabDataPtr& input) {
    return input->is_observable;
  }

  static decltype(::glic::mojom::TabData::is_media_active) is_media_active(
      const ::glic::mojom::TabDataPtr& input) {
    return input->is_media_active;
  }

  static decltype(::glic::mojom::TabData::is_tab_content_captured) is_tab_content_captured(
      const ::glic::mojom::TabDataPtr& input) {
    return input->is_tab_content_captured;
  }

  static decltype(::glic::mojom::TabData::is_active_in_window) is_active_in_window(
      const ::glic::mojom::TabDataPtr& input) {
    return input->is_active_in_window;
  }

  static decltype(::glic::mojom::TabData::is_window_active) is_window_active(
      const ::glic::mojom::TabDataPtr& input) {
    return input->is_window_active;
  }

  static const decltype(::glic::mojom::TabData::lightweight_page_features)& lightweight_page_features(
      const ::glic::mojom::TabDataPtr& input) {
    return input->lightweight_page_features;
  }

  static bool Read(::glic::mojom::TabData::DataView input, ::glic::mojom::TabDataPtr* output);
};


template <>
struct  StructTraits<::glic::mojom::NoFocusedTabData::DataView,
                                         ::glic::mojom::NoFocusedTabDataPtr> {
  static bool IsNull(const ::glic::mojom::NoFocusedTabDataPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::NoFocusedTabDataPtr* output) { output->reset(); }

  static  decltype(::glic::mojom::NoFocusedTabData::active_tab_data)& active_tab_data(
       ::glic::mojom::NoFocusedTabDataPtr& input) {
    return input->active_tab_data;
  }

  static const decltype(::glic::mojom::NoFocusedTabData::no_focus_reason)& no_focus_reason(
      const ::glic::mojom::NoFocusedTabDataPtr& input) {
    return input->no_focus_reason;
  }

  static bool Read(::glic::mojom::NoFocusedTabData::DataView input, ::glic::mojom::NoFocusedTabDataPtr* output);
};


template <>
struct  StructTraits<::glic::mojom::AnnotatedPageData::DataView,
                                         ::glic::mojom::AnnotatedPageDataPtr> {
  static bool IsNull(const ::glic::mojom::AnnotatedPageDataPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::AnnotatedPageDataPtr* output) { output->reset(); }

  static  decltype(::glic::mojom::AnnotatedPageData::annotated_page_content)& annotated_page_content(
       ::glic::mojom::AnnotatedPageDataPtr& input) {
    return input->annotated_page_content;
  }

  static const decltype(::glic::mojom::AnnotatedPageData::metadata)& metadata(
      const ::glic::mojom::AnnotatedPageDataPtr& input) {
    return input->metadata;
  }

  static bool Read(::glic::mojom::AnnotatedPageData::DataView input, ::glic::mojom::AnnotatedPageDataPtr* output);
};


template <>
struct  StructTraits<::glic::mojom::ImageOriginAnnotations::DataView,
                                         ::glic::mojom::ImageOriginAnnotationsPtr> {
  static bool IsNull(const ::glic::mojom::ImageOriginAnnotationsPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::ImageOriginAnnotationsPtr* output) { output->reset(); }

  static bool Read(::glic::mojom::ImageOriginAnnotations::DataView input, ::glic::mojom::ImageOriginAnnotationsPtr* output);
};


template <>
struct  StructTraits<::glic::mojom::Journal::DataView,
                                         ::glic::mojom::JournalPtr> {
  static bool IsNull(const ::glic::mojom::JournalPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::JournalPtr* output) { output->reset(); }

  static const decltype(::glic::mojom::Journal::data)& data(
      const ::glic::mojom::JournalPtr& input) {
    return input->data;
  }

  static bool Read(::glic::mojom::Journal::DataView input, ::glic::mojom::JournalPtr* output);
};


template <>
struct  StructTraits<::glic::mojom::PendingCapturedRegion::DataView,
                                         ::glic::mojom::PendingCapturedRegionPtr> {
  static bool IsNull(const ::glic::mojom::PendingCapturedRegionPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::PendingCapturedRegionPtr* output) { output->reset(); }

  static const decltype(::glic::mojom::PendingCapturedRegion::id)& id(
      const ::glic::mojom::PendingCapturedRegionPtr& input) {
    return input->id;
  }

  static const decltype(::glic::mojom::PendingCapturedRegion::region)& region(
      const ::glic::mojom::PendingCapturedRegionPtr& input) {
    return input->region;
  }

  static bool Read(::glic::mojom::PendingCapturedRegion::DataView input, ::glic::mojom::PendingCapturedRegionPtr* output);
};


template <>
struct  StructTraits<::glic::mojom::CaptureRegionResult::DataView,
                                         ::glic::mojom::CaptureRegionResultPtr> {
  static bool IsNull(const ::glic::mojom::CaptureRegionResultPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::CaptureRegionResultPtr* output) { output->reset(); }

  static decltype(::glic::mojom::CaptureRegionResult::tab_id) tab_id(
      const ::glic::mojom::CaptureRegionResultPtr& input) {
    return input->tab_id;
  }

  static const decltype(::glic::mojom::CaptureRegionResult::region)& region(
      const ::glic::mojom::CaptureRegionResultPtr& input) {
    return input->region;
  }

  static bool Read(::glic::mojom::CaptureRegionResult::DataView input, ::glic::mojom::CaptureRegionResultPtr* output);
};


template <>
struct  StructTraits<::glic::mojom::Screenshot::DataView,
                                         ::glic::mojom::ScreenshotPtr> {
  static bool IsNull(const ::glic::mojom::ScreenshotPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::ScreenshotPtr* output) { output->reset(); }

  static decltype(::glic::mojom::Screenshot::width_pixels) width_pixels(
      const ::glic::mojom::ScreenshotPtr& input) {
    return input->width_pixels;
  }

  static decltype(::glic::mojom::Screenshot::height_pixels) height_pixels(
      const ::glic::mojom::ScreenshotPtr& input) {
    return input->height_pixels;
  }

  static const decltype(::glic::mojom::Screenshot::data)& data(
      const ::glic::mojom::ScreenshotPtr& input) {
    return input->data;
  }

  static const decltype(::glic::mojom::Screenshot::mime_type)& mime_type(
      const ::glic::mojom::ScreenshotPtr& input) {
    return input->mime_type;
  }

  static const decltype(::glic::mojom::Screenshot::origin_annotations)& origin_annotations(
      const ::glic::mojom::ScreenshotPtr& input) {
    return input->origin_annotations;
  }

  static decltype(::glic::mojom::Screenshot::encryption_scheme) encryption_scheme(
      const ::glic::mojom::ScreenshotPtr& input) {
    return input->encryption_scheme;
  }

  static bool Read(::glic::mojom::Screenshot::DataView input, ::glic::mojom::ScreenshotPtr* output);
};


template <>
struct  StructTraits<::glic::mojom::ImageInfo::DataView,
                                         ::glic::mojom::ImageInfoPtr> {
  static bool IsNull(const ::glic::mojom::ImageInfoPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::ImageInfoPtr* output) { output->reset(); }

  static const decltype(::glic::mojom::ImageInfo::caption)& caption(
      const ::glic::mojom::ImageInfoPtr& input) {
    return input->caption;
  }

  static const decltype(::glic::mojom::ImageInfo::source_origin)& source_origin(
      const ::glic::mojom::ImageInfoPtr& input) {
    return input->source_origin;
  }

  static const decltype(::glic::mojom::ImageInfo::url)& url(
      const ::glic::mojom::ImageInfoPtr& input) {
    return input->url;
  }

  static const decltype(::glic::mojom::ImageInfo::mime_type)& mime_type(
      const ::glic::mojom::ImageInfoPtr& input) {
    return input->mime_type;
  }

  static bool Read(::glic::mojom::ImageInfo::DataView input, ::glic::mojom::ImageInfoPtr* output);
};


template <>
struct  StructTraits<::glic::mojom::ImageBytesResult::DataView,
                                         ::glic::mojom::ImageBytesResultPtr> {
  static bool IsNull(const ::glic::mojom::ImageBytesResultPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::ImageBytesResultPtr* output) { output->reset(); }

  static  decltype(::glic::mojom::ImageBytesResult::bytes)& bytes(
       ::glic::mojom::ImageBytesResultPtr& input) {
    return input->bytes;
  }

  static const decltype(::glic::mojom::ImageBytesResult::image_info)& image_info(
      const ::glic::mojom::ImageBytesResultPtr& input) {
    return input->image_info;
  }

  static bool Read(::glic::mojom::ImageBytesResult::DataView input, ::glic::mojom::ImageBytesResultPtr* output);
};


template <>
struct  StructTraits<::glic::mojom::OpenSettingsOptions::DataView,
                                         ::glic::mojom::OpenSettingsOptionsPtr> {
  static bool IsNull(const ::glic::mojom::OpenSettingsOptionsPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::OpenSettingsOptionsPtr* output) { output->reset(); }

  static decltype(::glic::mojom::OpenSettingsOptions::highlightField) highlightField(
      const ::glic::mojom::OpenSettingsOptionsPtr& input) {
    return input->highlightField;
  }

  static bool Read(::glic::mojom::OpenSettingsOptions::DataView input, ::glic::mojom::OpenSettingsOptionsPtr* output);
};


template <>
struct  UnionTraits<::glic::mojom::InvokeConversationSelection::DataView,
                                        ::glic::mojom::InvokeConversationSelectionPtr> {
  static bool IsNull(const ::glic::mojom::InvokeConversationSelectionPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::InvokeConversationSelectionPtr* output) { output->reset(); }

  static ::glic::mojom::InvokeConversationSelection::Tag GetTag(const ::glic::mojom::InvokeConversationSelectionPtr& input) {
    return input->which();
  }

  static const ::glic::mojom::DefaultConversationPtr& default_conversation(const ::glic::mojom::InvokeConversationSelectionPtr& input) {
    return input->get_default_conversation();
  }

  static const ::glic::mojom::NewConversationPtr& new_conversation(const ::glic::mojom::InvokeConversationSelectionPtr& input) {
    return input->get_new_conversation();
  }

  static const std::string& conversation_id(const ::glic::mojom::InvokeConversationSelectionPtr& input) {
    return input->get_conversation_id();
  }

  static bool Read(::glic::mojom::InvokeConversationSelection::DataView input, ::glic::mojom::InvokeConversationSelectionPtr* output);
};


template <>
struct  UnionTraits<::glic::mojom::InvokeTargetSurface::DataView,
                                        ::glic::mojom::InvokeTargetSurfacePtr> {
  static bool IsNull(const ::glic::mojom::InvokeTargetSurfacePtr& input) { return !input; }
  static void SetToNull(::glic::mojom::InvokeTargetSurfacePtr* output) { output->reset(); }

  static ::glic::mojom::InvokeTargetSurface::Tag GetTag(const ::glic::mojom::InvokeTargetSurfacePtr& input) {
    return input->which();
  }

  static const ::glic::mojom::DefaultSurfaceMojoPtr& default_surface(const ::glic::mojom::InvokeTargetSurfacePtr& input) {
    return input->get_default_surface();
  }

  static const ::glic::mojom::NewTabMojoPtr& new_tab(const ::glic::mojom::InvokeTargetSurfacePtr& input) {
    return input->get_new_tab();
  }

  static bool Read(::glic::mojom::InvokeTargetSurface::DataView input, ::glic::mojom::InvokeTargetSurfacePtr* output);
};


template <>
struct  UnionTraits<::glic::mojom::GetContextResult::DataView,
                                        ::glic::mojom::GetContextResultPtr> {
  static bool IsNull(const ::glic::mojom::GetContextResultPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::GetContextResultPtr* output) { output->reset(); }

  static ::glic::mojom::GetContextResult::Tag GetTag(const ::glic::mojom::GetContextResultPtr& input) {
    return input->which();
  }

  static const std::string& error_reason(const ::glic::mojom::GetContextResultPtr& input) {
    return input->get_error_reason();
  }

  static  ::glic::mojom::TabContextResultPtr& tab_context( ::glic::mojom::GetContextResultPtr& input) {
    return input->get_tab_context();
  }

  static bool Read(::glic::mojom::GetContextResult::DataView input, ::glic::mojom::GetContextResultPtr* output);
};


template <>
struct  UnionTraits<::glic::mojom::CaptureScreenshotResult::DataView,
                                        ::glic::mojom::CaptureScreenshotResultPtr> {
  static bool IsNull(const ::glic::mojom::CaptureScreenshotResultPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::CaptureScreenshotResultPtr* output) { output->reset(); }

  static ::glic::mojom::CaptureScreenshotResult::Tag GetTag(const ::glic::mojom::CaptureScreenshotResultPtr& input) {
    return input->which();
  }

  static  ::glic::mojom::CaptureScreenshotErrorReason error_reason(const ::glic::mojom::CaptureScreenshotResultPtr& input) {
    return input->get_error_reason();
  }

  static const ::glic::mojom::ScreenshotPtr& screenshot(const ::glic::mojom::CaptureScreenshotResultPtr& input) {
    return input->get_screenshot();
  }

  static bool Read(::glic::mojom::CaptureScreenshotResult::DataView input, ::glic::mojom::CaptureScreenshotResultPtr* output);
};


template <>
struct  UnionTraits<::glic::mojom::ScrollToSelector::DataView,
                                        ::glic::mojom::ScrollToSelectorPtr> {
  static bool IsNull(const ::glic::mojom::ScrollToSelectorPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::ScrollToSelectorPtr* output) { output->reset(); }

  static ::glic::mojom::ScrollToSelector::Tag GetTag(const ::glic::mojom::ScrollToSelectorPtr& input) {
    return input->which();
  }

  static const ::glic::mojom::ScrollToTextSelectorPtr& exact_text(const ::glic::mojom::ScrollToSelectorPtr& input) {
    return input->get_exact_text();
  }

  static const ::glic::mojom::ScrollToTextFragmentSelectorPtr& text_fragment(const ::glic::mojom::ScrollToSelectorPtr& input) {
    return input->get_text_fragment();
  }

  static const ::glic::mojom::ScrollToNodeSelectorPtr& node(const ::glic::mojom::ScrollToSelectorPtr& input) {
    return input->get_node();
  }

  static bool Read(::glic::mojom::ScrollToSelector::DataView input, ::glic::mojom::ScrollToSelectorPtr* output);
};


template <>
struct  UnionTraits<::glic::mojom::InvocationPayload::DataView,
                                        ::glic::mojom::InvocationPayloadPtr> {
  static bool IsNull(const ::glic::mojom::InvocationPayloadPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::InvocationPayloadPtr* output) { output->reset(); }

  static ::glic::mojom::InvocationPayload::Tag GetTag(const ::glic::mojom::InvocationPayloadPtr& input) {
    return input->which();
  }

  static const ::glic::mojom::UniversalCartPayloadPtr& universal_cart(const ::glic::mojom::InvocationPayloadPtr& input) {
    return input->get_universal_cart();
  }

  static const ::glic::mojom::SkillsPayloadPtr& skills_payload(const ::glic::mojom::InvocationPayloadPtr& input) {
    return input->get_skills_payload();
  }

  static bool Read(::glic::mojom::InvocationPayload::DataView input, ::glic::mojom::InvocationPayloadPtr* output);
};


template <>
struct  UnionTraits<::glic::mojom::AdditionalContextPart::DataView,
                                        ::glic::mojom::AdditionalContextPartPtr> {
  static bool IsNull(const ::glic::mojom::AdditionalContextPartPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::AdditionalContextPartPtr* output) { output->reset(); }

  static ::glic::mojom::AdditionalContextPart::Tag GetTag(const ::glic::mojom::AdditionalContextPartPtr& input) {
    return input->which();
  }

  static  ::glic::mojom::ContextDataPtr& data( ::glic::mojom::AdditionalContextPartPtr& input) {
    return input->get_data();
  }

  static const ::glic::mojom::ScreenshotPtr& screenshot(const ::glic::mojom::AdditionalContextPartPtr& input) {
    return input->get_screenshot();
  }

  static const ::glic::mojom::WebPageDataPtr& web_page_data(const ::glic::mojom::AdditionalContextPartPtr& input) {
    return input->get_web_page_data();
  }

  static  ::glic::mojom::AnnotatedPageDataPtr& annotated_page_data( ::glic::mojom::AdditionalContextPartPtr& input) {
    return input->get_annotated_page_data();
  }

  static const ::glic::mojom::PdfDocumentDataPtr& pdf_document_data(const ::glic::mojom::AdditionalContextPartPtr& input) {
    return input->get_pdf_document_data();
  }

  static  ::glic::mojom::TabContextResultPtr& tab_context( ::glic::mojom::AdditionalContextPartPtr& input) {
    return input->get_tab_context();
  }

  static const ::glic::mojom::CapturedRegionPtr& region(const ::glic::mojom::AdditionalContextPartPtr& input) {
    return input->get_region();
  }

  static const ::glic::mojom::PendingCapturedRegionPtr& pending_region(const ::glic::mojom::AdditionalContextPartPtr& input) {
    return input->get_pending_region();
  }

  static const ::glic::mojom::ParentConversationMetadataPtr& parent_conversation_metadata(const ::glic::mojom::AdditionalContextPartPtr& input) {
    return input->get_parent_conversation_metadata();
  }

  static bool Read(::glic::mojom::AdditionalContextPart::DataView input, ::glic::mojom::AdditionalContextPartPtr* output);
};


template <>
struct  UnionTraits<::glic::mojom::FocusedTabData::DataView,
                                        ::glic::mojom::FocusedTabDataPtr> {
  static bool IsNull(const ::glic::mojom::FocusedTabDataPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::FocusedTabDataPtr* output) { output->reset(); }

  static ::glic::mojom::FocusedTabData::Tag GetTag(const ::glic::mojom::FocusedTabDataPtr& input) {
    return input->which();
  }

  static  ::glic::mojom::TabDataPtr& focused_tab( ::glic::mojom::FocusedTabDataPtr& input) {
    return input->get_focused_tab();
  }

  static  ::glic::mojom::NoFocusedTabDataPtr& no_focused_tab_data( ::glic::mojom::FocusedTabDataPtr& input) {
    return input->get_no_focused_tab_data();
  }

  static bool Read(::glic::mojom::FocusedTabData::DataView input, ::glic::mojom::FocusedTabDataPtr* output);
};


template <>
struct  UnionTraits<::glic::mojom::CapturedRegion::DataView,
                                        ::glic::mojom::CapturedRegionPtr> {
  static bool IsNull(const ::glic::mojom::CapturedRegionPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::CapturedRegionPtr* output) { output->reset(); }

  static ::glic::mojom::CapturedRegion::Tag GetTag(const ::glic::mojom::CapturedRegionPtr& input) {
    return input->which();
  }

  static const ::gfx::Rect& rect(const ::glic::mojom::CapturedRegionPtr& input) {
    return input->get_rect();
  }

  static const std::vector<::gfx::Point>& polyline(const ::glic::mojom::CapturedRegionPtr& input) {
    return input->get_polyline();
  }

  static bool Read(::glic::mojom::CapturedRegion::DataView input, ::glic::mojom::CapturedRegionPtr* output);
};


template <>
struct  UnionTraits<::glic::mojom::GetImageBytesResult::DataView,
                                        ::glic::mojom::GetImageBytesResultPtr> {
  static bool IsNull(const ::glic::mojom::GetImageBytesResultPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::GetImageBytesResultPtr* output) { output->reset(); }

  static ::glic::mojom::GetImageBytesResult::Tag GetTag(const ::glic::mojom::GetImageBytesResultPtr& input) {
    return input->which();
  }

  static  ::glic::mojom::ImageBytesResultPtr& image_bytes( ::glic::mojom::GetImageBytesResultPtr& input) {
    return input->get_image_bytes();
  }

  static const std::string& error_reason(const ::glic::mojom::GetImageBytesResultPtr& input) {
    return input->get_error_reason();
  }

  static bool Read(::glic::mojom::GetImageBytesResult::DataView input, ::glic::mojom::GetImageBytesResultPtr* output);
};


template <>
struct  UnionTraits<::glic::mojom::ActorHandler_CreateTask_ResponseParam_Result::DataView,
                                        ::glic::mojom::ActorHandler_CreateTask_ResponseParam_ResultPtr> {
  static bool IsNull(const ::glic::mojom::ActorHandler_CreateTask_ResponseParam_ResultPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::ActorHandler_CreateTask_ResponseParam_ResultPtr* output) { output->reset(); }

  static ::glic::mojom::ActorHandler_CreateTask_ResponseParam_Result::Tag GetTag(const ::glic::mojom::ActorHandler_CreateTask_ResponseParam_ResultPtr& input) {
    return input->which();
  }

  static  int32_t success(const ::glic::mojom::ActorHandler_CreateTask_ResponseParam_ResultPtr& input) {
    return input->get_success();
  }

  static  ::glic::mojom::CreateTaskErrorReason failure(const ::glic::mojom::ActorHandler_CreateTask_ResponseParam_ResultPtr& input) {
    return input->get_failure();
  }

  static bool Read(::glic::mojom::ActorHandler_CreateTask_ResponseParam_Result::DataView input, ::glic::mojom::ActorHandler_CreateTask_ResponseParam_ResultPtr* output);
};


template <>
struct  UnionTraits<::glic::mojom::ActorHandler_PerformActions_ResponseParam_Result::DataView,
                                        ::glic::mojom::ActorHandler_PerformActions_ResponseParam_ResultPtr> {
  static bool IsNull(const ::glic::mojom::ActorHandler_PerformActions_ResponseParam_ResultPtr& input) { return !input; }
  static void SetToNull(::glic::mojom::ActorHandler_PerformActions_ResponseParam_ResultPtr* output) { output->reset(); }

  static ::glic::mojom::ActorHandler_PerformActions_ResponseParam_Result::Tag GetTag(const ::glic::mojom::ActorHandler_PerformActions_ResponseParam_ResultPtr& input) {
    return input->which();
  }

  static  ::mojo_base::ProtoWrapper& success( ::glic::mojom::ActorHandler_PerformActions_ResponseParam_ResultPtr& input) {
    return input->get_success();
  }

  static  ::glic::mojom::PerformActionsErrorReason failure(const ::glic::mojom::ActorHandler_PerformActions_ResponseParam_ResultPtr& input) {
    return input->get_failure();
  }

  static bool Read(::glic::mojom::ActorHandler_PerformActions_ResponseParam_Result::DataView input, ::glic::mojom::ActorHandler_PerformActions_ResponseParam_ResultPtr* output);
};

}  // namespace mojo

#endif  // CHROME_BROWSER_GLIC_HOST_GLIC_MOJOM_H_