// chrome/browser/glic/host/glic_internals.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_INTERNALS_MOJOM_H_
#define CHROME_BROWSER_GLIC_HOST_GLIC_INTERNALS_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_internals.mojom-features.h"  // IWYU pragma: export
#include "chrome/browser/glic/host/glic_internals.mojom-shared.h"  // IWYU pragma: export
#include "chrome/browser/glic/host/glic_internals.mojom-forward.h"  // IWYU pragma: export
#include "chrome/browser/glic/host/glic.mojom.h"
#include "chrome/common/glic_enums.mojom-forward.h"
#include "mojo/public/mojom/base/time.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"






namespace glic::mojom {

class InternalsPageHandlerProxy;

template <typename ImplRefTraits>
class InternalsPageHandlerStub;

class InternalsPageHandlerRequestValidator;
class InternalsPageHandlerResponseValidator;


class InternalsPageHandler
    : public InternalsPageHandlerInterfaceBase {
 public:
  using IPCStableHashFunction = uint32_t(*)();
  static constexpr const char* Name_ = "glic.mojom.InternalsPageHandler";
  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_ = InternalsPageHandlerInterfaceBase;
  using Proxy_ = InternalsPageHandlerProxy;

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

  using RequestValidator_ = InternalsPageHandlerRequestValidator;
  using ResponseValidator_ = InternalsPageHandlerResponseValidator;
  enum MethodMinVersions : uint32_t {
    kGetInternalsDataPayloadMinVersion = 0,
    kSetGuestUrlPresetsMinVersion = 0,
    kTriggerInvokeFromInternalsActionMinVersion = 0,
    kGetOpenTabsMinVersion = 0,
    kSetWebContinuityOriginatingHostUrlPresetMinVersion = 0,
    kSetShowErrorAllowedMinVersion = 0,
    kShowExperimentalOptInMinVersion = 0,
    kRevokeExperimentalTriggeringConsentMinVersion = 0,
    kRevokeGlicConsentMinVersion = 0,
    kRevokeActuationConsentMinVersion = 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 GetInternalsDataPayload_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct SetGuestUrlPresets_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct TriggerInvokeFromInternalsAction_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct GetOpenTabs_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct SetWebContinuityOriginatingHostUrlPreset_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct SetShowErrorAllowed_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct ShowExperimentalOptIn_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct RevokeExperimentalTriggeringConsent_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct RevokeGlicConsent_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
  struct RevokeActuationConsent_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
#endif // !BUILDFLAG(IS_FUCHSIA)
  virtual ~InternalsPageHandler() = default;

  using GetInternalsDataPayloadCallback = base::OnceCallback<void(InternalsDataPayloadPtr)>;
  using GetInternalsDataPayloadMojoCallback = base::OnceCallback<void(InternalsDataPayloadPtr)>;

  virtual void GetInternalsDataPayload(GetInternalsDataPayloadCallback callback) = 0;

  virtual void SetGuestUrlPresets(const ::GURL& autopush, const ::GURL& staging, const ::GURL& preprod, const ::GURL& prod) = 0;

  using TriggerInvokeFromInternalsActionCallback = base::OnceCallback<void(bool, const std::string&)>;
  using TriggerInvokeFromInternalsActionMojoCallback = base::OnceCallback<void(bool, const std::string&)>;

  virtual void TriggerInvokeFromInternalsAction(TriggerInvokeFromInternalsOptionsPtr options, TriggerInvokeFromInternalsActionCallback callback) = 0;

  using GetOpenTabsCallback = base::OnceCallback<void(const std::vector<std::string>&)>;
  using GetOpenTabsMojoCallback = base::OnceCallback<void(const std::vector<std::string>&)>;

  virtual void GetOpenTabs(GetOpenTabsCallback callback) = 0;

  virtual void SetWebContinuityOriginatingHostUrlPreset(const ::GURL& web_continuity_originating_host_url) = 0;

  virtual void SetShowErrorAllowed(bool allowed) = 0;

  virtual void ShowExperimentalOptIn() = 0;

  virtual void RevokeExperimentalTriggeringConsent() = 0;

  virtual void RevokeGlicConsent() = 0;

  virtual void RevokeActuationConsent() = 0;
};

class InternalsPageHandlerFactoryProxy;

template <typename ImplRefTraits>
class InternalsPageHandlerFactoryStub;

class InternalsPageHandlerFactoryRequestValidator;


class InternalsPageHandlerFactory
    : public InternalsPageHandlerFactoryInterfaceBase {
 public:
  using IPCStableHashFunction = uint32_t(*)();
  static constexpr const char* Name_ = "glic.mojom.InternalsPageHandlerFactory";
  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_ = InternalsPageHandlerFactoryInterfaceBase;
  using Proxy_ = InternalsPageHandlerFactoryProxy;

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

  using RequestValidator_ = InternalsPageHandlerFactoryRequestValidator;
  using ResponseValidator_ = mojo::PassThroughFilter;
  enum MethodMinVersions : uint32_t {
    kCreateInternalsPageHandlerMinVersion = 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 CreateInternalsPageHandler_Sym {
    NOINLINE static uint32_t IPCStableHash();
  };
#endif // !BUILDFLAG(IS_FUCHSIA)
  virtual ~InternalsPageHandlerFactory() = default;

  virtual void CreateInternalsPageHandler(::mojo::PendingReceiver<InternalsPageHandler> receiver) = 0;
};



class  InternalsPageHandlerProxy
    : public InternalsPageHandler {
 public:
  using InterfaceType = InternalsPageHandler;

  explicit InternalsPageHandlerProxy(mojo::MessageReceiverWithResponder* receiver);
  
  void GetInternalsDataPayload(GetInternalsDataPayloadCallback callback) final;
  
  void SetGuestUrlPresets(const ::GURL& autopush, const ::GURL& staging, const ::GURL& preprod, const ::GURL& prod) final;
  
  void TriggerInvokeFromInternalsAction(TriggerInvokeFromInternalsOptionsPtr options, TriggerInvokeFromInternalsActionCallback callback) final;
  
  void GetOpenTabs(GetOpenTabsCallback callback) final;
  
  void SetWebContinuityOriginatingHostUrlPreset(const ::GURL& web_continuity_originating_host_url) final;
  
  void SetShowErrorAllowed(bool allowed) final;
  
  void ShowExperimentalOptIn() final;
  
  void RevokeExperimentalTriggeringConsent() final;
  
  void RevokeGlicConsent() final;
  
  void RevokeActuationConsent() final;

 private:
  mojo::MessageReceiverWithResponder* receiver_;
};



class  InternalsPageHandlerFactoryProxy
    : public InternalsPageHandlerFactory {
 public:
  using InterfaceType = InternalsPageHandlerFactory;

  explicit InternalsPageHandlerFactoryProxy(mojo::MessageReceiverWithResponder* receiver);
  
  void CreateInternalsPageHandler(::mojo::PendingReceiver<InternalsPageHandler> receiver) final;

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

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

  InternalsPageHandlerStub() = default;
  ~InternalsPageHandlerStub() 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 InternalsPageHandlerStubDispatch::Accept(
        ImplRefTraits::GetRawPointer(&sink_), message);
  }

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

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

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

  InternalsPageHandlerFactoryStub() = default;
  ~InternalsPageHandlerFactoryStub() 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 InternalsPageHandlerFactoryStubDispatch::Accept(
        ImplRefTraits::GetRawPointer(&sink_), message);
  }

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

 private:
  ImplPointerType sink_;
};
class  InternalsPageHandlerRequestValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class  InternalsPageHandlerFactoryRequestValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};
class  InternalsPageHandlerResponseValidator : public mojo::MessageReceiver {
 public:
  bool Accept(mojo::Message* message) override;
};








class  ScreenshotTestKeyConfiguration {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<ScreenshotTestKeyConfiguration, T>::value>;
  using DataView = ScreenshotTestKeyConfigurationDataView;
  using Data_ = internal::ScreenshotTestKeyConfiguration_Data;

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

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

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


  ScreenshotTestKeyConfiguration();

  ScreenshotTestKeyConfiguration(
      const std::string& public_key,
      const std::string& auth_secret);


  ~ScreenshotTestKeyConfiguration();

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

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

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

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

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

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

  
  std::string public_key;
  
  std::string auth_secret;

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

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

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

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








class  TieredRolloutInfo {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<TieredRolloutInfo, T>::value>;
  using DataView = TieredRolloutInfoDataView;
  using Data_ = internal::TieredRolloutInfo_Data;

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

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

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


  TieredRolloutInfo();

  TieredRolloutInfo(
      std::optional<int32_t> ai_subscription_tier,
      bool is_eligible_for_tiered_rollout_v1,
      bool is_eligible_for_tiered_rollout_v2,
      bool is_eligible_overall,
      bool glic_rollout_eligibility_pref,
      const std::string& tiered_rollout_v2_eligible_tiers,
      const std::string& preference_sync_status);


  ~TieredRolloutInfo();

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

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

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

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

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

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

  
  std::optional<int32_t> ai_subscription_tier;
  
  bool is_eligible_for_tiered_rollout_v1;
  
  bool is_eligible_for_tiered_rollout_v2;
  
  bool is_eligible_overall;
  
  bool glic_rollout_eligibility_pref;
  
  std::string tiered_rollout_v2_eligible_tiers;
  
  std::string preference_sync_status;

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

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

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

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





class  InternalsDataPayload {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<InternalsDataPayload, T>::value>;
  using DataView = InternalsDataPayloadDataView;
  using Data_ = internal::InternalsDataPayload_Data;

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

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

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


  InternalsDataPayload();

  InternalsDataPayload(
      ::glic::mojom::ProfileEnablementPtr enablement,
      ::glic::mojom::ConfigInfoPtr config,
      bool show_error_allowed,
      bool experimental_triggering_enabled,
      InternalsDebugInfoPtr debug_info,
      TieredRolloutInfoPtr tiered_rollout_info);

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

  ~InternalsDataPayload();

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

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

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

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

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

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

  
  ::glic::mojom::ProfileEnablementPtr enablement;
  
  ::glic::mojom::ConfigInfoPtr config;
  
  bool show_error_allowed;
  
  bool experimental_triggering_enabled;
  
  InternalsDebugInfoPtr debug_info;
  
  TieredRolloutInfoPtr tiered_rollout_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, InternalsDataPayload::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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





class  InternalsDebugInfo {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<InternalsDebugInfo, T>::value>;
  using DataView = InternalsDebugInfoDataView;
  using Data_ = internal::InternalsDebugInfo_Data;

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

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

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


  InternalsDebugInfo();

  InternalsDebugInfo(
      bool glic_actor_feature_enabled,
      bool glic_rollout_feature_enabled,
      bool glic_tiered_rollout_feature_enabled,
      bool glic_tiered_rollout_v2_feature_enabled,
      ::glic::mojom::Platform platform,
      ::glic::mojom::FormFactor form_factor,
      const base::flat_map<std::string, bool>& boolean_settings,
      const std::string& hotkey,
      const std::string& locale,
      const std::string& permanent_country_code,
      const std::string& session_country_code,
      bool system_requirement_met,
      bool os_version_supported,
      bool anchor_entrypoint_override_active,
      bool primary_account_needs_signed_in,
      const std::string& dogfood_status);


  ~InternalsDebugInfo();

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

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

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

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

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

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

  
  bool glic_actor_feature_enabled;
  
  bool glic_rollout_feature_enabled;
  
  bool glic_tiered_rollout_feature_enabled;
  
  bool glic_tiered_rollout_v2_feature_enabled;
  
  ::glic::mojom::Platform platform;
  
  ::glic::mojom::FormFactor form_factor;
  
  base::flat_map<std::string, bool> boolean_settings;
  
  std::string hotkey;
  
  std::string locale;
  
  std::string permanent_country_code;
  
  std::string session_country_code;
  
  bool system_requirement_met;
  
  bool os_version_supported;
  
  bool anchor_entrypoint_override_active;
  
  bool primary_account_needs_signed_in;
  
  std::string dogfood_status;

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

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

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

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






class  TriggerInvokeFromInternalsOptions {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<TriggerInvokeFromInternalsOptions, T>::value>;
  using DataView = TriggerInvokeFromInternalsOptionsDataView;
  using Data_ = internal::TriggerInvokeFromInternalsOptions_Data;

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

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

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


  TriggerInvokeFromInternalsOptions();

  TriggerInvokeFromInternalsOptions(
      ::glic::mojom::InvocationSource invocation_source,
      std::vector<std::string> prompts,
      ::glic::mojom::AdditionalContextPtr additional_context,
      ::glic::mojom::InvokeConversationSelectionPtr conversation,
      std::optional<::glic::mojom::FeatureMode> feature_mode,
      bool disable_zss,
      ::glic::mojom::ZssConfigPtr zss_config,
      const std::optional<std::string>& skill_id,
      const std::optional<std::string>& error_message,
      std::optional<::base::TimeDelta> timeout,
      bool auto_submit,
      ::glic::mojom::FreOverride fre_override,
      bool wait_for_panel_open,
      std::optional<bool> focus_on_show,
      FreCompletionWaitMode fre_completion_wait_mode,
      std::optional<bool> show_panel,
      ::glic::mojom::InvokeTargetSurfacePtr surface,
      std::optional<int32_t> specific_tab_index,
      std::optional<std::vector<int32_t>> specific_tabs_to_share_indices,
      ::glic::mojom::ActuationTarget actuation_target,
      ::glic::mojom::InvocationPayloadPtr payload,
      bool take_screenshot,
      ScreenshotTestKeyConfigurationPtr key_config,
      bool supersede_if_in_progress);

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

  ~TriggerInvokeFromInternalsOptions();

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

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

  template <typename T, TriggerInvokeFromInternalsOptions::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<
        TriggerInvokeFromInternalsOptions::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::TriggerInvokeFromInternalsOptions_UnserializedMessageContext<
            UserType, TriggerInvokeFromInternalsOptions::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<TriggerInvokeFromInternalsOptions::DataView>(
        message, data, data_num_bytes, output, Validate);
  }

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

  
  ::glic::mojom::InvocationSource invocation_source;
  
  std::vector<std::string> prompts;
  
  ::glic::mojom::AdditionalContextPtr additional_context;
  
  ::glic::mojom::InvokeConversationSelectionPtr conversation;
  
  std::optional<::glic::mojom::FeatureMode> feature_mode;
  
  bool disable_zss;
  
  ::glic::mojom::ZssConfigPtr zss_config;
  
  std::optional<std::string> skill_id;
  
  std::optional<std::string> error_message;
  
  std::optional<::base::TimeDelta> timeout;
  
  bool auto_submit;
  
  ::glic::mojom::FreOverride fre_override;
  
  bool wait_for_panel_open;
  
  std::optional<bool> focus_on_show;
  
  FreCompletionWaitMode fre_completion_wait_mode;
  
  std::optional<bool> show_panel;
  
  ::glic::mojom::InvokeTargetSurfacePtr surface;
  
  std::optional<int32_t> specific_tab_index;
  
  std::optional<std::vector<int32_t>> specific_tabs_to_share_indices;
  
  ::glic::mojom::ActuationTarget actuation_target;
  
  ::glic::mojom::InvocationPayloadPtr payload;
  
  bool take_screenshot;
  
  ScreenshotTestKeyConfigurationPtr key_config;
  
  bool supersede_if_in_progress;

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

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

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

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

template <typename StructPtrType>
TieredRolloutInfoPtr TieredRolloutInfo::Clone() const {
  return New(
      mojo::Clone(ai_subscription_tier),
      mojo::Clone(is_eligible_for_tiered_rollout_v1),
      mojo::Clone(is_eligible_for_tiered_rollout_v2),
      mojo::Clone(is_eligible_overall),
      mojo::Clone(glic_rollout_eligibility_pref),
      mojo::Clone(tiered_rollout_v2_eligible_tiers),
      mojo::Clone(preference_sync_status)
  );
}

template <typename T, TieredRolloutInfo::EnableIfSame<T>*>
bool TieredRolloutInfo::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->ai_subscription_tier, other_struct.ai_subscription_tier))
    return false;
  if (!mojo::Equals(this->is_eligible_for_tiered_rollout_v1, other_struct.is_eligible_for_tiered_rollout_v1))
    return false;
  if (!mojo::Equals(this->is_eligible_for_tiered_rollout_v2, other_struct.is_eligible_for_tiered_rollout_v2))
    return false;
  if (!mojo::Equals(this->is_eligible_overall, other_struct.is_eligible_overall))
    return false;
  if (!mojo::Equals(this->glic_rollout_eligibility_pref, other_struct.glic_rollout_eligibility_pref))
    return false;
  if (!mojo::Equals(this->tiered_rollout_v2_eligible_tiers, other_struct.tiered_rollout_v2_eligible_tiers))
    return false;
  if (!mojo::Equals(this->preference_sync_status, other_struct.preference_sync_status))
    return false;
  return true;
}

template <typename T, TieredRolloutInfo::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.ai_subscription_tier < rhs.ai_subscription_tier)
    return true;
  if (rhs.ai_subscription_tier < lhs.ai_subscription_tier)
    return false;
  if (lhs.is_eligible_for_tiered_rollout_v1 < rhs.is_eligible_for_tiered_rollout_v1)
    return true;
  if (rhs.is_eligible_for_tiered_rollout_v1 < lhs.is_eligible_for_tiered_rollout_v1)
    return false;
  if (lhs.is_eligible_for_tiered_rollout_v2 < rhs.is_eligible_for_tiered_rollout_v2)
    return true;
  if (rhs.is_eligible_for_tiered_rollout_v2 < lhs.is_eligible_for_tiered_rollout_v2)
    return false;
  if (lhs.is_eligible_overall < rhs.is_eligible_overall)
    return true;
  if (rhs.is_eligible_overall < lhs.is_eligible_overall)
    return false;
  if (lhs.glic_rollout_eligibility_pref < rhs.glic_rollout_eligibility_pref)
    return true;
  if (rhs.glic_rollout_eligibility_pref < lhs.glic_rollout_eligibility_pref)
    return false;
  if (lhs.tiered_rollout_v2_eligible_tiers < rhs.tiered_rollout_v2_eligible_tiers)
    return true;
  if (rhs.tiered_rollout_v2_eligible_tiers < lhs.tiered_rollout_v2_eligible_tiers)
    return false;
  if (lhs.preference_sync_status < rhs.preference_sync_status)
    return true;
  if (rhs.preference_sync_status < lhs.preference_sync_status)
    return false;
  return false;
}
template <typename StructPtrType>
InternalsDataPayloadPtr InternalsDataPayload::Clone() const {
  return New(
      mojo::Clone(enablement),
      mojo::Clone(config),
      mojo::Clone(show_error_allowed),
      mojo::Clone(experimental_triggering_enabled),
      mojo::Clone(debug_info),
      mojo::Clone(tiered_rollout_info)
  );
}

template <typename T, InternalsDataPayload::EnableIfSame<T>*>
bool InternalsDataPayload::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->enablement, other_struct.enablement))
    return false;
  if (!mojo::Equals(this->config, other_struct.config))
    return false;
  if (!mojo::Equals(this->show_error_allowed, other_struct.show_error_allowed))
    return false;
  if (!mojo::Equals(this->experimental_triggering_enabled, other_struct.experimental_triggering_enabled))
    return false;
  if (!mojo::Equals(this->debug_info, other_struct.debug_info))
    return false;
  if (!mojo::Equals(this->tiered_rollout_info, other_struct.tiered_rollout_info))
    return false;
  return true;
}

template <typename T, InternalsDataPayload::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.enablement < rhs.enablement)
    return true;
  if (rhs.enablement < lhs.enablement)
    return false;
  if (lhs.config < rhs.config)
    return true;
  if (rhs.config < lhs.config)
    return false;
  if (lhs.show_error_allowed < rhs.show_error_allowed)
    return true;
  if (rhs.show_error_allowed < lhs.show_error_allowed)
    return false;
  if (lhs.experimental_triggering_enabled < rhs.experimental_triggering_enabled)
    return true;
  if (rhs.experimental_triggering_enabled < lhs.experimental_triggering_enabled)
    return false;
  if (lhs.debug_info < rhs.debug_info)
    return true;
  if (rhs.debug_info < lhs.debug_info)
    return false;
  if (lhs.tiered_rollout_info < rhs.tiered_rollout_info)
    return true;
  if (rhs.tiered_rollout_info < lhs.tiered_rollout_info)
    return false;
  return false;
}
template <typename StructPtrType>
InternalsDebugInfoPtr InternalsDebugInfo::Clone() const {
  return New(
      mojo::Clone(glic_actor_feature_enabled),
      mojo::Clone(glic_rollout_feature_enabled),
      mojo::Clone(glic_tiered_rollout_feature_enabled),
      mojo::Clone(glic_tiered_rollout_v2_feature_enabled),
      mojo::Clone(platform),
      mojo::Clone(form_factor),
      mojo::Clone(boolean_settings),
      mojo::Clone(hotkey),
      mojo::Clone(locale),
      mojo::Clone(permanent_country_code),
      mojo::Clone(session_country_code),
      mojo::Clone(system_requirement_met),
      mojo::Clone(os_version_supported),
      mojo::Clone(anchor_entrypoint_override_active),
      mojo::Clone(primary_account_needs_signed_in),
      mojo::Clone(dogfood_status)
  );
}

template <typename T, InternalsDebugInfo::EnableIfSame<T>*>
bool InternalsDebugInfo::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->glic_actor_feature_enabled, other_struct.glic_actor_feature_enabled))
    return false;
  if (!mojo::Equals(this->glic_rollout_feature_enabled, other_struct.glic_rollout_feature_enabled))
    return false;
  if (!mojo::Equals(this->glic_tiered_rollout_feature_enabled, other_struct.glic_tiered_rollout_feature_enabled))
    return false;
  if (!mojo::Equals(this->glic_tiered_rollout_v2_feature_enabled, other_struct.glic_tiered_rollout_v2_feature_enabled))
    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->boolean_settings, other_struct.boolean_settings))
    return false;
  if (!mojo::Equals(this->hotkey, other_struct.hotkey))
    return false;
  if (!mojo::Equals(this->locale, other_struct.locale))
    return false;
  if (!mojo::Equals(this->permanent_country_code, other_struct.permanent_country_code))
    return false;
  if (!mojo::Equals(this->session_country_code, other_struct.session_country_code))
    return false;
  if (!mojo::Equals(this->system_requirement_met, other_struct.system_requirement_met))
    return false;
  if (!mojo::Equals(this->os_version_supported, other_struct.os_version_supported))
    return false;
  if (!mojo::Equals(this->anchor_entrypoint_override_active, other_struct.anchor_entrypoint_override_active))
    return false;
  if (!mojo::Equals(this->primary_account_needs_signed_in, other_struct.primary_account_needs_signed_in))
    return false;
  if (!mojo::Equals(this->dogfood_status, other_struct.dogfood_status))
    return false;
  return true;
}

template <typename T, InternalsDebugInfo::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.glic_actor_feature_enabled < rhs.glic_actor_feature_enabled)
    return true;
  if (rhs.glic_actor_feature_enabled < lhs.glic_actor_feature_enabled)
    return false;
  if (lhs.glic_rollout_feature_enabled < rhs.glic_rollout_feature_enabled)
    return true;
  if (rhs.glic_rollout_feature_enabled < lhs.glic_rollout_feature_enabled)
    return false;
  if (lhs.glic_tiered_rollout_feature_enabled < rhs.glic_tiered_rollout_feature_enabled)
    return true;
  if (rhs.glic_tiered_rollout_feature_enabled < lhs.glic_tiered_rollout_feature_enabled)
    return false;
  if (lhs.glic_tiered_rollout_v2_feature_enabled < rhs.glic_tiered_rollout_v2_feature_enabled)
    return true;
  if (rhs.glic_tiered_rollout_v2_feature_enabled < lhs.glic_tiered_rollout_v2_feature_enabled)
    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.boolean_settings < rhs.boolean_settings)
    return true;
  if (rhs.boolean_settings < lhs.boolean_settings)
    return false;
  if (lhs.hotkey < rhs.hotkey)
    return true;
  if (rhs.hotkey < lhs.hotkey)
    return false;
  if (lhs.locale < rhs.locale)
    return true;
  if (rhs.locale < lhs.locale)
    return false;
  if (lhs.permanent_country_code < rhs.permanent_country_code)
    return true;
  if (rhs.permanent_country_code < lhs.permanent_country_code)
    return false;
  if (lhs.session_country_code < rhs.session_country_code)
    return true;
  if (rhs.session_country_code < lhs.session_country_code)
    return false;
  if (lhs.system_requirement_met < rhs.system_requirement_met)
    return true;
  if (rhs.system_requirement_met < lhs.system_requirement_met)
    return false;
  if (lhs.os_version_supported < rhs.os_version_supported)
    return true;
  if (rhs.os_version_supported < lhs.os_version_supported)
    return false;
  if (lhs.anchor_entrypoint_override_active < rhs.anchor_entrypoint_override_active)
    return true;
  if (rhs.anchor_entrypoint_override_active < lhs.anchor_entrypoint_override_active)
    return false;
  if (lhs.primary_account_needs_signed_in < rhs.primary_account_needs_signed_in)
    return true;
  if (rhs.primary_account_needs_signed_in < lhs.primary_account_needs_signed_in)
    return false;
  if (lhs.dogfood_status < rhs.dogfood_status)
    return true;
  if (rhs.dogfood_status < lhs.dogfood_status)
    return false;
  return false;
}
template <typename StructPtrType>
ScreenshotTestKeyConfigurationPtr ScreenshotTestKeyConfiguration::Clone() const {
  return New(
      mojo::Clone(public_key),
      mojo::Clone(auth_secret)
  );
}

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

template <typename T, ScreenshotTestKeyConfiguration::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.public_key < rhs.public_key)
    return true;
  if (rhs.public_key < lhs.public_key)
    return false;
  if (lhs.auth_secret < rhs.auth_secret)
    return true;
  if (rhs.auth_secret < lhs.auth_secret)
    return false;
  return false;
}
template <typename StructPtrType>
TriggerInvokeFromInternalsOptionsPtr TriggerInvokeFromInternalsOptions::Clone() const {
  return New(
      mojo::Clone(invocation_source),
      mojo::Clone(prompts),
      mojo::Clone(additional_context),
      mojo::Clone(conversation),
      mojo::Clone(feature_mode),
      mojo::Clone(disable_zss),
      mojo::Clone(zss_config),
      mojo::Clone(skill_id),
      mojo::Clone(error_message),
      mojo::Clone(timeout),
      mojo::Clone(auto_submit),
      mojo::Clone(fre_override),
      mojo::Clone(wait_for_panel_open),
      mojo::Clone(focus_on_show),
      mojo::Clone(fre_completion_wait_mode),
      mojo::Clone(show_panel),
      mojo::Clone(surface),
      mojo::Clone(specific_tab_index),
      mojo::Clone(specific_tabs_to_share_indices),
      mojo::Clone(actuation_target),
      mojo::Clone(payload),
      mojo::Clone(take_screenshot),
      mojo::Clone(key_config),
      mojo::Clone(supersede_if_in_progress)
  );
}

template <typename T, TriggerInvokeFromInternalsOptions::EnableIfSame<T>*>
bool TriggerInvokeFromInternalsOptions::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->additional_context, other_struct.additional_context))
    return false;
  if (!mojo::Equals(this->conversation, other_struct.conversation))
    return false;
  if (!mojo::Equals(this->feature_mode, other_struct.feature_mode))
    return false;
  if (!mojo::Equals(this->disable_zss, other_struct.disable_zss))
    return false;
  if (!mojo::Equals(this->zss_config, other_struct.zss_config))
    return false;
  if (!mojo::Equals(this->skill_id, other_struct.skill_id))
    return false;
  if (!mojo::Equals(this->error_message, other_struct.error_message))
    return false;
  if (!mojo::Equals(this->timeout, other_struct.timeout))
    return false;
  if (!mojo::Equals(this->auto_submit, other_struct.auto_submit))
    return false;
  if (!mojo::Equals(this->fre_override, other_struct.fre_override))
    return false;
  if (!mojo::Equals(this->wait_for_panel_open, other_struct.wait_for_panel_open))
    return false;
  if (!mojo::Equals(this->focus_on_show, other_struct.focus_on_show))
    return false;
  if (!mojo::Equals(this->fre_completion_wait_mode, other_struct.fre_completion_wait_mode))
    return false;
  if (!mojo::Equals(this->show_panel, other_struct.show_panel))
    return false;
  if (!mojo::Equals(this->surface, other_struct.surface))
    return false;
  if (!mojo::Equals(this->specific_tab_index, other_struct.specific_tab_index))
    return false;
  if (!mojo::Equals(this->specific_tabs_to_share_indices, other_struct.specific_tabs_to_share_indices))
    return false;
  if (!mojo::Equals(this->actuation_target, other_struct.actuation_target))
    return false;
  if (!mojo::Equals(this->payload, other_struct.payload))
    return false;
  if (!mojo::Equals(this->take_screenshot, other_struct.take_screenshot))
    return false;
  if (!mojo::Equals(this->key_config, other_struct.key_config))
    return false;
  if (!mojo::Equals(this->supersede_if_in_progress, other_struct.supersede_if_in_progress))
    return false;
  return true;
}

template <typename T, TriggerInvokeFromInternalsOptions::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.additional_context < rhs.additional_context)
    return true;
  if (rhs.additional_context < lhs.additional_context)
    return false;
  if (lhs.conversation < rhs.conversation)
    return true;
  if (rhs.conversation < lhs.conversation)
    return false;
  if (lhs.feature_mode < rhs.feature_mode)
    return true;
  if (rhs.feature_mode < lhs.feature_mode)
    return false;
  if (lhs.disable_zss < rhs.disable_zss)
    return true;
  if (rhs.disable_zss < lhs.disable_zss)
    return false;
  if (lhs.zss_config < rhs.zss_config)
    return true;
  if (rhs.zss_config < lhs.zss_config)
    return false;
  if (lhs.skill_id < rhs.skill_id)
    return true;
  if (rhs.skill_id < lhs.skill_id)
    return false;
  if (lhs.error_message < rhs.error_message)
    return true;
  if (rhs.error_message < lhs.error_message)
    return false;
  if (lhs.timeout < rhs.timeout)
    return true;
  if (rhs.timeout < lhs.timeout)
    return false;
  if (lhs.auto_submit < rhs.auto_submit)
    return true;
  if (rhs.auto_submit < lhs.auto_submit)
    return false;
  if (lhs.fre_override < rhs.fre_override)
    return true;
  if (rhs.fre_override < lhs.fre_override)
    return false;
  if (lhs.wait_for_panel_open < rhs.wait_for_panel_open)
    return true;
  if (rhs.wait_for_panel_open < lhs.wait_for_panel_open)
    return false;
  if (lhs.focus_on_show < rhs.focus_on_show)
    return true;
  if (rhs.focus_on_show < lhs.focus_on_show)
    return false;
  if (lhs.fre_completion_wait_mode < rhs.fre_completion_wait_mode)
    return true;
  if (rhs.fre_completion_wait_mode < lhs.fre_completion_wait_mode)
    return false;
  if (lhs.show_panel < rhs.show_panel)
    return true;
  if (rhs.show_panel < lhs.show_panel)
    return false;
  if (lhs.surface < rhs.surface)
    return true;
  if (rhs.surface < lhs.surface)
    return false;
  if (lhs.specific_tab_index < rhs.specific_tab_index)
    return true;
  if (rhs.specific_tab_index < lhs.specific_tab_index)
    return false;
  if (lhs.specific_tabs_to_share_indices < rhs.specific_tabs_to_share_indices)
    return true;
  if (rhs.specific_tabs_to_share_indices < lhs.specific_tabs_to_share_indices)
    return false;
  if (lhs.actuation_target < rhs.actuation_target)
    return true;
  if (rhs.actuation_target < lhs.actuation_target)
    return false;
  if (lhs.payload < rhs.payload)
    return true;
  if (rhs.payload < lhs.payload)
    return false;
  if (lhs.take_screenshot < rhs.take_screenshot)
    return true;
  if (rhs.take_screenshot < lhs.take_screenshot)
    return false;
  if (lhs.key_config < rhs.key_config)
    return true;
  if (rhs.key_config < lhs.key_config)
    return false;
  if (lhs.supersede_if_in_progress < rhs.supersede_if_in_progress)
    return true;
  if (rhs.supersede_if_in_progress < lhs.supersede_if_in_progress)
    return false;
  return false;
}


}  // glic::mojom

namespace mojo {


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

  static decltype(::glic::mojom::TieredRolloutInfo::ai_subscription_tier) ai_subscription_tier(
      const ::glic::mojom::TieredRolloutInfoPtr& input) {
    return input->ai_subscription_tier;
  }

  static decltype(::glic::mojom::TieredRolloutInfo::is_eligible_for_tiered_rollout_v1) is_eligible_for_tiered_rollout_v1(
      const ::glic::mojom::TieredRolloutInfoPtr& input) {
    return input->is_eligible_for_tiered_rollout_v1;
  }

  static decltype(::glic::mojom::TieredRolloutInfo::is_eligible_for_tiered_rollout_v2) is_eligible_for_tiered_rollout_v2(
      const ::glic::mojom::TieredRolloutInfoPtr& input) {
    return input->is_eligible_for_tiered_rollout_v2;
  }

  static decltype(::glic::mojom::TieredRolloutInfo::is_eligible_overall) is_eligible_overall(
      const ::glic::mojom::TieredRolloutInfoPtr& input) {
    return input->is_eligible_overall;
  }

  static decltype(::glic::mojom::TieredRolloutInfo::glic_rollout_eligibility_pref) glic_rollout_eligibility_pref(
      const ::glic::mojom::TieredRolloutInfoPtr& input) {
    return input->glic_rollout_eligibility_pref;
  }

  static const decltype(::glic::mojom::TieredRolloutInfo::tiered_rollout_v2_eligible_tiers)& tiered_rollout_v2_eligible_tiers(
      const ::glic::mojom::TieredRolloutInfoPtr& input) {
    return input->tiered_rollout_v2_eligible_tiers;
  }

  static const decltype(::glic::mojom::TieredRolloutInfo::preference_sync_status)& preference_sync_status(
      const ::glic::mojom::TieredRolloutInfoPtr& input) {
    return input->preference_sync_status;
  }

  static bool Read(::glic::mojom::TieredRolloutInfo::DataView input, ::glic::mojom::TieredRolloutInfoPtr* output);
};


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

  static const decltype(::glic::mojom::InternalsDataPayload::enablement)& enablement(
      const ::glic::mojom::InternalsDataPayloadPtr& input) {
    return input->enablement;
  }

  static const decltype(::glic::mojom::InternalsDataPayload::config)& config(
      const ::glic::mojom::InternalsDataPayloadPtr& input) {
    return input->config;
  }

  static decltype(::glic::mojom::InternalsDataPayload::show_error_allowed) show_error_allowed(
      const ::glic::mojom::InternalsDataPayloadPtr& input) {
    return input->show_error_allowed;
  }

  static decltype(::glic::mojom::InternalsDataPayload::experimental_triggering_enabled) experimental_triggering_enabled(
      const ::glic::mojom::InternalsDataPayloadPtr& input) {
    return input->experimental_triggering_enabled;
  }

  static const decltype(::glic::mojom::InternalsDataPayload::debug_info)& debug_info(
      const ::glic::mojom::InternalsDataPayloadPtr& input) {
    return input->debug_info;
  }

  static const decltype(::glic::mojom::InternalsDataPayload::tiered_rollout_info)& tiered_rollout_info(
      const ::glic::mojom::InternalsDataPayloadPtr& input) {
    return input->tiered_rollout_info;
  }

  static bool Read(::glic::mojom::InternalsDataPayload::DataView input, ::glic::mojom::InternalsDataPayloadPtr* output);
};


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

  static decltype(::glic::mojom::InternalsDebugInfo::glic_actor_feature_enabled) glic_actor_feature_enabled(
      const ::glic::mojom::InternalsDebugInfoPtr& input) {
    return input->glic_actor_feature_enabled;
  }

  static decltype(::glic::mojom::InternalsDebugInfo::glic_rollout_feature_enabled) glic_rollout_feature_enabled(
      const ::glic::mojom::InternalsDebugInfoPtr& input) {
    return input->glic_rollout_feature_enabled;
  }

  static decltype(::glic::mojom::InternalsDebugInfo::glic_tiered_rollout_feature_enabled) glic_tiered_rollout_feature_enabled(
      const ::glic::mojom::InternalsDebugInfoPtr& input) {
    return input->glic_tiered_rollout_feature_enabled;
  }

  static decltype(::glic::mojom::InternalsDebugInfo::glic_tiered_rollout_v2_feature_enabled) glic_tiered_rollout_v2_feature_enabled(
      const ::glic::mojom::InternalsDebugInfoPtr& input) {
    return input->glic_tiered_rollout_v2_feature_enabled;
  }

  static decltype(::glic::mojom::InternalsDebugInfo::platform) platform(
      const ::glic::mojom::InternalsDebugInfoPtr& input) {
    return input->platform;
  }

  static decltype(::glic::mojom::InternalsDebugInfo::form_factor) form_factor(
      const ::glic::mojom::InternalsDebugInfoPtr& input) {
    return input->form_factor;
  }

  static const decltype(::glic::mojom::InternalsDebugInfo::boolean_settings)& boolean_settings(
      const ::glic::mojom::InternalsDebugInfoPtr& input) {
    return input->boolean_settings;
  }

  static const decltype(::glic::mojom::InternalsDebugInfo::hotkey)& hotkey(
      const ::glic::mojom::InternalsDebugInfoPtr& input) {
    return input->hotkey;
  }

  static const decltype(::glic::mojom::InternalsDebugInfo::locale)& locale(
      const ::glic::mojom::InternalsDebugInfoPtr& input) {
    return input->locale;
  }

  static const decltype(::glic::mojom::InternalsDebugInfo::permanent_country_code)& permanent_country_code(
      const ::glic::mojom::InternalsDebugInfoPtr& input) {
    return input->permanent_country_code;
  }

  static const decltype(::glic::mojom::InternalsDebugInfo::session_country_code)& session_country_code(
      const ::glic::mojom::InternalsDebugInfoPtr& input) {
    return input->session_country_code;
  }

  static decltype(::glic::mojom::InternalsDebugInfo::system_requirement_met) system_requirement_met(
      const ::glic::mojom::InternalsDebugInfoPtr& input) {
    return input->system_requirement_met;
  }

  static decltype(::glic::mojom::InternalsDebugInfo::os_version_supported) os_version_supported(
      const ::glic::mojom::InternalsDebugInfoPtr& input) {
    return input->os_version_supported;
  }

  static decltype(::glic::mojom::InternalsDebugInfo::anchor_entrypoint_override_active) anchor_entrypoint_override_active(
      const ::glic::mojom::InternalsDebugInfoPtr& input) {
    return input->anchor_entrypoint_override_active;
  }

  static decltype(::glic::mojom::InternalsDebugInfo::primary_account_needs_signed_in) primary_account_needs_signed_in(
      const ::glic::mojom::InternalsDebugInfoPtr& input) {
    return input->primary_account_needs_signed_in;
  }

  static const decltype(::glic::mojom::InternalsDebugInfo::dogfood_status)& dogfood_status(
      const ::glic::mojom::InternalsDebugInfoPtr& input) {
    return input->dogfood_status;
  }

  static bool Read(::glic::mojom::InternalsDebugInfo::DataView input, ::glic::mojom::InternalsDebugInfoPtr* output);
};


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

  static const decltype(::glic::mojom::ScreenshotTestKeyConfiguration::public_key)& public_key(
      const ::glic::mojom::ScreenshotTestKeyConfigurationPtr& input) {
    return input->public_key;
  }

  static const decltype(::glic::mojom::ScreenshotTestKeyConfiguration::auth_secret)& auth_secret(
      const ::glic::mojom::ScreenshotTestKeyConfigurationPtr& input) {
    return input->auth_secret;
  }

  static bool Read(::glic::mojom::ScreenshotTestKeyConfiguration::DataView input, ::glic::mojom::ScreenshotTestKeyConfigurationPtr* output);
};


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

  static decltype(::glic::mojom::TriggerInvokeFromInternalsOptions::invocation_source) invocation_source(
      const ::glic::mojom::TriggerInvokeFromInternalsOptionsPtr& input) {
    return input->invocation_source;
  }

  static const decltype(::glic::mojom::TriggerInvokeFromInternalsOptions::prompts)& prompts(
      const ::glic::mojom::TriggerInvokeFromInternalsOptionsPtr& input) {
    return input->prompts;
  }

  static  decltype(::glic::mojom::TriggerInvokeFromInternalsOptions::additional_context)& additional_context(
       ::glic::mojom::TriggerInvokeFromInternalsOptionsPtr& input) {
    return input->additional_context;
  }

  static const decltype(::glic::mojom::TriggerInvokeFromInternalsOptions::conversation)& conversation(
      const ::glic::mojom::TriggerInvokeFromInternalsOptionsPtr& input) {
    return input->conversation;
  }

  static decltype(::glic::mojom::TriggerInvokeFromInternalsOptions::feature_mode) feature_mode(
      const ::glic::mojom::TriggerInvokeFromInternalsOptionsPtr& input) {
    return input->feature_mode;
  }

  static decltype(::glic::mojom::TriggerInvokeFromInternalsOptions::disable_zss) disable_zss(
      const ::glic::mojom::TriggerInvokeFromInternalsOptionsPtr& input) {
    return input->disable_zss;
  }

  static const decltype(::glic::mojom::TriggerInvokeFromInternalsOptions::zss_config)& zss_config(
      const ::glic::mojom::TriggerInvokeFromInternalsOptionsPtr& input) {
    return input->zss_config;
  }

  static const decltype(::glic::mojom::TriggerInvokeFromInternalsOptions::skill_id)& skill_id(
      const ::glic::mojom::TriggerInvokeFromInternalsOptionsPtr& input) {
    return input->skill_id;
  }

  static const decltype(::glic::mojom::TriggerInvokeFromInternalsOptions::error_message)& error_message(
      const ::glic::mojom::TriggerInvokeFromInternalsOptionsPtr& input) {
    return input->error_message;
  }

  static const decltype(::glic::mojom::TriggerInvokeFromInternalsOptions::timeout)& timeout(
      const ::glic::mojom::TriggerInvokeFromInternalsOptionsPtr& input) {
    return input->timeout;
  }

  static decltype(::glic::mojom::TriggerInvokeFromInternalsOptions::auto_submit) auto_submit(
      const ::glic::mojom::TriggerInvokeFromInternalsOptionsPtr& input) {
    return input->auto_submit;
  }

  static decltype(::glic::mojom::TriggerInvokeFromInternalsOptions::fre_override) fre_override(
      const ::glic::mojom::TriggerInvokeFromInternalsOptionsPtr& input) {
    return input->fre_override;
  }

  static decltype(::glic::mojom::TriggerInvokeFromInternalsOptions::wait_for_panel_open) wait_for_panel_open(
      const ::glic::mojom::TriggerInvokeFromInternalsOptionsPtr& input) {
    return input->wait_for_panel_open;
  }

  static decltype(::glic::mojom::TriggerInvokeFromInternalsOptions::focus_on_show) focus_on_show(
      const ::glic::mojom::TriggerInvokeFromInternalsOptionsPtr& input) {
    return input->focus_on_show;
  }

  static decltype(::glic::mojom::TriggerInvokeFromInternalsOptions::fre_completion_wait_mode) fre_completion_wait_mode(
      const ::glic::mojom::TriggerInvokeFromInternalsOptionsPtr& input) {
    return input->fre_completion_wait_mode;
  }

  static decltype(::glic::mojom::TriggerInvokeFromInternalsOptions::show_panel) show_panel(
      const ::glic::mojom::TriggerInvokeFromInternalsOptionsPtr& input) {
    return input->show_panel;
  }

  static const decltype(::glic::mojom::TriggerInvokeFromInternalsOptions::surface)& surface(
      const ::glic::mojom::TriggerInvokeFromInternalsOptionsPtr& input) {
    return input->surface;
  }

  static decltype(::glic::mojom::TriggerInvokeFromInternalsOptions::specific_tab_index) specific_tab_index(
      const ::glic::mojom::TriggerInvokeFromInternalsOptionsPtr& input) {
    return input->specific_tab_index;
  }

  static const decltype(::glic::mojom::TriggerInvokeFromInternalsOptions::specific_tabs_to_share_indices)& specific_tabs_to_share_indices(
      const ::glic::mojom::TriggerInvokeFromInternalsOptionsPtr& input) {
    return input->specific_tabs_to_share_indices;
  }

  static decltype(::glic::mojom::TriggerInvokeFromInternalsOptions::actuation_target) actuation_target(
      const ::glic::mojom::TriggerInvokeFromInternalsOptionsPtr& input) {
    return input->actuation_target;
  }

  static const decltype(::glic::mojom::TriggerInvokeFromInternalsOptions::payload)& payload(
      const ::glic::mojom::TriggerInvokeFromInternalsOptionsPtr& input) {
    return input->payload;
  }

  static decltype(::glic::mojom::TriggerInvokeFromInternalsOptions::take_screenshot) take_screenshot(
      const ::glic::mojom::TriggerInvokeFromInternalsOptionsPtr& input) {
    return input->take_screenshot;
  }

  static const decltype(::glic::mojom::TriggerInvokeFromInternalsOptions::key_config)& key_config(
      const ::glic::mojom::TriggerInvokeFromInternalsOptionsPtr& input) {
    return input->key_config;
  }

  static decltype(::glic::mojom::TriggerInvokeFromInternalsOptions::supersede_if_in_progress) supersede_if_in_progress(
      const ::glic::mojom::TriggerInvokeFromInternalsOptionsPtr& input) {
    return input->supersede_if_in_progress;
  }

  static bool Read(::glic::mojom::TriggerInvokeFromInternalsOptions::DataView input, ::glic::mojom::TriggerInvokeFromInternalsOptionsPtr* output);
};

}  // namespace mojo

#endif  // CHROME_BROWSER_GLIC_HOST_GLIC_INTERNALS_MOJOM_H_