// chrome/browser/glic/host/glic_internals.mojom-data-view.h is auto generated by mojom_bindings_generator.py, do not edit

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

// This file defines XDataView for type traits and can be included in
// _mojom_traits.h definitions but otherwise please use .mojom-forward.h,
// .mojom-shared.h or .mojom.h.

// IWYU pragma: private
// IWYU pragma: friend "traits"

#ifndef CHROME_BROWSER_GLIC_HOST_GLIC_INTERNALS_MOJOM_DATA_VIEW_H_
#define CHROME_BROWSER_GLIC_HOST_GLIC_INTERNALS_MOJOM_DATA_VIEW_H_

#include <stdint.h>

#include <functional>
#include <iosfwd>
#include <type_traits>
#include <utility>
#include "mojo/public/cpp/bindings/array_data_view.h"
#include "mojo/public/cpp/bindings/string_data_view.h"
#include "mojo/public/cpp/bindings/lib/serialization.h"

#include "chrome/browser/glic/host/glic_internals.mojom-shared-internal.h"
#include "chrome/browser/glic/host/glic.mojom-shared.h"
#include "chrome/common/glic_enums.mojom-shared.h"
#include "mojo/public/mojom/base/time.mojom-shared.h"
#include "url/mojom/url.mojom-shared.h"


namespace glic::mojom {
class TieredRolloutInfoDataView;

class InternalsDataPayloadDataView;

class InternalsDebugInfoDataView;

class ScreenshotTestKeyConfigurationDataView;

class TriggerInvokeFromInternalsOptionsDataView;



}  // glic::mojom


namespace mojo {
namespace internal {

template <>
struct MojomTypeTraits<::glic::mojom::TieredRolloutInfoDataView> {
  using Data = ::glic::mojom::internal::TieredRolloutInfo_Data;
  using DataAsArrayElement = Pointer<Data>;
  static constexpr MojomTypeCategory category = MojomTypeCategory::kStruct;
};

template <>
struct MojomTypeTraits<::glic::mojom::InternalsDataPayloadDataView> {
  using Data = ::glic::mojom::internal::InternalsDataPayload_Data;
  using DataAsArrayElement = Pointer<Data>;
  static constexpr MojomTypeCategory category = MojomTypeCategory::kStruct;
};

template <>
struct MojomTypeTraits<::glic::mojom::InternalsDebugInfoDataView> {
  using Data = ::glic::mojom::internal::InternalsDebugInfo_Data;
  using DataAsArrayElement = Pointer<Data>;
  static constexpr MojomTypeCategory category = MojomTypeCategory::kStruct;
};

template <>
struct MojomTypeTraits<::glic::mojom::ScreenshotTestKeyConfigurationDataView> {
  using Data = ::glic::mojom::internal::ScreenshotTestKeyConfiguration_Data;
  using DataAsArrayElement = Pointer<Data>;
  static constexpr MojomTypeCategory category = MojomTypeCategory::kStruct;
};

template <>
struct MojomTypeTraits<::glic::mojom::TriggerInvokeFromInternalsOptionsDataView> {
  using Data = ::glic::mojom::internal::TriggerInvokeFromInternalsOptions_Data;
  using DataAsArrayElement = Pointer<Data>;
  static constexpr MojomTypeCategory category = MojomTypeCategory::kStruct;
};

}  // namespace internal
}  // namespace mojo


namespace glic::mojom {


enum class FreCompletionWaitMode : int32_t {
  
  kDefault = 0,
  
  kNever = 1,
  kMinValue = 0,
  kMaxValue = 1,
};

 std::ostream& operator<<(std::ostream& os, FreCompletionWaitMode value);
inline bool IsKnownEnumValue(FreCompletionWaitMode value) {
  return internal::FreCompletionWaitMode_Data::IsKnownValue(
      static_cast<int32_t>(value));
}

// Returns true if the enum has an infallible conversion from the mojom enum.
consteval bool HasInfallibleConversion(FreCompletionWaitMode) {
  return true;
}
// Interface base classes. They are used for type safety check.
class InternalsPageHandlerInterfaceBase {};

using InternalsPageHandlerPtrDataView =
    mojo::InterfacePtrDataView<InternalsPageHandlerInterfaceBase>;
using InternalsPageHandlerRequestDataView =
    mojo::InterfaceRequestDataView<InternalsPageHandlerInterfaceBase>;
using InternalsPageHandlerAssociatedPtrInfoDataView =
    mojo::AssociatedInterfacePtrInfoDataView<InternalsPageHandlerInterfaceBase>;
using InternalsPageHandlerAssociatedRequestDataView =
    mojo::AssociatedInterfaceRequestDataView<InternalsPageHandlerInterfaceBase>;
class InternalsPageHandlerFactoryInterfaceBase {};

using InternalsPageHandlerFactoryPtrDataView =
    mojo::InterfacePtrDataView<InternalsPageHandlerFactoryInterfaceBase>;
using InternalsPageHandlerFactoryRequestDataView =
    mojo::InterfaceRequestDataView<InternalsPageHandlerFactoryInterfaceBase>;
using InternalsPageHandlerFactoryAssociatedPtrInfoDataView =
    mojo::AssociatedInterfacePtrInfoDataView<InternalsPageHandlerFactoryInterfaceBase>;
using InternalsPageHandlerFactoryAssociatedRequestDataView =
    mojo::AssociatedInterfaceRequestDataView<InternalsPageHandlerFactoryInterfaceBase>;


class TieredRolloutInfoDataView {
 public:
  TieredRolloutInfoDataView() = default;

  TieredRolloutInfoDataView(
      internal::TieredRolloutInfo_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  std::optional<int32_t> ai_subscription_tier() const {

    return data_->ai_subscription_tier_$flag
        ? std::make_optional(data_->ai_subscription_tier_$value)
        : std::nullopt;
  }
  bool is_eligible_for_tiered_rollout_v1() const {
    return data_->is_eligible_for_tiered_rollout_v1;
  }
  bool is_eligible_for_tiered_rollout_v2() const {
    return data_->is_eligible_for_tiered_rollout_v2;
  }
  bool is_eligible_overall() const {
    return data_->is_eligible_overall;
  }
  bool glic_rollout_eligibility_pref() const {
    return data_->glic_rollout_eligibility_pref;
  }
  inline void GetTieredRolloutV2EligibleTiersDataView(
      mojo::StringDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadTieredRolloutV2EligibleTiers(UserType* output) {
    
    auto* pointer = data_->tiered_rollout_v2_eligible_tiers.Get();
    return mojo::internal::Deserialize<mojo::StringDataView>(
        pointer, output, message_);
  }
  inline void GetPreferenceSyncStatusDataView(
      mojo::StringDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadPreferenceSyncStatus(UserType* output) {
    
    auto* pointer = data_->preference_sync_status.Get();
    return mojo::internal::Deserialize<mojo::StringDataView>(
        pointer, output, message_);
  }
 private:
  internal::TieredRolloutInfo_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class InternalsDataPayloadDataView {
 public:
  InternalsDataPayloadDataView() = default;

  InternalsDataPayloadDataView(
      internal::InternalsDataPayload_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  inline void GetEnablementDataView(
      ::glic::mojom::ProfileEnablementDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadEnablement(UserType* output) {
    
    auto* pointer = data_->enablement.Get();
    return mojo::internal::Deserialize<::glic::mojom::ProfileEnablementDataView>(
        pointer, output, message_);
  }
  inline void GetConfigDataView(
      ::glic::mojom::ConfigInfoDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadConfig(UserType* output) {
    
    auto* pointer = data_->config.Get();
    return mojo::internal::Deserialize<::glic::mojom::ConfigInfoDataView>(
        pointer, output, message_);
  }
  bool show_error_allowed() const {
    return data_->show_error_allowed;
  }
  bool experimental_triggering_enabled() const {
    return data_->experimental_triggering_enabled;
  }
  inline void GetDebugInfoDataView(
      InternalsDebugInfoDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadDebugInfo(UserType* output) {
    
    auto* pointer = data_->debug_info.Get();
    return mojo::internal::Deserialize<::glic::mojom::InternalsDebugInfoDataView>(
        pointer, output, message_);
  }
  inline void GetTieredRolloutInfoDataView(
      TieredRolloutInfoDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadTieredRolloutInfo(UserType* output) {
    
    auto* pointer = data_->tiered_rollout_info.Get();
    return mojo::internal::Deserialize<::glic::mojom::TieredRolloutInfoDataView>(
        pointer, output, message_);
  }
 private:
  internal::InternalsDataPayload_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class InternalsDebugInfoDataView {
 public:
  InternalsDebugInfoDataView() = default;

  InternalsDebugInfoDataView(
      internal::InternalsDebugInfo_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  bool glic_actor_feature_enabled() const {
    return data_->glic_actor_feature_enabled;
  }
  bool glic_rollout_feature_enabled() const {
    return data_->glic_rollout_feature_enabled;
  }
  bool glic_tiered_rollout_feature_enabled() const {
    return data_->glic_tiered_rollout_feature_enabled;
  }
  bool glic_tiered_rollout_v2_feature_enabled() const {
    return data_->glic_tiered_rollout_v2_feature_enabled;
  }
  template <typename UserType>
  [[nodiscard]] bool ReadPlatform(UserType* output) const {
    auto data_value = data_->platform;
    return mojo::internal::Deserialize<::glic::mojom::Platform>(
        data_value, output);
  }
  ::glic::mojom::Platform platform() const {
    return ::mojo::internal::ToKnownEnumValueHelper(
          static_cast<::glic::mojom::Platform>(data_->platform));
  }
  template <typename UserType>
  [[nodiscard]] bool ReadFormFactor(UserType* output) const {
    auto data_value = data_->form_factor;
    return mojo::internal::Deserialize<::glic::mojom::FormFactor>(
        data_value, output);
  }
  ::glic::mojom::FormFactor form_factor() const {
    return ::mojo::internal::ToKnownEnumValueHelper(
          static_cast<::glic::mojom::FormFactor>(data_->form_factor));
  }
  inline void GetBooleanSettingsDataView(
      mojo::MapDataView<mojo::StringDataView, bool>* output);

  template <typename UserType>
  [[nodiscard]] bool ReadBooleanSettings(UserType* output) {
    
    auto* pointer = data_->boolean_settings.Get();
    return mojo::internal::Deserialize<mojo::MapDataView<mojo::StringDataView, bool>>(
        pointer, output, message_);
  }
  inline void GetHotkeyDataView(
      mojo::StringDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadHotkey(UserType* output) {
    
    auto* pointer = data_->hotkey.Get();
    return mojo::internal::Deserialize<mojo::StringDataView>(
        pointer, output, message_);
  }
  inline void GetLocaleDataView(
      mojo::StringDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadLocale(UserType* output) {
    
    auto* pointer = data_->locale.Get();
    return mojo::internal::Deserialize<mojo::StringDataView>(
        pointer, output, message_);
  }
  inline void GetPermanentCountryCodeDataView(
      mojo::StringDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadPermanentCountryCode(UserType* output) {
    
    auto* pointer = data_->permanent_country_code.Get();
    return mojo::internal::Deserialize<mojo::StringDataView>(
        pointer, output, message_);
  }
  inline void GetSessionCountryCodeDataView(
      mojo::StringDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadSessionCountryCode(UserType* output) {
    
    auto* pointer = data_->session_country_code.Get();
    return mojo::internal::Deserialize<mojo::StringDataView>(
        pointer, output, message_);
  }
  bool system_requirement_met() const {
    return data_->system_requirement_met;
  }
  bool os_version_supported() const {
    return data_->os_version_supported;
  }
  bool anchor_entrypoint_override_active() const {
    return data_->anchor_entrypoint_override_active;
  }
  bool primary_account_needs_signed_in() const {
    return data_->primary_account_needs_signed_in;
  }
  inline void GetDogfoodStatusDataView(
      mojo::StringDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadDogfoodStatus(UserType* output) {
    
    auto* pointer = data_->dogfood_status.Get();
    return mojo::internal::Deserialize<mojo::StringDataView>(
        pointer, output, message_);
  }
 private:
  internal::InternalsDebugInfo_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class ScreenshotTestKeyConfigurationDataView {
 public:
  ScreenshotTestKeyConfigurationDataView() = default;

  ScreenshotTestKeyConfigurationDataView(
      internal::ScreenshotTestKeyConfiguration_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  inline void GetPublicKeyDataView(
      mojo::StringDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadPublicKey(UserType* output) {
    
    auto* pointer = data_->public_key.Get();
    return mojo::internal::Deserialize<mojo::StringDataView>(
        pointer, output, message_);
  }
  inline void GetAuthSecretDataView(
      mojo::StringDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadAuthSecret(UserType* output) {
    
    auto* pointer = data_->auth_secret.Get();
    return mojo::internal::Deserialize<mojo::StringDataView>(
        pointer, output, message_);
  }
 private:
  internal::ScreenshotTestKeyConfiguration_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class TriggerInvokeFromInternalsOptionsDataView {
 public:
  TriggerInvokeFromInternalsOptionsDataView() = default;

  TriggerInvokeFromInternalsOptionsDataView(
      internal::TriggerInvokeFromInternalsOptions_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  template <typename UserType>
  [[nodiscard]] bool ReadInvocationSource(UserType* output) const {
    auto data_value = data_->invocation_source;
    return mojo::internal::Deserialize<::glic::mojom::InvocationSource>(
        data_value, output);
  }
  ::glic::mojom::InvocationSource invocation_source() const {
    return ::mojo::internal::ToKnownEnumValueHelper(
          static_cast<::glic::mojom::InvocationSource>(data_->invocation_source));
  }
  inline void GetPromptsDataView(
      mojo::ArrayDataView<mojo::StringDataView>* output);

  template <typename UserType>
  [[nodiscard]] bool ReadPrompts(UserType* output) {
    
    auto* pointer = data_->prompts.Get();
    return mojo::internal::Deserialize<mojo::ArrayDataView<mojo::StringDataView>>(
        pointer, output, message_);
  }
  inline void GetAdditionalContextDataView(
      ::glic::mojom::AdditionalContextDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadAdditionalContext(UserType* output) {
    
static_assert(
    mojo::internal::IsValidUserTypeForOptionalValue<
        ::glic::mojom::AdditionalContextDataView, UserType>(),
    "Attempting to read the optional `additional_context` field into a type which "
    "cannot represent a null value. Either wrap the destination object "
    "with std::optional, ensure that any corresponding "
    "{Struct/Union/Array/String}Traits define the necessary IsNull and "
    "SetToNull methods, or use `MaybeReadAdditionalContext` instead "
    "of `ReadAdditionalContext if you're fine with null values being "
    "silently ignored in this case.");
    auto* pointer = data_->additional_context.Get();
    return mojo::internal::Deserialize<::glic::mojom::AdditionalContextDataView>(
        pointer, output, message_);
  }
  inline void GetConversationDataView(
      ::glic::mojom::InvokeConversationSelectionDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadConversation(UserType* output) {
    
    auto* pointer = !data_->conversation.is_null() ? &data_->conversation : nullptr;
    return mojo::internal::Deserialize<::glic::mojom::InvokeConversationSelectionDataView>(
        pointer, output, message_);
  }
  template <typename UserType>
  [[nodiscard]] bool ReadFeatureMode(UserType* output) const {
    if (!data_->feature_mode_$flag) {
      *output = std::nullopt;
      return true;
    }

    return mojo::internal::Deserialize<::glic::mojom::FeatureMode>(
        data_->feature_mode_$value, &output->emplace());
  }
  std::optional<::glic::mojom::FeatureMode> feature_mode() const {
    if (!data_->feature_mode_$flag) {
      return std::nullopt;
    }
    return ::mojo::internal::ToKnownEnumValueHelper(
          static_cast<::glic::mojom::FeatureMode>(data_->feature_mode_$value));
  }
  bool disable_zss() const {
    return data_->disable_zss;
  }
  inline void GetZssConfigDataView(
      ::glic::mojom::ZssConfigDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadZssConfig(UserType* output) {
    
static_assert(
    mojo::internal::IsValidUserTypeForOptionalValue<
        ::glic::mojom::ZssConfigDataView, UserType>(),
    "Attempting to read the optional `zss_config` field into a type which "
    "cannot represent a null value. Either wrap the destination object "
    "with std::optional, ensure that any corresponding "
    "{Struct/Union/Array/String}Traits define the necessary IsNull and "
    "SetToNull methods, or use `MaybeReadZssConfig` instead "
    "of `ReadZssConfig if you're fine with null values being "
    "silently ignored in this case.");
    auto* pointer = data_->zss_config.Get();
    return mojo::internal::Deserialize<::glic::mojom::ZssConfigDataView>(
        pointer, output, message_);
  }
  inline void GetSkillIdDataView(
      mojo::StringDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadSkillId(UserType* output) {
    
static_assert(
    mojo::internal::IsValidUserTypeForOptionalValue<
        mojo::StringDataView, UserType>(),
    "Attempting to read the optional `skill_id` field into a type which "
    "cannot represent a null value. Either wrap the destination object "
    "with std::optional, ensure that any corresponding "
    "{Struct/Union/Array/String}Traits define the necessary IsNull and "
    "SetToNull methods, or use `MaybeReadSkillId` instead "
    "of `ReadSkillId if you're fine with null values being "
    "silently ignored in this case.");
    auto* pointer = data_->skill_id.Get();
    return mojo::internal::Deserialize<mojo::StringDataView>(
        pointer, output, message_);
  }
  inline void GetErrorMessageDataView(
      mojo::StringDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadErrorMessage(UserType* output) {
    
static_assert(
    mojo::internal::IsValidUserTypeForOptionalValue<
        mojo::StringDataView, UserType>(),
    "Attempting to read the optional `error_message` field into a type which "
    "cannot represent a null value. Either wrap the destination object "
    "with std::optional, ensure that any corresponding "
    "{Struct/Union/Array/String}Traits define the necessary IsNull and "
    "SetToNull methods, or use `MaybeReadErrorMessage` instead "
    "of `ReadErrorMessage if you're fine with null values being "
    "silently ignored in this case.");
    auto* pointer = data_->error_message.Get();
    return mojo::internal::Deserialize<mojo::StringDataView>(
        pointer, output, message_);
  }
  inline void GetTimeoutDataView(
      ::mojo_base::mojom::TimeDeltaDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadTimeout(UserType* output) {
    
static_assert(
    mojo::internal::IsValidUserTypeForOptionalValue<
        ::mojo_base::mojom::TimeDeltaDataView, UserType>(),
    "Attempting to read the optional `timeout` field into a type which "
    "cannot represent a null value. Either wrap the destination object "
    "with std::optional, ensure that any corresponding "
    "{Struct/Union/Array/String}Traits define the necessary IsNull and "
    "SetToNull methods, or use `MaybeReadTimeout` instead "
    "of `ReadTimeout if you're fine with null values being "
    "silently ignored in this case.");
    auto* pointer = data_->timeout.Get();
    return mojo::internal::Deserialize<::mojo_base::mojom::TimeDeltaDataView>(
        pointer, output, message_);
  }
  bool auto_submit() const {
    return data_->auto_submit;
  }
  template <typename UserType>
  [[nodiscard]] bool ReadFreOverride(UserType* output) const {
    auto data_value = data_->fre_override;
    return mojo::internal::Deserialize<::glic::mojom::FreOverride>(
        data_value, output);
  }
  ::glic::mojom::FreOverride fre_override() const {
    return ::mojo::internal::ToKnownEnumValueHelper(
          static_cast<::glic::mojom::FreOverride>(data_->fre_override));
  }
  bool wait_for_panel_open() const {
    return data_->wait_for_panel_open;
  }
  std::optional<bool> focus_on_show() const {

    return data_->focus_on_show_$flag
        ? std::make_optional(!!data_->focus_on_show_$value)
        : std::nullopt;
  }
  template <typename UserType>
  [[nodiscard]] bool ReadFreCompletionWaitMode(UserType* output) const {
    auto data_value = data_->fre_completion_wait_mode;
    return mojo::internal::Deserialize<::glic::mojom::FreCompletionWaitMode>(
        data_value, output);
  }
  FreCompletionWaitMode fre_completion_wait_mode() const {
    return ::mojo::internal::ToKnownEnumValueHelper(
          static_cast<::glic::mojom::FreCompletionWaitMode>(data_->fre_completion_wait_mode));
  }
  std::optional<bool> show_panel() const {

    return data_->show_panel_$flag
        ? std::make_optional(!!data_->show_panel_$value)
        : std::nullopt;
  }
  inline void GetSurfaceDataView(
      ::glic::mojom::InvokeTargetSurfaceDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadSurface(UserType* output) {
    
    auto* pointer = !data_->surface.is_null() ? &data_->surface : nullptr;
    return mojo::internal::Deserialize<::glic::mojom::InvokeTargetSurfaceDataView>(
        pointer, output, message_);
  }
  std::optional<int32_t> specific_tab_index() const {

    return data_->specific_tab_index_$flag
        ? std::make_optional(data_->specific_tab_index_$value)
        : std::nullopt;
  }
  inline void GetSpecificTabsToShareIndicesDataView(
      mojo::ArrayDataView<int32_t>* output);

  template <typename UserType>
  [[nodiscard]] bool ReadSpecificTabsToShareIndices(UserType* output) {
    
static_assert(
    mojo::internal::IsValidUserTypeForOptionalValue<
        mojo::ArrayDataView<int32_t>, UserType>(),
    "Attempting to read the optional `specific_tabs_to_share_indices` field into a type which "
    "cannot represent a null value. Either wrap the destination object "
    "with std::optional, ensure that any corresponding "
    "{Struct/Union/Array/String}Traits define the necessary IsNull and "
    "SetToNull methods, or use `MaybeReadSpecificTabsToShareIndices` instead "
    "of `ReadSpecificTabsToShareIndices if you're fine with null values being "
    "silently ignored in this case.");
    auto* pointer = data_->specific_tabs_to_share_indices.Get();
    return mojo::internal::Deserialize<mojo::ArrayDataView<int32_t>>(
        pointer, output, message_);
  }
  template <typename UserType>
  [[nodiscard]] bool ReadActuationTarget(UserType* output) const {
    auto data_value = data_->actuation_target;
    return mojo::internal::Deserialize<::glic::mojom::ActuationTarget>(
        data_value, output);
  }
  ::glic::mojom::ActuationTarget actuation_target() const {
    return ::mojo::internal::ToKnownEnumValueHelper(
          static_cast<::glic::mojom::ActuationTarget>(data_->actuation_target));
  }
  inline void GetPayloadDataView(
      ::glic::mojom::InvocationPayloadDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadPayload(UserType* output) {
    
static_assert(
    mojo::internal::IsValidUserTypeForOptionalValue<
        ::glic::mojom::InvocationPayloadDataView, UserType>(),
    "Attempting to read the optional `payload` field into a type which "
    "cannot represent a null value. Either wrap the destination object "
    "with std::optional, ensure that any corresponding "
    "{Struct/Union/Array/String}Traits define the necessary IsNull and "
    "SetToNull methods, or use `MaybeReadPayload` instead "
    "of `ReadPayload if you're fine with null values being "
    "silently ignored in this case.");
    auto* pointer = !data_->payload.is_null() ? &data_->payload : nullptr;
    return mojo::internal::Deserialize<::glic::mojom::InvocationPayloadDataView>(
        pointer, output, message_);
  }
  bool take_screenshot() const {
    return data_->take_screenshot;
  }
  inline void GetKeyConfigDataView(
      ScreenshotTestKeyConfigurationDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadKeyConfig(UserType* output) {
    
static_assert(
    mojo::internal::IsValidUserTypeForOptionalValue<
        ::glic::mojom::ScreenshotTestKeyConfigurationDataView, UserType>(),
    "Attempting to read the optional `key_config` field into a type which "
    "cannot represent a null value. Either wrap the destination object "
    "with std::optional, ensure that any corresponding "
    "{Struct/Union/Array/String}Traits define the necessary IsNull and "
    "SetToNull methods, or use `MaybeReadKeyConfig` instead "
    "of `ReadKeyConfig if you're fine with null values being "
    "silently ignored in this case.");
    auto* pointer = data_->key_config.Get();
    return mojo::internal::Deserialize<::glic::mojom::ScreenshotTestKeyConfigurationDataView>(
        pointer, output, message_);
  }
  bool supersede_if_in_progress() const {
    return data_->supersede_if_in_progress;
  }
 private:
  internal::TriggerInvokeFromInternalsOptions_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


}  // glic::mojom

#endif  // CHROME_BROWSER_GLIC_HOST_GLIC_INTERNALS_MOJOM_DATA_VIEW_H_