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


namespace glic::mojom {
class GeminiEnterpriseSettingsDataView;

class ProfileEnablementDataView;

class ConfigInfoDataView;

class DefaultConversationDataView;

class NewConversationDataView;

class DefaultSurfaceMojoDataView;

class NewTabMojoDataView;

class ZssConfigDataView;

class GetContextResultWithActionResultCodeDataView;

class UserProfileInfoDataView;

class SafeBrowsingVerdictDataView;

class CounterAbuseVerdictDataView;

class WebClientInitialStateDataView;

class ScreenshotCollectionOptionsDataView;

class TabContextOptionsDataView;

class GetPinCandidatesOptionsDataView;

class ScrollToParamsDataView;

class ScrollToTextSelectorDataView;

class ScrollToTextFragmentSelectorDataView;

class ScrollToNodeSelectorDataView;

class SuggestionContentDataView;

class SkillPreviewDataView;

class SkillDataView;

class CreateSkillRequestDataView;

class UpdateSkillRequestDataView;

class ZeroStateSuggestionsDataView;

class ZeroStateSuggestionsV2DataView;

class ZeroStateSuggestionsOptionsDataView;

class PinCandidateDataView;

class PinTabsOptionsDataView;

class UnpinTabsOptionsDataView;

class OpenPinnedTabPickerOptionsDataView;

class CreateActorTabOptionsDataView;

class CaptureRegionParamsDataView;

class ActivateTabOptionsDataView;

class CreateTabOptionsDataView;

class ConversationInfoDataView;

class PanelOpeningDataDataView;

class PanelStateDataView;

class SkillsPayloadDataView;

class UniversalCartPayloadDataView;

class InvokeOptionsDataView;

class OnResponseStoppedDetailsDataView;

class OpenPanelInfoDataView;

class ContextDataDataView;

class ParentConversationMetadataDataView;

class AdditionalContextDataView;

class ExperimentalTriggeringUpdateDataView;

class TabContextResultDataView;

class WebPageDataDataView;

class DocumentDataDataView;

class PdfDocumentDataDataView;

class TabDataDataView;

class NoFocusedTabDataDataView;

class AnnotatedPageDataDataView;

class ImageOriginAnnotationsDataView;

class JournalDataView;

class PendingCapturedRegionDataView;

class CaptureRegionResultDataView;

class ScreenshotDataView;

class ImageInfoDataView;

class ImageBytesResultDataView;

class OpenSettingsOptionsDataView;

class InvokeConversationSelectionDataView;
class InvokeTargetSurfaceDataView;
class GetContextResultDataView;
class CaptureScreenshotResultDataView;
class ScrollToSelectorDataView;
class InvocationPayloadDataView;
class AdditionalContextPartDataView;
class FocusedTabDataDataView;
class CapturedRegionDataView;
class GetImageBytesResultDataView;
class ActorHandler_CreateTask_ResponseParam_ResultDataView;
class ActorHandler_PerformActions_ResponseParam_ResultDataView;


}  // glic::mojom


namespace mojo {
namespace internal {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

template <>
struct MojomTypeTraits<::glic::mojom::InvokeConversationSelectionDataView> {
  using Data = ::glic::mojom::internal::InvokeConversationSelection_Data;
  using DataAsArrayElement = Data;
  static constexpr MojomTypeCategory category = MojomTypeCategory::kUnion;
};

template <>
struct MojomTypeTraits<::glic::mojom::InvokeTargetSurfaceDataView> {
  using Data = ::glic::mojom::internal::InvokeTargetSurface_Data;
  using DataAsArrayElement = Data;
  static constexpr MojomTypeCategory category = MojomTypeCategory::kUnion;
};

template <>
struct MojomTypeTraits<::glic::mojom::GetContextResultDataView> {
  using Data = ::glic::mojom::internal::GetContextResult_Data;
  using DataAsArrayElement = Data;
  static constexpr MojomTypeCategory category = MojomTypeCategory::kUnion;
};

template <>
struct MojomTypeTraits<::glic::mojom::CaptureScreenshotResultDataView> {
  using Data = ::glic::mojom::internal::CaptureScreenshotResult_Data;
  using DataAsArrayElement = Data;
  static constexpr MojomTypeCategory category = MojomTypeCategory::kUnion;
};

template <>
struct MojomTypeTraits<::glic::mojom::ScrollToSelectorDataView> {
  using Data = ::glic::mojom::internal::ScrollToSelector_Data;
  using DataAsArrayElement = Data;
  static constexpr MojomTypeCategory category = MojomTypeCategory::kUnion;
};

template <>
struct MojomTypeTraits<::glic::mojom::InvocationPayloadDataView> {
  using Data = ::glic::mojom::internal::InvocationPayload_Data;
  using DataAsArrayElement = Data;
  static constexpr MojomTypeCategory category = MojomTypeCategory::kUnion;
};

template <>
struct MojomTypeTraits<::glic::mojom::AdditionalContextPartDataView> {
  using Data = ::glic::mojom::internal::AdditionalContextPart_Data;
  using DataAsArrayElement = Data;
  static constexpr MojomTypeCategory category = MojomTypeCategory::kUnion;
};

template <>
struct MojomTypeTraits<::glic::mojom::FocusedTabDataDataView> {
  using Data = ::glic::mojom::internal::FocusedTabData_Data;
  using DataAsArrayElement = Data;
  static constexpr MojomTypeCategory category = MojomTypeCategory::kUnion;
};

template <>
struct MojomTypeTraits<::glic::mojom::CapturedRegionDataView> {
  using Data = ::glic::mojom::internal::CapturedRegion_Data;
  using DataAsArrayElement = Data;
  static constexpr MojomTypeCategory category = MojomTypeCategory::kUnion;
};

template <>
struct MojomTypeTraits<::glic::mojom::GetImageBytesResultDataView> {
  using Data = ::glic::mojom::internal::GetImageBytesResult_Data;
  using DataAsArrayElement = Data;
  static constexpr MojomTypeCategory category = MojomTypeCategory::kUnion;
};

template <>
struct MojomTypeTraits<::glic::mojom::ActorHandler_CreateTask_ResponseParam_ResultDataView> {
  using Data = ::glic::mojom::internal::ActorHandler_CreateTask_ResponseParam_Result_Data;
  using DataAsArrayElement = Data;
  static constexpr MojomTypeCategory category = MojomTypeCategory::kUnion;
};

template <>
struct MojomTypeTraits<::glic::mojom::ActorHandler_PerformActions_ResponseParam_ResultDataView> {
  using Data = ::glic::mojom::internal::ActorHandler_PerformActions_ResponseParam_Result_Data;
  using DataAsArrayElement = Data;
  static constexpr MojomTypeCategory category = MojomTypeCategory::kUnion;
};

}  // namespace internal
}  // namespace mojo


namespace glic::mojom {


enum class GlicExperimentalTriggeringState : int32_t {
  
  kUnavailable = 0,
  
  kNeedsOptIn = 1,
  
  kReady = 2,
  kMinValue = 0,
  kMaxValue = 2,
};

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

// Returns true if the enum has an infallible conversion from the mojom enum.
consteval bool HasInfallibleConversion(GlicExperimentalTriggeringState) {
  return true;
}


enum class FileUploadPolicyState : int32_t {
  
  kEnabled = 0,
  
  kDisabled = 1,
  kMinValue = 0,
  kMaxValue = 1,
};

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

// Returns true if the enum has an infallible conversion from the mojom enum.
consteval bool HasInfallibleConversion(FileUploadPolicyState) {
  return true;
}


enum class ActuationEligibility : int32_t {
  
  kEligible = 0,
  
  kMissingAccountCapability = 1,
  
  kMissingChromeBenefits = 2,
  
  kDisabledByPolicy = 3,
  
  kEnterpriseWithoutManagement = 4,
  
  kPlatformUnsupported = 5,
  kMinValue = 0,
  kMaxValue = 5,
};

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

// Returns true if the enum has an infallible conversion from the mojom enum.
consteval bool HasInfallibleConversion(ActuationEligibility) {
  return true;
}


enum class MetricUserInputReactionType : int32_t {
  
  kUnknown = 0,
  
  kCanned = 1,
  
  kModel = 2,
  kMinValue = 0,
  kMaxValue = 2,
  kDefaultValue = 0
};

 std::ostream& operator<<(std::ostream& os, MetricUserInputReactionType value);
inline bool IsKnownEnumValue(MetricUserInputReactionType value) {
  return internal::MetricUserInputReactionType_Data::IsKnownValue(
      static_cast<int32_t>(value));
}
inline MetricUserInputReactionType ToKnownEnumValue(MetricUserInputReactionType value) {
  if (IsKnownEnumValue(value)) {
    return value;
  }
  return MetricUserInputReactionType::kDefaultValue;
}

// Returns true if the enum has an infallible conversion from the mojom enum.
consteval bool HasInfallibleConversion(MetricUserInputReactionType) {
  return true;
}


enum class PerformActionsErrorReason : int32_t {
  
  kUnknown = 0,
  
  kInvalidProto = 1,
  
  kMissingTaskId = 2,
  kMinValue = 0,
  kMaxValue = 2,
  kDefaultValue = 0
};

 std::ostream& operator<<(std::ostream& os, PerformActionsErrorReason value);
inline bool IsKnownEnumValue(PerformActionsErrorReason value) {
  return internal::PerformActionsErrorReason_Data::IsKnownValue(
      static_cast<int32_t>(value));
}
inline PerformActionsErrorReason ToKnownEnumValue(PerformActionsErrorReason value) {
  if (IsKnownEnumValue(value)) {
    return value;
  }
  return PerformActionsErrorReason::kDefaultValue;
}

// Returns true if the enum has an infallible conversion from the mojom enum.
consteval bool HasInfallibleConversion(PerformActionsErrorReason) {
  return true;
}


enum class CreateTaskErrorReason : int32_t {
  
  kUnknown = 0,
  
  kTaskSystemUnavailable = 1,
  
  kExistingActiveTask = 2,
  
  kBlockedByPolicy = 3,
  
  kConversationNotRegistered = 4,
  kMinValue = 0,
  kMaxValue = 4,
  kDefaultValue = 0
};

 std::ostream& operator<<(std::ostream& os, CreateTaskErrorReason value);
inline bool IsKnownEnumValue(CreateTaskErrorReason value) {
  return internal::CreateTaskErrorReason_Data::IsKnownValue(
      static_cast<int32_t>(value));
}
inline CreateTaskErrorReason ToKnownEnumValue(CreateTaskErrorReason value) {
  if (IsKnownEnumValue(value)) {
    return value;
  }
  return CreateTaskErrorReason::kDefaultValue;
}

// Returns true if the enum has an infallible conversion from the mojom enum.
consteval bool HasInfallibleConversion(CreateTaskErrorReason) {
  return true;
}


enum class ActorTaskState : int32_t {
  
  kUnknown = 0,
  
  kIdle = 1,
  
  kActing = 2,
  
  kPaused = 3,
  
  kStopped = 4,
  kMinValue = 0,
  kMaxValue = 4,
  kDefaultValue = 0
};

 std::ostream& operator<<(std::ostream& os, ActorTaskState value);
inline bool IsKnownEnumValue(ActorTaskState value) {
  return internal::ActorTaskState_Data::IsKnownValue(
      static_cast<int32_t>(value));
}
inline ActorTaskState ToKnownEnumValue(ActorTaskState value) {
  if (IsKnownEnumValue(value)) {
    return value;
  }
  return ActorTaskState::kDefaultValue;
}

// Returns true if the enum has an infallible conversion from the mojom enum.
consteval bool HasInfallibleConversion(ActorTaskState) {
  return true;
}


enum class ActorTaskPauseReason : int32_t {
  
  kPausedByModel = 0,
  
  kPausedByUser = 1,
  kMinValue = 0,
  kMaxValue = 1,
  kDefaultValue = 0
};

 std::ostream& operator<<(std::ostream& os, ActorTaskPauseReason value);
inline bool IsKnownEnumValue(ActorTaskPauseReason value) {
  return internal::ActorTaskPauseReason_Data::IsKnownValue(
      static_cast<int32_t>(value));
}
inline ActorTaskPauseReason ToKnownEnumValue(ActorTaskPauseReason value) {
  if (IsKnownEnumValue(value)) {
    return value;
  }
  return ActorTaskPauseReason::kDefaultValue;
}

// Returns true if the enum has an infallible conversion from the mojom enum.
consteval bool HasInfallibleConversion(ActorTaskPauseReason) {
  return true;
}


enum class ActorTaskStopReason : int32_t {
  
  kTaskComplete = 0,
  
  kStoppedByUser = 1,
  
  kModelError = 2,
  
  kUserStartedNewChat = 3,
  
  kUserLoadedPreviousChat = 4,
  kMinValue = 0,
  kMaxValue = 4,
  kDefaultValue = 0
};

 std::ostream& operator<<(std::ostream& os, ActorTaskStopReason value);
inline bool IsKnownEnumValue(ActorTaskStopReason value) {
  return internal::ActorTaskStopReason_Data::IsKnownValue(
      static_cast<int32_t>(value));
}
inline ActorTaskStopReason ToKnownEnumValue(ActorTaskStopReason value) {
  if (IsKnownEnumValue(value)) {
    return value;
  }
  return ActorTaskStopReason::kDefaultValue;
}

// Returns true if the enum has an infallible conversion from the mojom enum.
consteval bool HasInfallibleConversion(ActorTaskStopReason) {
  return true;
}


enum class ActorTaskInterruptReason : int32_t {
  
  kUnknownReason = 0,
  
  kTaskComplete = 1,
  
  kWaitingUserInput = 2,
  
  kWaitingUserClarification = 3,
  
  kWaitingUserConfirmation = 4,
  
  kWaitingUserTakeOver = 5,
  
  kWaitingIrrelevantUserInput = 6,
  
  kWaitingUnsafeCounterAbuseVerdict = 7,
  
  kWaitingForExperimentalTriggeringConsent = 8,
  kMinValue = 0,
  kMaxValue = 8,
  kDefaultValue = 0
};

 std::ostream& operator<<(std::ostream& os, ActorTaskInterruptReason value);
inline bool IsKnownEnumValue(ActorTaskInterruptReason value) {
  return internal::ActorTaskInterruptReason_Data::IsKnownValue(
      static_cast<int32_t>(value));
}
inline ActorTaskInterruptReason ToKnownEnumValue(ActorTaskInterruptReason value) {
  if (IsKnownEnumValue(value)) {
    return value;
  }
  return ActorTaskInterruptReason::kDefaultValue;
}

// Returns true if the enum has an infallible conversion from the mojom enum.
consteval bool HasInfallibleConversion(ActorTaskInterruptReason) {
  return true;
}


enum class CaptureScreenshotErrorReason : int32_t {
  
  kUnknown = 0,
  
  kScreenCaptureRequestThrottled = 1,
  
  kUserCancelledScreenPickerDialog = 2,
  kMinValue = 0,
  kMaxValue = 2,
  kDefaultValue = 0
};

 std::ostream& operator<<(std::ostream& os, CaptureScreenshotErrorReason value);
inline bool IsKnownEnumValue(CaptureScreenshotErrorReason value) {
  return internal::CaptureScreenshotErrorReason_Data::IsKnownValue(
      static_cast<int32_t>(value));
}
inline CaptureScreenshotErrorReason ToKnownEnumValue(CaptureScreenshotErrorReason value) {
  if (IsKnownEnumValue(value)) {
    return value;
  }
  return CaptureScreenshotErrorReason::kDefaultValue;
}

// Returns true if the enum has an infallible conversion from the mojom enum.
consteval bool HasInfallibleConversion(CaptureScreenshotErrorReason) {
  return true;
}


enum class SbThreatType : int32_t {
  
  kUnspecified = 0,
  
  kSocialEngineering = 1,
  
  kMalware = 2,
  
  kUnwantedSoftware = 3,
  kMinValue = 0,
  kMaxValue = 3,
  kDefaultValue = 0
};

 std::ostream& operator<<(std::ostream& os, SbThreatType value);
inline bool IsKnownEnumValue(SbThreatType value) {
  return internal::SbThreatType_Data::IsKnownValue(
      static_cast<int32_t>(value));
}
inline SbThreatType ToKnownEnumValue(SbThreatType value) {
  if (IsKnownEnumValue(value)) {
    return value;
  }
  return SbThreatType::kDefaultValue;
}

// Returns true if the enum has an infallible conversion from the mojom enum.
consteval bool HasInfallibleConversion(SbThreatType) {
  return true;
}


enum class Platform : int32_t {
  
  kUnknown = 0,
  
  kMacOS = 1,
  
  kWindows = 2,
  
  kLinux = 3,
  
  kChromeOS = 4,
  
  kAndroid = 5,
  kMinValue = 0,
  kMaxValue = 5,
};

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

// Returns true if the enum has an infallible conversion from the mojom enum.
consteval bool HasInfallibleConversion(Platform) {
  return true;
}


enum class FormFactor : int32_t {
  
  kUnknown = 0,
  
  kDesktop = 1,
  
  kPhone = 2,
  
  kTablet = 3,
  kMinValue = 0,
  kMaxValue = 3,
};

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

// Returns true if the enum has an infallible conversion from the mojom enum.
consteval bool HasInfallibleConversion(FormFactor) {
  return true;
}


enum class ScreenshotImageFormat : int32_t {
  
  kJpeg = 0,
  
  kPng = 1,
  
  kWebp = 2,
  kMinValue = 0,
  kMaxValue = 2,
  kDefaultValue = 0
};

 std::ostream& operator<<(std::ostream& os, ScreenshotImageFormat value);
inline bool IsKnownEnumValue(ScreenshotImageFormat value) {
  return internal::ScreenshotImageFormat_Data::IsKnownValue(
      static_cast<int32_t>(value));
}
inline ScreenshotImageFormat ToKnownEnumValue(ScreenshotImageFormat value) {
  if (IsKnownEnumValue(value)) {
    return value;
  }
  return ScreenshotImageFormat::kDefaultValue;
}

// Returns true if the enum has an infallible conversion from the mojom enum.
consteval bool HasInfallibleConversion(ScreenshotImageFormat) {
  return true;
}


enum class ScreenshotCompressionQuality : int32_t {
  
  kNone = 0,
  
  kLow = 1,
  
  kMedium = 2,
  
  kHigh = 3,
  kMinValue = 0,
  kMaxValue = 3,
  kDefaultValue = 0
};

 std::ostream& operator<<(std::ostream& os, ScreenshotCompressionQuality value);
inline bool IsKnownEnumValue(ScreenshotCompressionQuality value) {
  return internal::ScreenshotCompressionQuality_Data::IsKnownValue(
      static_cast<int32_t>(value));
}
inline ScreenshotCompressionQuality ToKnownEnumValue(ScreenshotCompressionQuality value) {
  if (IsKnownEnumValue(value)) {
    return value;
  }
  return ScreenshotCompressionQuality::kDefaultValue;
}

// Returns true if the enum has an infallible conversion from the mojom enum.
consteval bool HasInfallibleConversion(ScreenshotCompressionQuality) {
  return true;
}


enum class ScrollToErrorReason : int32_t {
  
  kNotSupported = 0,
  
  kNewerScrollToCall = 1,
  
  kNoFocusedTab = 2,
  
  kNoMatchFound = 3,
  
  kFocusedTabChangedOrNavigated = 4,
  
  kNoMatchingDocument = 5,
  
  kSearchRangeInvalid = 6,
  
  kTabContextPermissionDisabled = 7,
  
  kDroppedByWebClient = 8,
  kMinValue = 0,
  kMaxValue = 8,
  kDefaultValue = 0
};

 std::ostream& operator<<(std::ostream& os, ScrollToErrorReason value);
inline bool IsKnownEnumValue(ScrollToErrorReason value) {
  return internal::ScrollToErrorReason_Data::IsKnownValue(
      static_cast<int32_t>(value));
}
inline ScrollToErrorReason ToKnownEnumValue(ScrollToErrorReason value) {
  if (IsKnownEnumValue(value)) {
    return value;
  }
  return ScrollToErrorReason::kDefaultValue;
}

// Returns true if the enum has an infallible conversion from the mojom enum.
consteval bool HasInfallibleConversion(ScrollToErrorReason) {
  return true;
}


enum class SkillSource : int32_t {
  
  kUnknown = 0,
  
  kFirstParty = 1,
  
  kUserCreated = 2,
  
  kDerivedFromFirstParty = 3,
  
  kEnterprise = 4,
  
  kDerivedFromEnterprise = 5,
  kMinValue = 0,
  kMaxValue = 5,
  kDefaultValue = 0
};

 std::ostream& operator<<(std::ostream& os, SkillSource value);
inline bool IsKnownEnumValue(SkillSource value) {
  return internal::SkillSource_Data::IsKnownValue(
      static_cast<int32_t>(value));
}
inline SkillSource ToKnownEnumValue(SkillSource value) {
  if (IsKnownEnumValue(value)) {
    return value;
  }
  return SkillSource::kDefaultValue;
}

// Returns true if the enum has an infallible conversion from the mojom enum.
consteval bool HasInfallibleConversion(SkillSource) {
  return true;
}


enum class SkillsWebClientEvent : int32_t {
  
  kUnknown = 0,
  
  kUsedFirstPartySkill = 1,
  
  kUsedUserCreatedSkill = 2,
  
  kUsedDerivedFirstPartySkill = 3,
  
  kOpenedMenu = 4,
  
  kClickedManageFromMenu = 5,
  
  kClickedAddFromMenu = 6,
  
  kClickedEditFromMenu = 7,
  
  kClickedAddOn1pSkill = 8,
  
  kClickedSaveAsSkillHoverChip = 9,
  
  kClickedEditSkillHoverChip = 10,
  
  kClickedBrowseSkillFromPlusMenu = 11,
  
  kClickedSkillFromPlusMenu = 12,
  
  kClickedManageSkillFromPlusMenu = 13,
  
  kClickedMoreFromMenu = 14,
  
  kClickedManageSkillFromMenu = 15,
  
  kClickedSkillFromMenu = 16,
  
  kClickedBrowseSkillsFromMenu = 17,
  
  kSkillBuilderClickedPromoChip = 20,
  
  kSkillBuilderPromptGenerated = 21,
  
  kSkillBuilderClickedSaveAsSkill = 22,
  kMinValue = 0,
  kMaxValue = 22,
  kDefaultValue = 0
};

 std::ostream& operator<<(std::ostream& os, SkillsWebClientEvent value);
inline bool IsKnownEnumValue(SkillsWebClientEvent value) {
  return internal::SkillsWebClientEvent_Data::IsKnownValue(
      static_cast<int32_t>(value));
}
inline SkillsWebClientEvent ToKnownEnumValue(SkillsWebClientEvent value) {
  if (IsKnownEnumValue(value)) {
    return value;
  }
  return SkillsWebClientEvent::kDefaultValue;
}

// Returns true if the enum has an infallible conversion from the mojom enum.
consteval bool HasInfallibleConversion(SkillsWebClientEvent) {
  return true;
}


enum class PinTrigger : int32_t {
  
  kWebClientUnknown = 0,
  
  kCandidatesToggle = 1,
  
  kAtMention = 2,
  
  kActuation = 3,
  kMinValue = 0,
  kMaxValue = 3,
  kDefaultValue = 0
};

 std::ostream& operator<<(std::ostream& os, PinTrigger value);
inline bool IsKnownEnumValue(PinTrigger value) {
  return internal::PinTrigger_Data::IsKnownValue(
      static_cast<int32_t>(value));
}
inline PinTrigger ToKnownEnumValue(PinTrigger value) {
  if (IsKnownEnumValue(value)) {
    return value;
  }
  return PinTrigger::kDefaultValue;
}

// Returns true if the enum has an infallible conversion from the mojom enum.
consteval bool HasInfallibleConversion(PinTrigger) {
  return true;
}


enum class UnpinTrigger : int32_t {
  
  kWebClientUnknown = 0,
  
  kCandidatesToggle = 1,
  
  kChip = 2,
  
  kActuation = 3,
  kMinValue = 0,
  kMaxValue = 3,
  kDefaultValue = 0
};

 std::ostream& operator<<(std::ostream& os, UnpinTrigger value);
inline bool IsKnownEnumValue(UnpinTrigger value) {
  return internal::UnpinTrigger_Data::IsKnownValue(
      static_cast<int32_t>(value));
}
inline UnpinTrigger ToKnownEnumValue(UnpinTrigger value) {
  if (IsKnownEnumValue(value)) {
    return value;
  }
  return UnpinTrigger::kDefaultValue;
}

// Returns true if the enum has an infallible conversion from the mojom enum.
consteval bool HasInfallibleConversion(UnpinTrigger) {
  return true;
}


enum class CancelActionsResult : int32_t {
  
  kUnknown = 0,
  
  kSuccess = 1,
  
  kTaskNotFound = 2,
  
  kFailed = 3,
  kMinValue = 0,
  kMaxValue = 3,
  kDefaultValue = 0
};

 std::ostream& operator<<(std::ostream& os, CancelActionsResult value);
inline bool IsKnownEnumValue(CancelActionsResult value) {
  return internal::CancelActionsResult_Data::IsKnownValue(
      static_cast<int32_t>(value));
}
inline CancelActionsResult ToKnownEnumValue(CancelActionsResult value) {
  if (IsKnownEnumValue(value)) {
    return value;
  }
  return CancelActionsResult::kDefaultValue;
}

// Returns true if the enum has an infallible conversion from the mojom enum.
consteval bool HasInfallibleConversion(CancelActionsResult) {
  return true;
}


enum class SwitchConversationErrorReason : int32_t {
  
  kUnknown = 0,
  kMinValue = 0,
  kMaxValue = 0,
  kDefaultValue = 0
};

 std::ostream& operator<<(std::ostream& os, SwitchConversationErrorReason value);
inline bool IsKnownEnumValue(SwitchConversationErrorReason value) {
  return internal::SwitchConversationErrorReason_Data::IsKnownValue(
      static_cast<int32_t>(value));
}
inline SwitchConversationErrorReason ToKnownEnumValue(SwitchConversationErrorReason value) {
  if (IsKnownEnumValue(value)) {
    return value;
  }
  return SwitchConversationErrorReason::kDefaultValue;
}

// Returns true if the enum has an infallible conversion from the mojom enum.
consteval bool HasInfallibleConversion(SwitchConversationErrorReason) {
  return true;
}


enum class RegisterConversationErrorReason : int32_t {
  
  kUnknown = 0,
  
  kInstanceAlreadyHasConversationId = 1,
  kMinValue = 0,
  kMaxValue = 1,
  kDefaultValue = 0
};

 std::ostream& operator<<(std::ostream& os, RegisterConversationErrorReason value);
inline bool IsKnownEnumValue(RegisterConversationErrorReason value) {
  return internal::RegisterConversationErrorReason_Data::IsKnownValue(
      static_cast<int32_t>(value));
}
inline RegisterConversationErrorReason ToKnownEnumValue(RegisterConversationErrorReason value) {
  if (IsKnownEnumValue(value)) {
    return value;
  }
  return RegisterConversationErrorReason::kDefaultValue;
}

// Returns true if the enum has an infallible conversion from the mojom enum.
consteval bool HasInfallibleConversion(RegisterConversationErrorReason) {
  return true;
}


enum class PanelStateKind : int32_t {
  
  kHidden = 0,
  
  kDetached = 1,
  
  kAttached = 2,
  kMinValue = 0,
  kMaxValue = 2,
};

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

// Returns true if the enum has an infallible conversion from the mojom enum.
consteval bool HasInfallibleConversion(PanelStateKind) {
  return true;
}


enum class FreOverride : int32_t {
  
  kUnspecified = 0,
  
  kTrustFirstText = 1,
  
  kTrustFirstClick = 2,
  
  kTrustFirstInline = 3,
  kMinValue = 0,
  kMaxValue = 3,
  kDefaultValue = 0
};

 std::ostream& operator<<(std::ostream& os, FreOverride value);
inline bool IsKnownEnumValue(FreOverride value) {
  return internal::FreOverride_Data::IsKnownValue(
      static_cast<int32_t>(value));
}
inline FreOverride ToKnownEnumValue(FreOverride value) {
  if (IsKnownEnumValue(value)) {
    return value;
  }
  return FreOverride::kDefaultValue;
}

// Returns true if the enum has an infallible conversion from the mojom enum.
consteval bool HasInfallibleConversion(FreOverride) {
  return true;
}


enum class InvocationSource : int32_t {
  
  kOsButton = 0,
  
  kOsButtonMenu = 1,
  
  kOsHotkey = 2,
  
  kTopChromeButton = 3,
  
  kFre = 4,
  
  kProfilePicker = 5,
  
  kNudge = 6,
  
  kThreeDotsMenu = 7,
  
  kUnsupported = 8,
  
  kWhatsNew = 9,
  
  kAfterSignIn = 10,
  
  kSharedTab = 11,
  
  kActorTaskIcon = 12,
  
  kSharedImage = 13,
  
  kHandoffButton = 14,
  
  kSkills = 15,
  
  kAutoOpenedByContextualCue = 16,
  
  kPdfSummarizeButton = 17,
  
  kNavigationCapture = 18,
  
  kAutoOpenedForPdf = 19,
  
  kCaptureRegionHotkey = 20,
  
  kIph = 21,
  
  kAnchoredContextualCue = 22,
  
  kWebContentsContextMenu = 23,
  
  kTextSelectionNudge = 24,
  
  kTextSelectionWidget = 25,
  
  kZeroStateAutoSummarize = 26,
  
  kUniversalCart = 27,
  
  kExperimentalTriggering = 28,
  
  kPasswordChange = 29,
  
  kAutofill = 30,
  
  kToolbarButton = 31,
  
  kIndigoPageAction = 32,
  
  kWebDragDrop = 33,
  
  kPromotionPage = 34,
  
  kDaisyChainOnNewTab = 35,
  
  kDaisyChainOnFollowLink = 36,
  
  kConversationSwitch = 37,
  
  kDetachAttachButton = 38,
  
  kTabRestore = 39,
  
  kReshowInactive = 40,
  
  kTabContextMenu = 41,
  
  kWebContinuity = 42,
  kMinValue = 0,
  kMaxValue = 42,
  kDefaultValue = 8
};

 std::ostream& operator<<(std::ostream& os, InvocationSource value);
inline bool IsKnownEnumValue(InvocationSource value) {
  return internal::InvocationSource_Data::IsKnownValue(
      static_cast<int32_t>(value));
}
inline InvocationSource ToKnownEnumValue(InvocationSource value) {
  if (IsKnownEnumValue(value)) {
    return value;
  }
  return InvocationSource::kDefaultValue;
}

// Returns true if the enum has an infallible conversion from the mojom enum.
consteval bool HasInfallibleConversion(InvocationSource) {
  return true;
}


enum class ActuationTarget : int32_t {
  
  kUnknown = 0,
  
  kAgentDecides = 1,
  
  kCurrentTab = 2,
  
  kNewTab = 3,
  
  kTargetSurface = 4,
  kMinValue = 0,
  kMaxValue = 4,
  kDefaultValue = 0
};

 std::ostream& operator<<(std::ostream& os, ActuationTarget value);
inline bool IsKnownEnumValue(ActuationTarget value) {
  return internal::ActuationTarget_Data::IsKnownValue(
      static_cast<int32_t>(value));
}
inline ActuationTarget ToKnownEnumValue(ActuationTarget value) {
  if (IsKnownEnumValue(value)) {
    return value;
  }
  return ActuationTarget::kDefaultValue;
}

// Returns true if the enum has an infallible conversion from the mojom enum.
consteval bool HasInfallibleConversion(ActuationTarget) {
  return true;
}


enum class WebClientMode : int32_t {
  
  kUnknown = 2,
  
  kText = 0,
  
  kAudio = 1,
  kMinValue = 0,
  kMaxValue = 2,
  kDefaultValue = 2
};

 std::ostream& operator<<(std::ostream& os, WebClientMode value);
inline bool IsKnownEnumValue(WebClientMode value) {
  return internal::WebClientMode_Data::IsKnownValue(
      static_cast<int32_t>(value));
}
inline WebClientMode ToKnownEnumValue(WebClientMode value) {
  if (IsKnownEnumValue(value)) {
    return value;
  }
  return WebClientMode::kDefaultValue;
}

// Returns true if the enum has an infallible conversion from the mojom enum.
consteval bool HasInfallibleConversion(WebClientMode) {
  return true;
}


enum class PromptType : int32_t {
  
  kUnspecified = 0,
  
  kTypedText = 1,
  
  kZeroStateSuggestions = 2,
  
  kAutoPrompt = 3,
  
  kAudio = 4,
  kMinValue = 0,
  kMaxValue = 4,
  kDefaultValue = 0
};

 std::ostream& operator<<(std::ostream& os, PromptType value);
inline bool IsKnownEnumValue(PromptType value) {
  return internal::PromptType_Data::IsKnownValue(
      static_cast<int32_t>(value));
}
inline PromptType ToKnownEnumValue(PromptType value) {
  if (IsKnownEnumValue(value)) {
    return value;
  }
  return PromptType::kDefaultValue;
}

// Returns true if the enum has an infallible conversion from the mojom enum.
consteval bool HasInfallibleConversion(PromptType) {
  return true;
}


enum class MicrophoneStatus : int32_t {
  
  kNotListening = 0,
  
  kListening = 1,
  
  kUnknown = 2,
  kMinValue = 0,
  kMaxValue = 2,
  kDefaultValue = 2
};

 std::ostream& operator<<(std::ostream& os, MicrophoneStatus value);
inline bool IsKnownEnumValue(MicrophoneStatus value) {
  return internal::MicrophoneStatus_Data::IsKnownValue(
      static_cast<int32_t>(value));
}
inline MicrophoneStatus ToKnownEnumValue(MicrophoneStatus value) {
  if (IsKnownEnumValue(value)) {
    return value;
  }
  return MicrophoneStatus::kDefaultValue;
}

// Returns true if the enum has an infallible conversion from the mojom enum.
consteval bool HasInfallibleConversion(MicrophoneStatus) {
  return true;
}


enum class WebClientModel : int32_t {
  
  kDefault = 0,
  
  kActor = 1,
  kMinValue = 0,
  kMaxValue = 1,
  kDefaultValue = 0
};

 std::ostream& operator<<(std::ostream& os, WebClientModel value);
inline bool IsKnownEnumValue(WebClientModel value) {
  return internal::WebClientModel_Data::IsKnownValue(
      static_cast<int32_t>(value));
}
inline WebClientModel ToKnownEnumValue(WebClientModel value) {
  if (IsKnownEnumValue(value)) {
    return value;
  }
  return WebClientModel::kDefaultValue;
}

// Returns true if the enum has an infallible conversion from the mojom enum.
consteval bool HasInfallibleConversion(WebClientModel) {
  return true;
}


enum class WebUseCounter : int32_t {
  
  kDefault = 0,
  
  kSubmitPromptWithAutoMode = 1,
  
  kTaskInterruptedForUserConfirmation = 2,
  
  kTaskInterruptedForUserClarification = 3,
  
  kSelectionToggledViaSharedMenu = 4,
  
  kSelectionToggledViaHotKey = 5,
  
  kSubmitPromptWithTextSelectionCue = 6,
  kMinValue = 0,
  kMaxValue = 6,
  kDefaultValue = 0
};

 std::ostream& operator<<(std::ostream& os, WebUseCounter value);
inline bool IsKnownEnumValue(WebUseCounter value) {
  return internal::WebUseCounter_Data::IsKnownValue(
      static_cast<int32_t>(value));
}
inline WebUseCounter ToKnownEnumValue(WebUseCounter value) {
  if (IsKnownEnumValue(value)) {
    return value;
  }
  return WebUseCounter::kDefaultValue;
}

// Returns true if the enum has an infallible conversion from the mojom enum.
consteval bool HasInfallibleConversion(WebUseCounter) {
  return true;
}


enum class ClientErrorDialogType : int32_t {
  
  kUnknown = 0,
  
  kDisabledByOrganization = 1,
  
  kGenericAvailability = 2,
  
  kIneligibleAccount = 3,
  
  kSignout = 4,
  
  kUnsupportedLocation = 5,
  kMinValue = 0,
  kMaxValue = 5,
  kDefaultValue = 0
};

 std::ostream& operator<<(std::ostream& os, ClientErrorDialogType value);
inline bool IsKnownEnumValue(ClientErrorDialogType value) {
  return internal::ClientErrorDialogType_Data::IsKnownValue(
      static_cast<int32_t>(value));
}
inline ClientErrorDialogType ToKnownEnumValue(ClientErrorDialogType value) {
  if (IsKnownEnumValue(value)) {
    return value;
  }
  return ClientErrorDialogType::kDefaultValue;
}

// Returns true if the enum has an infallible conversion from the mojom enum.
consteval bool HasInfallibleConversion(ClientErrorDialogType) {
  return true;
}


enum class ResponseStopCause : int32_t {
  
  kUnknown = 0,
  
  kUser = 1,
  
  kOther = 2,
  kMinValue = 0,
  kMaxValue = 2,
  kDefaultValue = 0
};

 std::ostream& operator<<(std::ostream& os, ResponseStopCause value);
inline bool IsKnownEnumValue(ResponseStopCause value) {
  return internal::ResponseStopCause_Data::IsKnownValue(
      static_cast<int32_t>(value));
}
inline ResponseStopCause ToKnownEnumValue(ResponseStopCause value) {
  if (IsKnownEnumValue(value)) {
    return value;
  }
  return ResponseStopCause::kDefaultValue;
}

// Returns true if the enum has an infallible conversion from the mojom enum.
consteval bool HasInfallibleConversion(ResponseStopCause) {
  return true;
}


enum class AdditionalContextSource : int32_t {
  
  kUnknown = 2,
  
  kShareContextMenu = 0,
  
  kRegionSelection = 1,
  
  kTextSelection = 3,
  
  kWebDragDrop = 4,
  
  kExperimentalTriggering = 5,
  kMinValue = 0,
  kMaxValue = 5,
  kDefaultValue = 2
};

 std::ostream& operator<<(std::ostream& os, AdditionalContextSource value);
inline bool IsKnownEnumValue(AdditionalContextSource value) {
  return internal::AdditionalContextSource_Data::IsKnownValue(
      static_cast<int32_t>(value));
}
inline AdditionalContextSource ToKnownEnumValue(AdditionalContextSource value) {
  if (IsKnownEnumValue(value)) {
    return value;
  }
  return AdditionalContextSource::kDefaultValue;
}

// Returns true if the enum has an infallible conversion from the mojom enum.
consteval bool HasInfallibleConversion(AdditionalContextSource) {
  return true;
}


enum class ExperimentalTriggeringUpdateType : int32_t {
  
  kUnknown = 0,
  
  kWorklog = 1,
  
  kPaused = 2,
  
  kTerminalCompletion = 3,
  
  kTerminalStopped = 4,
  
  kTerminalFailed = 5,
  
  kYieldToUser = 6,
  
  kResumed = 7,
  kMinValue = 0,
  kMaxValue = 7,
  kDefaultValue = 0
};

 std::ostream& operator<<(std::ostream& os, ExperimentalTriggeringUpdateType value);
inline bool IsKnownEnumValue(ExperimentalTriggeringUpdateType value) {
  return internal::ExperimentalTriggeringUpdateType_Data::IsKnownValue(
      static_cast<int32_t>(value));
}
inline ExperimentalTriggeringUpdateType ToKnownEnumValue(ExperimentalTriggeringUpdateType value) {
  if (IsKnownEnumValue(value)) {
    return value;
  }
  return ExperimentalTriggeringUpdateType::kDefaultValue;
}

// Returns true if the enum has an infallible conversion from the mojom enum.
consteval bool HasInfallibleConversion(ExperimentalTriggeringUpdateType) {
  return true;
}


enum class SubscriberObservationType : int32_t {
  
  kUpdate = 0,
  
  kComplete = 1,
  
  kError = 2,
  kMinValue = 0,
  kMaxValue = 2,
  kDefaultValue = 0
};

 std::ostream& operator<<(std::ostream& os, SubscriberObservationType value);
inline bool IsKnownEnumValue(SubscriberObservationType value) {
  return internal::SubscriberObservationType_Data::IsKnownValue(
      static_cast<int32_t>(value));
}
inline SubscriberObservationType ToKnownEnumValue(SubscriberObservationType value) {
  if (IsKnownEnumValue(value)) {
    return value;
  }
  return SubscriberObservationType::kDefaultValue;
}

// Returns true if the enum has an infallible conversion from the mojom enum.
consteval bool HasInfallibleConversion(SubscriberObservationType) {
  return true;
}


enum class LightweightPageFeature : int32_t {
  
  kUnknown = 0,
  
  kYtAskButtonPresent = 1,
  kMinValue = 0,
  kMaxValue = 1,
  kDefaultValue = 0
};

 std::ostream& operator<<(std::ostream& os, LightweightPageFeature value);
inline bool IsKnownEnumValue(LightweightPageFeature value) {
  return internal::LightweightPageFeature_Data::IsKnownValue(
      static_cast<int32_t>(value));
}
inline LightweightPageFeature ToKnownEnumValue(LightweightPageFeature value) {
  if (IsKnownEnumValue(value)) {
    return value;
  }
  return LightweightPageFeature::kDefaultValue;
}

// Returns true if the enum has an infallible conversion from the mojom enum.
consteval bool HasInfallibleConversion(LightweightPageFeature) {
  return true;
}


enum class CaptureRegionErrorReason : int32_t {
  
  kUnknown = 0,
  
  kNoFocusableTab = 1,
  kMinValue = 0,
  kMaxValue = 1,
  kDefaultValue = 0
};

 std::ostream& operator<<(std::ostream& os, CaptureRegionErrorReason value);
inline bool IsKnownEnumValue(CaptureRegionErrorReason value) {
  return internal::CaptureRegionErrorReason_Data::IsKnownValue(
      static_cast<int32_t>(value));
}
inline CaptureRegionErrorReason ToKnownEnumValue(CaptureRegionErrorReason value) {
  if (IsKnownEnumValue(value)) {
    return value;
  }
  return CaptureRegionErrorReason::kDefaultValue;
}

// Returns true if the enum has an infallible conversion from the mojom enum.
consteval bool HasInfallibleConversion(CaptureRegionErrorReason) {
  return true;
}


enum class ScreenshotEncryptionScheme : int32_t {
  
  kUnknown = 0,
  
  kNone = 1,
  
  kRfc8291 = 2,
  kMinValue = 0,
  kMaxValue = 2,
  kDefaultValue = 0
};

 std::ostream& operator<<(std::ostream& os, ScreenshotEncryptionScheme value);
inline bool IsKnownEnumValue(ScreenshotEncryptionScheme value) {
  return internal::ScreenshotEncryptionScheme_Data::IsKnownValue(
      static_cast<int32_t>(value));
}
inline ScreenshotEncryptionScheme ToKnownEnumValue(ScreenshotEncryptionScheme value) {
  if (IsKnownEnumValue(value)) {
    return value;
  }
  return ScreenshotEncryptionScheme::kDefaultValue;
}

// Returns true if the enum has an infallible conversion from the mojom enum.
consteval bool HasInfallibleConversion(ScreenshotEncryptionScheme) {
  return true;
}


enum class SettingsPageField : int32_t {
  
  kNone = 0,
  
  kOsHotkey = 1,
  
  kOsEntrypointToggle = 2,
  
  kLocationPermission = 3,
  kMinValue = 0,
  kMaxValue = 3,
  kDefaultValue = 0
};

 std::ostream& operator<<(std::ostream& os, SettingsPageField value);
inline bool IsKnownEnumValue(SettingsPageField value) {
  return internal::SettingsPageField_Data::IsKnownValue(
      static_cast<int32_t>(value));
}
inline SettingsPageField ToKnownEnumValue(SettingsPageField value) {
  if (IsKnownEnumValue(value)) {
    return value;
  }
  return SettingsPageField::kDefaultValue;
}

// Returns true if the enum has an infallible conversion from the mojom enum.
consteval bool HasInfallibleConversion(SettingsPageField) {
  return true;
}


enum class HostCapability : int32_t {
  
  kScrollToPdf = 0,
  
  kResetSizeAndLocationOnOpen = 1,
  
  kGetModelQualityClientId = 2,
  
  kMultiInstance = 3,
  
  kTrustFirstOnboardingArm1 = 4,
  
  kTrustFirstOnboardingArm2 = 5,
  
  kShareAdditionalImageContext = 6,
  
  kPdfZeroState = 7,
  
  kInvoke = 8,
  
  kNoLiveMode = 9,
  
  kAutoLoginSignInWithGoogle = 10,
  
  kShareImageViaInvoke = 11,
  
  kImgWebDragDrop = 12,
  
  kNoWebUiLoader = 13,
  
  kEnforcesPasteEligibility = 14,
  
  kAttemptOtpFilling = 15,
  kMinValue = 0,
  kMaxValue = 15,
};

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

// Returns true if the enum has an infallible conversion from the mojom enum.
consteval bool HasInfallibleConversion(HostCapability) {
  return true;
}


enum class ClientCapabilities : int32_t {
  
  kIgnoresTabDataFavicons = 0,
  kMinValue = 0,
  kMaxValue = 0,
};

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

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

using PinCandidatesObserverPtrDataView =
    mojo::InterfacePtrDataView<PinCandidatesObserverInterfaceBase>;
using PinCandidatesObserverRequestDataView =
    mojo::InterfaceRequestDataView<PinCandidatesObserverInterfaceBase>;
using PinCandidatesObserverAssociatedPtrInfoDataView =
    mojo::AssociatedInterfacePtrInfoDataView<PinCandidatesObserverInterfaceBase>;
using PinCandidatesObserverAssociatedRequestDataView =
    mojo::AssociatedInterfaceRequestDataView<PinCandidatesObserverInterfaceBase>;
class ActorClientInterfaceBase {};

using ActorClientPtrDataView =
    mojo::InterfacePtrDataView<ActorClientInterfaceBase>;
using ActorClientRequestDataView =
    mojo::InterfaceRequestDataView<ActorClientInterfaceBase>;
using ActorClientAssociatedPtrInfoDataView =
    mojo::AssociatedInterfacePtrInfoDataView<ActorClientInterfaceBase>;
using ActorClientAssociatedRequestDataView =
    mojo::AssociatedInterfaceRequestDataView<ActorClientInterfaceBase>;
class ActorHandlerInterfaceBase {};

using ActorHandlerPtrDataView =
    mojo::InterfacePtrDataView<ActorHandlerInterfaceBase>;
using ActorHandlerRequestDataView =
    mojo::InterfaceRequestDataView<ActorHandlerInterfaceBase>;
using ActorHandlerAssociatedPtrInfoDataView =
    mojo::AssociatedInterfacePtrInfoDataView<ActorHandlerInterfaceBase>;
using ActorHandlerAssociatedRequestDataView =
    mojo::AssociatedInterfaceRequestDataView<ActorHandlerInterfaceBase>;
class AnnotationHandlerInterfaceBase {};

using AnnotationHandlerPtrDataView =
    mojo::InterfacePtrDataView<AnnotationHandlerInterfaceBase>;
using AnnotationHandlerRequestDataView =
    mojo::InterfaceRequestDataView<AnnotationHandlerInterfaceBase>;
using AnnotationHandlerAssociatedPtrInfoDataView =
    mojo::AssociatedInterfacePtrInfoDataView<AnnotationHandlerInterfaceBase>;
using AnnotationHandlerAssociatedRequestDataView =
    mojo::AssociatedInterfaceRequestDataView<AnnotationHandlerInterfaceBase>;
class SkillsHandlerInterfaceBase {};

using SkillsHandlerPtrDataView =
    mojo::InterfacePtrDataView<SkillsHandlerInterfaceBase>;
using SkillsHandlerRequestDataView =
    mojo::InterfaceRequestDataView<SkillsHandlerInterfaceBase>;
using SkillsHandlerAssociatedPtrInfoDataView =
    mojo::AssociatedInterfacePtrInfoDataView<SkillsHandlerInterfaceBase>;
using SkillsHandlerAssociatedRequestDataView =
    mojo::AssociatedInterfaceRequestDataView<SkillsHandlerInterfaceBase>;
class SkillsClientInterfaceBase {};

using SkillsClientPtrDataView =
    mojo::InterfacePtrDataView<SkillsClientInterfaceBase>;
using SkillsClientRequestDataView =
    mojo::InterfaceRequestDataView<SkillsClientInterfaceBase>;
using SkillsClientAssociatedPtrInfoDataView =
    mojo::AssociatedInterfacePtrInfoDataView<SkillsClientInterfaceBase>;
using SkillsClientAssociatedRequestDataView =
    mojo::AssociatedInterfaceRequestDataView<SkillsClientInterfaceBase>;
class WebClientHandlerInterfaceBase {};

using WebClientHandlerPtrDataView =
    mojo::InterfacePtrDataView<WebClientHandlerInterfaceBase>;
using WebClientHandlerRequestDataView =
    mojo::InterfaceRequestDataView<WebClientHandlerInterfaceBase>;
using WebClientHandlerAssociatedPtrInfoDataView =
    mojo::AssociatedInterfacePtrInfoDataView<WebClientHandlerInterfaceBase>;
using WebClientHandlerAssociatedRequestDataView =
    mojo::AssociatedInterfaceRequestDataView<WebClientHandlerInterfaceBase>;
class ZeroStateSuggestionsHandlerInterfaceBase {};

using ZeroStateSuggestionsHandlerPtrDataView =
    mojo::InterfacePtrDataView<ZeroStateSuggestionsHandlerInterfaceBase>;
using ZeroStateSuggestionsHandlerRequestDataView =
    mojo::InterfaceRequestDataView<ZeroStateSuggestionsHandlerInterfaceBase>;
using ZeroStateSuggestionsHandlerAssociatedPtrInfoDataView =
    mojo::AssociatedInterfacePtrInfoDataView<ZeroStateSuggestionsHandlerInterfaceBase>;
using ZeroStateSuggestionsHandlerAssociatedRequestDataView =
    mojo::AssociatedInterfaceRequestDataView<ZeroStateSuggestionsHandlerInterfaceBase>;
class ZeroStateSuggestionsClientInterfaceBase {};

using ZeroStateSuggestionsClientPtrDataView =
    mojo::InterfacePtrDataView<ZeroStateSuggestionsClientInterfaceBase>;
using ZeroStateSuggestionsClientRequestDataView =
    mojo::InterfaceRequestDataView<ZeroStateSuggestionsClientInterfaceBase>;
using ZeroStateSuggestionsClientAssociatedPtrInfoDataView =
    mojo::AssociatedInterfacePtrInfoDataView<ZeroStateSuggestionsClientInterfaceBase>;
using ZeroStateSuggestionsClientAssociatedRequestDataView =
    mojo::AssociatedInterfaceRequestDataView<ZeroStateSuggestionsClientInterfaceBase>;
class TabDataHandlerInterfaceBase {};

using TabDataHandlerPtrDataView =
    mojo::InterfacePtrDataView<TabDataHandlerInterfaceBase>;
using TabDataHandlerRequestDataView =
    mojo::InterfaceRequestDataView<TabDataHandlerInterfaceBase>;
using TabDataHandlerAssociatedPtrInfoDataView =
    mojo::AssociatedInterfacePtrInfoDataView<TabDataHandlerInterfaceBase>;
using TabDataHandlerAssociatedRequestDataView =
    mojo::AssociatedInterfaceRequestDataView<TabDataHandlerInterfaceBase>;
class TabFaviconHandlerInterfaceBase {};

using TabFaviconHandlerPtrDataView =
    mojo::InterfacePtrDataView<TabFaviconHandlerInterfaceBase>;
using TabFaviconHandlerRequestDataView =
    mojo::InterfaceRequestDataView<TabFaviconHandlerInterfaceBase>;
using TabFaviconHandlerAssociatedPtrInfoDataView =
    mojo::AssociatedInterfacePtrInfoDataView<TabFaviconHandlerInterfaceBase>;
using TabFaviconHandlerAssociatedRequestDataView =
    mojo::AssociatedInterfaceRequestDataView<TabFaviconHandlerInterfaceBase>;
class ExperimentalTriggeringUpdatesHandlerInterfaceBase {};

using ExperimentalTriggeringUpdatesHandlerPtrDataView =
    mojo::InterfacePtrDataView<ExperimentalTriggeringUpdatesHandlerInterfaceBase>;
using ExperimentalTriggeringUpdatesHandlerRequestDataView =
    mojo::InterfaceRequestDataView<ExperimentalTriggeringUpdatesHandlerInterfaceBase>;
using ExperimentalTriggeringUpdatesHandlerAssociatedPtrInfoDataView =
    mojo::AssociatedInterfacePtrInfoDataView<ExperimentalTriggeringUpdatesHandlerInterfaceBase>;
using ExperimentalTriggeringUpdatesHandlerAssociatedRequestDataView =
    mojo::AssociatedInterfaceRequestDataView<ExperimentalTriggeringUpdatesHandlerInterfaceBase>;
class ExperimentalTriggeringClientInterfaceBase {};

using ExperimentalTriggeringClientPtrDataView =
    mojo::InterfacePtrDataView<ExperimentalTriggeringClientInterfaceBase>;
using ExperimentalTriggeringClientRequestDataView =
    mojo::InterfaceRequestDataView<ExperimentalTriggeringClientInterfaceBase>;
using ExperimentalTriggeringClientAssociatedPtrInfoDataView =
    mojo::AssociatedInterfacePtrInfoDataView<ExperimentalTriggeringClientInterfaceBase>;
using ExperimentalTriggeringClientAssociatedRequestDataView =
    mojo::AssociatedInterfaceRequestDataView<ExperimentalTriggeringClientInterfaceBase>;
class WebClientInterfaceBase {};

using WebClientPtrDataView =
    mojo::InterfacePtrDataView<WebClientInterfaceBase>;
using WebClientRequestDataView =
    mojo::InterfaceRequestDataView<WebClientInterfaceBase>;
using WebClientAssociatedPtrInfoDataView =
    mojo::AssociatedInterfacePtrInfoDataView<WebClientInterfaceBase>;
using WebClientAssociatedRequestDataView =
    mojo::AssociatedInterfaceRequestDataView<WebClientInterfaceBase>;
class CaptureRegionObserverInterfaceBase {};

using CaptureRegionObserverPtrDataView =
    mojo::InterfacePtrDataView<CaptureRegionObserverInterfaceBase>;
using CaptureRegionObserverRequestDataView =
    mojo::InterfaceRequestDataView<CaptureRegionObserverInterfaceBase>;
using CaptureRegionObserverAssociatedPtrInfoDataView =
    mojo::AssociatedInterfacePtrInfoDataView<CaptureRegionObserverInterfaceBase>;
using CaptureRegionObserverAssociatedRequestDataView =
    mojo::AssociatedInterfaceRequestDataView<CaptureRegionObserverInterfaceBase>;


class GeminiEnterpriseSettingsDataView {
 public:
  GeminiEnterpriseSettingsDataView() = default;

  GeminiEnterpriseSettingsDataView(
      internal::GeminiEnterpriseSettings_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

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

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

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

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


class ProfileEnablementDataView {
 public:
  ProfileEnablementDataView() = default;

  ProfileEnablementDataView(
      internal::ProfileEnablement_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  bool feature_enabled() const {
    return data_->feature_enabled;
  }
  bool is_regular_profile() const {
    return data_->is_regular_profile;
  }
  bool is_rolled_out() const {
    return data_->is_rolled_out;
  }
  bool primary_account_is_capable() const {
    return data_->primary_account_is_capable;
  }
  bool primary_account_is_fully_signed_in() const {
    return data_->primary_account_is_fully_signed_in;
  }
  bool allowed_by_chrome_policy() const {
    return data_->allowed_by_chrome_policy;
  }
  bool allowed_by_remote_admin() const {
    return data_->allowed_by_remote_admin;
  }
  bool allowed_by_remote_other() const {
    return data_->allowed_by_remote_other;
  }
  bool fre_is_consented() const {
    return data_->fre_is_consented;
  }
  bool allowed_by_country_filter() const {
    return data_->allowed_by_country_filter;
  }
  bool allowed_by_locale_filter() const {
    return data_->allowed_by_locale_filter;
  }
  bool actuation_is_consented() const {
    return data_->actuation_is_consented;
  }
  bool live_allowed() const {
    return data_->live_allowed;
  }
  bool share_image_allowed() const {
    return data_->share_image_allowed;
  }
  inline void GetGeminiEnterpriseSettingsDataView(
      GeminiEnterpriseSettingsDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadGeminiEnterpriseSettings(UserType* output) {
    
static_assert(
    mojo::internal::IsValidUserTypeForOptionalValue<
        ::glic::mojom::GeminiEnterpriseSettingsDataView, UserType>(),
    "Attempting to read the optional `gemini_enterprise_settings` 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 `MaybeReadGeminiEnterpriseSettings` instead "
    "of `ReadGeminiEnterpriseSettings if you're fine with null values being "
    "silently ignored in this case.");
    auto* pointer = data_->gemini_enterprise_settings.Get();
    return mojo::internal::Deserialize<::glic::mojom::GeminiEnterpriseSettingsDataView>(
        pointer, output, message_);
  }
  template <typename UserType>
  [[nodiscard]] bool ReadActuationEligibility(UserType* output) const {
    auto data_value = data_->actuation_eligibility;
    return mojo::internal::Deserialize<::glic::mojom::ActuationEligibility>(
        data_value, output);
  }
  ActuationEligibility actuation_eligibility() const {
    return ::mojo::internal::ToKnownEnumValueHelper(
          static_cast<::glic::mojom::ActuationEligibility>(data_->actuation_eligibility));
  }
  template <typename UserType>
  [[nodiscard]] bool ReadGlicApiActuationEligibility(UserType* output) const {
    auto data_value = data_->glic_api_actuation_eligibility;
    return mojo::internal::Deserialize<::glic::mojom::ActuationEligibility>(
        data_value, output);
  }
  ActuationEligibility glic_api_actuation_eligibility() const {
    return ::mojo::internal::ToKnownEnumValueHelper(
          static_cast<::glic::mojom::ActuationEligibility>(data_->glic_api_actuation_eligibility));
  }
  template <typename UserType>
  [[nodiscard]] bool ReadGlicExperimentalTriggeringState(UserType* output) const {
    auto data_value = data_->glic_experimental_triggering_state;
    return mojo::internal::Deserialize<::glic::mojom::GlicExperimentalTriggeringState>(
        data_value, output);
  }
  GlicExperimentalTriggeringState glic_experimental_triggering_state() const {
    return ::mojo::internal::ToKnownEnumValueHelper(
          static_cast<::glic::mojom::GlicExperimentalTriggeringState>(data_->glic_experimental_triggering_state));
  }
 private:
  internal::ProfileEnablement_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class ConfigInfoDataView {
 public:
  ConfigInfoDataView() = default;

  ConfigInfoDataView(
      internal::ConfigInfo_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  inline void GetGuestUrlDataView(
      ::url::mojom::UrlDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadGuestUrl(UserType* output) {
    
    auto* pointer = data_->guest_url.Get();
    return mojo::internal::Deserialize<::url::mojom::UrlDataView>(
        pointer, output, message_);
  }
  inline void GetAutopushGuestUrlDataView(
      ::url::mojom::UrlDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadAutopushGuestUrl(UserType* output) {
    
    auto* pointer = data_->autopush_guest_url.Get();
    return mojo::internal::Deserialize<::url::mojom::UrlDataView>(
        pointer, output, message_);
  }
  inline void GetStagingGuestUrlDataView(
      ::url::mojom::UrlDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadStagingGuestUrl(UserType* output) {
    
    auto* pointer = data_->staging_guest_url.Get();
    return mojo::internal::Deserialize<::url::mojom::UrlDataView>(
        pointer, output, message_);
  }
  inline void GetPreprodGuestUrlDataView(
      ::url::mojom::UrlDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadPreprodGuestUrl(UserType* output) {
    
    auto* pointer = data_->preprod_guest_url.Get();
    return mojo::internal::Deserialize<::url::mojom::UrlDataView>(
        pointer, output, message_);
  }
  inline void GetProdGuestUrlDataView(
      ::url::mojom::UrlDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadProdGuestUrl(UserType* output) {
    
    auto* pointer = data_->prod_guest_url.Get();
    return mojo::internal::Deserialize<::url::mojom::UrlDataView>(
        pointer, output, message_);
  }
  inline void GetWebContinuityOriginatingHostUrlDataView(
      ::url::mojom::UrlDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadWebContinuityOriginatingHostUrl(UserType* output) {
    
    auto* pointer = data_->web_continuity_originating_host_url.Get();
    return mojo::internal::Deserialize<::url::mojom::UrlDataView>(
        pointer, output, message_);
  }
 private:
  internal::ConfigInfo_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class DefaultConversationDataView {
 public:
  DefaultConversationDataView() = default;

  DefaultConversationDataView(
      internal::DefaultConversation_Data* data,
      mojo::Message* message)
      : data_(data) {}

  bool is_null() const { return !data_; }
 private:
  internal::DefaultConversation_Data* data_ = nullptr;
};


class NewConversationDataView {
 public:
  NewConversationDataView() = default;

  NewConversationDataView(
      internal::NewConversation_Data* data,
      mojo::Message* message)
      : data_(data) {}

  bool is_null() const { return !data_; }
 private:
  internal::NewConversation_Data* data_ = nullptr;
};


class DefaultSurfaceMojoDataView {
 public:
  DefaultSurfaceMojoDataView() = default;

  DefaultSurfaceMojoDataView(
      internal::DefaultSurfaceMojo_Data* data,
      mojo::Message* message)
      : data_(data) {}

  bool is_null() const { return !data_; }
 private:
  internal::DefaultSurfaceMojo_Data* data_ = nullptr;
};


class NewTabMojoDataView {
 public:
  NewTabMojoDataView() = default;

  NewTabMojoDataView(
      internal::NewTabMojo_Data* data,
      mojo::Message* message)
      : data_(data) {}

  bool is_null() const { return !data_; }
  bool open_in_foreground() const {
    return data_->open_in_foreground;
  }
 private:
  internal::NewTabMojo_Data* data_ = nullptr;
};


class ZssConfigDataView {
 public:
  ZssConfigDataView() = default;

  ZssConfigDataView(
      internal::ZssConfig_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

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

  template <typename UserType>
  [[nodiscard]] bool ReadAdditionalContent(UserType* output) {
    
static_assert(
    mojo::internal::IsValidUserTypeForOptionalValue<
        mojo::StringDataView, UserType>(),
    "Attempting to read the optional `additional_content` 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 `MaybeReadAdditionalContent` instead "
    "of `ReadAdditionalContent if you're fine with null values being "
    "silently ignored in this case.");
    auto* pointer = data_->additional_content.Get();
    return mojo::internal::Deserialize<mojo::StringDataView>(
        pointer, output, message_);
  }
 private:
  internal::ZssConfig_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class GetContextResultWithActionResultCodeDataView {
 public:
  GetContextResultWithActionResultCodeDataView() = default;

  GetContextResultWithActionResultCodeDataView(
      internal::GetContextResultWithActionResultCode_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  inline void GetGetContextResultDataView(
      GetContextResultDataView* output);

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

    return data_->action_result_$flag
        ? std::make_optional(data_->action_result_$value)
        : std::nullopt;
  }
 private:
  internal::GetContextResultWithActionResultCode_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class UserProfileInfoDataView {
 public:
  UserProfileInfoDataView() = default;

  UserProfileInfoDataView(
      internal::UserProfileInfo_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  inline void GetAvatarIconDataView(
      ::skia::mojom::BitmapN32DataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadAvatarIcon(UserType* output) {
    
static_assert(
    mojo::internal::IsValidUserTypeForOptionalValue<
        ::skia::mojom::BitmapN32DataView, UserType>(),
    "Attempting to read the optional `avatar_icon` 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 `MaybeReadAvatarIcon` instead "
    "of `ReadAvatarIcon if you're fine with null values being "
    "silently ignored in this case.");
    auto* pointer = data_->avatar_icon.Get();
    return mojo::internal::Deserialize<::skia::mojom::BitmapN32DataView>(
        pointer, output, message_);
  }
  inline void GetDisplayNameDataView(
      mojo::StringDataView* output);

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

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

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

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


class SafeBrowsingVerdictDataView {
 public:
  SafeBrowsingVerdictDataView() = default;

  SafeBrowsingVerdictDataView(
      internal::SafeBrowsingVerdict_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

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

  template <typename UserType>
  [[nodiscard]] bool ReadUrl(UserType* output) {
    
    auto* pointer = data_->url.Get();
    return mojo::internal::Deserialize<mojo::StringDataView>(
        pointer, output, message_);
  }
  template <typename UserType>
  [[nodiscard]] bool ReadThreatType(UserType* output) const {
    auto data_value = data_->threat_type;
    return mojo::internal::Deserialize<::glic::mojom::SbThreatType>(
        data_value, output);
  }
  SbThreatType threat_type() const {
    return ::mojo::internal::ToKnownEnumValueHelper(
          static_cast<::glic::mojom::SbThreatType>(data_->threat_type));
  }
  bool show_interstitial() const {
    return data_->show_interstitial;
  }
 private:
  internal::SafeBrowsingVerdict_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class CounterAbuseVerdictDataView {
 public:
  CounterAbuseVerdictDataView() = default;

  CounterAbuseVerdictDataView(
      internal::CounterAbuseVerdict_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  inline void GetSbVerdictResultDataView(
      SafeBrowsingVerdictDataView* output);

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


class WebClientInitialStateDataView {
 public:
  WebClientInitialStateDataView() = default;

  WebClientInitialStateDataView(
      internal::WebClientInitialState_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  inline void GetPanelStateDataView(
      PanelStateDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadPanelState(UserType* output) {
    
    auto* pointer = data_->panel_state.Get();
    return mojo::internal::Deserialize<::glic::mojom::PanelStateDataView>(
        pointer, output, message_);
  }
  inline void GetFocusedTabDataDataView(
      FocusedTabDataDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadFocusedTabData(UserType* output) {
    
    auto* pointer = !data_->focused_tab_data.is_null() ? &data_->focused_tab_data : nullptr;
    return mojo::internal::Deserialize<::glic::mojom::FocusedTabDataDataView>(
        pointer, output, message_);
  }
  bool microphone_permission_enabled() const {
    return data_->microphone_permission_enabled;
  }
  bool location_permission_enabled() const {
    return data_->location_permission_enabled;
  }
  bool tab_context_permission_enabled() const {
    return data_->tab_context_permission_enabled;
  }
  bool os_location_permission_enabled() const {
    return data_->os_location_permission_enabled;
  }
  double zoom_factor() const {
    return data_->zoom_factor;
  }
  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 GetChromeVersionDataView(
      ::mojo_base::mojom::VersionDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadChromeVersion(UserType* output) {
    
    auto* pointer = data_->chrome_version.Get();
    return mojo::internal::Deserialize<::mojo_base::mojom::VersionDataView>(
        pointer, output, message_);
  }
  template <typename UserType>
  [[nodiscard]] bool ReadPlatform(UserType* output) const {
    auto data_value = data_->platform;
    return mojo::internal::Deserialize<::glic::mojom::Platform>(
        data_value, output);
  }
  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);
  }
  FormFactor form_factor() const {
    return ::mojo::internal::ToKnownEnumValueHelper(
          static_cast<::glic::mojom::FormFactor>(data_->form_factor));
  }
  bool can_attach() const {
    return data_->can_attach;
  }
  bool panel_is_active() const {
    return data_->panel_is_active;
  }
  bool browser_is_open() const {
    return data_->browser_is_open;
  }
  bool instance_is_active() const {
    return data_->instance_is_active;
  }
  bool enable_zero_state_suggestions() const {
    return data_->enable_zero_state_suggestions;
  }
  bool enable_cached_get_user_profile_info() const {
    return data_->enable_cached_get_user_profile_info;
  }
  bool enable_act_in_focused_tab() const {
    return data_->enable_act_in_focused_tab;
  }
  bool enable_scroll_to() const {
    return data_->enable_scroll_to;
  }
  bool enable_default_tab_context_setting_feature() const {
    return data_->enable_default_tab_context_setting_feature;
  }
  bool default_tab_context_setting_enabled() const {
    return data_->default_tab_context_setting_enabled;
  }
  bool closed_captioning_setting_enabled() const {
    return data_->closed_captioning_setting_enabled;
  }
  bool enable_maybe_refresh_user_status() const {
    return data_->enable_maybe_refresh_user_status;
  }
  bool enable_multi_tab() const {
    return data_->enable_multi_tab;
  }
  bool enable_get_context_actor() const {
    return data_->enable_get_context_actor;
  }
  inline void GetHostCapabilitiesDataView(
      mojo::ArrayDataView<HostCapability>* output);

  template <typename UserType>
  [[nodiscard]] bool ReadHostCapabilities(UserType* output) {
    
    auto* pointer = data_->host_capabilities.Get();
    return mojo::internal::Deserialize<mojo::ArrayDataView<::glic::mojom::HostCapability>>(
        pointer, output, message_);
  }
  bool enable_get_page_metadata() const {
    return data_->enable_get_page_metadata;
  }
  bool enable_capture_region() const {
    return data_->enable_capture_region;
  }
  bool enable_web_actuation_setting_feature() const {
    return data_->enable_web_actuation_setting_feature;
  }
  bool actuation_on_web_setting_enabled() const {
    return data_->actuation_on_web_setting_enabled;
  }
  bool can_act_on_web() const {
    return data_->can_act_on_web;
  }
  bool enable_activate_tab() const {
    return data_->enable_activate_tab;
  }
  bool enable_get_tab_by_id() const {
    return data_->enable_get_tab_by_id;
  }
  bool enable_open_password_manager_settings_page() const {
    return data_->enable_open_password_manager_settings_page;
  }
  bool enable_trust_first_onboarding() const {
    return data_->enable_trust_first_onboarding;
  }
  bool onboarding_completed() const {
    return data_->onboarding_completed;
  }
  bool enable_skills() const {
    return data_->enable_skills;
  }
  bool enable_get_tab_favicon_by_id() const {
    return data_->enable_get_tab_favicon_by_id;
  }
  bool enable_process_counter_abuse_verdict() const {
    return data_->enable_process_counter_abuse_verdict;
  }
  inline void GetGeminiEnterpriseSettingsDataView(
      GeminiEnterpriseSettingsDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadGeminiEnterpriseSettings(UserType* output) {
    
static_assert(
    mojo::internal::IsValidUserTypeForOptionalValue<
        ::glic::mojom::GeminiEnterpriseSettingsDataView, UserType>(),
    "Attempting to read the optional `gemini_enterprise_settings` 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 `MaybeReadGeminiEnterpriseSettings` instead "
    "of `ReadGeminiEnterpriseSettings if you're fine with null values being "
    "silently ignored in this case.");
    auto* pointer = data_->gemini_enterprise_settings.Get();
    return mojo::internal::Deserialize<::glic::mojom::GeminiEnterpriseSettingsDataView>(
        pointer, output, message_);
  }
  bool enable_gmail_otp_opt_in() const {
    return data_->enable_gmail_otp_opt_in;
  }
  bool enable_gmail_otp_confirmation() const {
    return data_->enable_gmail_otp_confirmation;
  }
  template <typename UserType>
  [[nodiscard]] bool ReadFileUploadPolicyState(UserType* output) const {
    auto data_value = data_->file_upload_policy_state;
    return mojo::internal::Deserialize<::glic::mojom::FileUploadPolicyState>(
        data_value, output);
  }
  FileUploadPolicyState file_upload_policy_state() const {
    return ::mojo::internal::ToKnownEnumValueHelper(
          static_cast<::glic::mojom::FileUploadPolicyState>(data_->file_upload_policy_state));
  }
 private:
  internal::WebClientInitialState_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class ScreenshotCollectionOptionsDataView {
 public:
  ScreenshotCollectionOptionsDataView() = default;

  ScreenshotCollectionOptionsDataView(
      internal::ScreenshotCollectionOptions_Data* data,
      mojo::Message* message)
      : data_(data) {}

  bool is_null() const { return !data_; }
  uint32_t max_width() const {
    return data_->max_width;
  }
  uint32_t max_height() const {
    return data_->max_height;
  }
  template <typename UserType>
  [[nodiscard]] bool ReadScreenshotImageFormat(UserType* output) const {
    auto data_value = data_->screenshot_image_format;
    return mojo::internal::Deserialize<::glic::mojom::ScreenshotImageFormat>(
        data_value, output);
  }
  ScreenshotImageFormat screenshot_image_format() const {
    return ::mojo::internal::ToKnownEnumValueHelper(
          static_cast<::glic::mojom::ScreenshotImageFormat>(data_->screenshot_image_format));
  }
  template <typename UserType>
  [[nodiscard]] bool ReadScreenshotCompressionQuality(UserType* output) const {
    auto data_value = data_->screenshot_compression_quality;
    return mojo::internal::Deserialize<::glic::mojom::ScreenshotCompressionQuality>(
        data_value, output);
  }
  ScreenshotCompressionQuality screenshot_compression_quality() const {
    return ::mojo::internal::ToKnownEnumValueHelper(
          static_cast<::glic::mojom::ScreenshotCompressionQuality>(data_->screenshot_compression_quality));
  }
 private:
  internal::ScreenshotCollectionOptions_Data* data_ = nullptr;
};


class TabContextOptionsDataView {
 public:
  TabContextOptionsDataView() = default;

  TabContextOptionsDataView(
      internal::TabContextOptions_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  bool inner_text() const {
    return data_->inner_text;
  }
  uint32_t inner_text_bytes_limit() const {
    return data_->inner_text_bytes_limit;
  }
  bool viewport_screenshot() const {
    return data_->viewport_screenshot;
  }
  bool annotated_page_content() const {
    return data_->annotated_page_content;
  }
  uint32_t max_meta_tags() const {
    return data_->max_meta_tags;
  }
  bool pdf_data() const {
    return data_->pdf_data;
  }
  uint32_t pdf_size_limit() const {
    return data_->pdf_size_limit;
  }
  uint32_t annotated_page_content_mode() const {
    return data_->annotated_page_content_mode;
  }
  inline void GetScreenshotCollectionOptionsDataView(
      ScreenshotCollectionOptionsDataView* output);

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


class GetPinCandidatesOptionsDataView {
 public:
  GetPinCandidatesOptionsDataView() = default;

  GetPinCandidatesOptionsDataView(
      internal::GetPinCandidatesOptions_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  uint32_t max_candidates() const {
    return data_->max_candidates;
  }
  inline void GetQueryDataView(
      mojo::StringDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadQuery(UserType* output) {
    
static_assert(
    mojo::internal::IsValidUserTypeForOptionalValue<
        mojo::StringDataView, UserType>(),
    "Attempting to read the optional `query` 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 `MaybeReadQuery` instead "
    "of `ReadQuery if you're fine with null values being "
    "silently ignored in this case.");
    auto* pointer = data_->query.Get();
    return mojo::internal::Deserialize<mojo::StringDataView>(
        pointer, output, message_);
  }
 private:
  internal::GetPinCandidatesOptions_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class ScrollToParamsDataView {
 public:
  ScrollToParamsDataView() = default;

  ScrollToParamsDataView(
      internal::ScrollToParams_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  inline void GetSelectorDataView(
      ScrollToSelectorDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadSelector(UserType* output) {
    
    auto* pointer = !data_->selector.is_null() ? &data_->selector : nullptr;
    return mojo::internal::Deserialize<::glic::mojom::ScrollToSelectorDataView>(
        pointer, output, message_);
  }
  bool highlight() const {
    return data_->highlight;
  }
  inline void GetDocumentIdDataView(
      ::mojo_base::mojom::UnguessableTokenDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadDocumentId(UserType* output) {
    
static_assert(
    mojo::internal::IsValidUserTypeForOptionalValue<
        ::mojo_base::mojom::UnguessableTokenDataView, UserType>(),
    "Attempting to read the optional `document_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 `MaybeReadDocumentId` instead "
    "of `ReadDocumentId if you're fine with null values being "
    "silently ignored in this case.");
    auto* pointer = data_->document_id.Get();
    return mojo::internal::Deserialize<::mojo_base::mojom::UnguessableTokenDataView>(
        pointer, output, message_);
  }
  inline void GetUrlDataView(
      ::url::mojom::UrlDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadUrl(UserType* output) {
    
static_assert(
    mojo::internal::IsValidUserTypeForOptionalValue<
        ::url::mojom::UrlDataView, UserType>(),
    "Attempting to read the optional `url` 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 `MaybeReadUrl` instead "
    "of `ReadUrl if you're fine with null values being "
    "silently ignored in this case.");
    auto* pointer = data_->url.Get();
    return mojo::internal::Deserialize<::url::mojom::UrlDataView>(
        pointer, output, message_);
  }
 private:
  internal::ScrollToParams_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class ScrollToTextSelectorDataView {
 public:
  ScrollToTextSelectorDataView() = default;

  ScrollToTextSelectorDataView(
      internal::ScrollToTextSelector_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

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

  template <typename UserType>
  [[nodiscard]] bool ReadText(UserType* output) {
    
    auto* pointer = data_->text.Get();
    return mojo::internal::Deserialize<mojo::StringDataView>(
        pointer, output, message_);
  }
  std::optional<int32_t> search_range_start_node_id() const {

    return data_->search_range_start_node_id_$flag
        ? std::make_optional(data_->search_range_start_node_id_$value)
        : std::nullopt;
  }
 private:
  internal::ScrollToTextSelector_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class ScrollToTextFragmentSelectorDataView {
 public:
  ScrollToTextFragmentSelectorDataView() = default;

  ScrollToTextFragmentSelectorDataView(
      internal::ScrollToTextFragmentSelector_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

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

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

  template <typename UserType>
  [[nodiscard]] bool ReadTextEnd(UserType* output) {
    
    auto* pointer = data_->text_end.Get();
    return mojo::internal::Deserialize<mojo::StringDataView>(
        pointer, output, message_);
  }
  std::optional<int32_t> search_range_start_node_id() const {

    return data_->search_range_start_node_id_$flag
        ? std::make_optional(data_->search_range_start_node_id_$value)
        : std::nullopt;
  }
 private:
  internal::ScrollToTextFragmentSelector_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class ScrollToNodeSelectorDataView {
 public:
  ScrollToNodeSelectorDataView() = default;

  ScrollToNodeSelectorDataView(
      internal::ScrollToNodeSelector_Data* data,
      mojo::Message* message)
      : data_(data) {}

  bool is_null() const { return !data_; }
  int32_t node_id() const {
    return data_->node_id;
  }
 private:
  internal::ScrollToNodeSelector_Data* data_ = nullptr;
};


class SuggestionContentDataView {
 public:
  SuggestionContentDataView() = default;

  SuggestionContentDataView(
      internal::SuggestionContent_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

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

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


class SkillPreviewDataView {
 public:
  SkillPreviewDataView() = default;

  SkillPreviewDataView(
      internal::SkillPreview_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

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

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

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

  template <typename UserType>
  [[nodiscard]] bool ReadIcon(UserType* output) {
    
    auto* pointer = data_->icon.Get();
    return mojo::internal::Deserialize<mojo::StringDataView>(
        pointer, output, message_);
  }
  template <typename UserType>
  [[nodiscard]] bool ReadSource(UserType* output) const {
    auto data_value = data_->source;
    return mojo::internal::Deserialize<::glic::mojom::SkillSource>(
        data_value, output);
  }
  SkillSource source() const {
    return ::mojo::internal::ToKnownEnumValueHelper(
          static_cast<::glic::mojom::SkillSource>(data_->source));
  }
  inline void GetDescriptionDataView(
      mojo::StringDataView* output);

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

  template <typename UserType>
  [[nodiscard]] bool ReadCuratedBy(UserType* output) {
    
static_assert(
    mojo::internal::IsValidUserTypeForOptionalValue<
        mojo::StringDataView, UserType>(),
    "Attempting to read the optional `curated_by` 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 `MaybeReadCuratedBy` instead "
    "of `ReadCuratedBy if you're fine with null values being "
    "silently ignored in this case.");
    auto* pointer = data_->curated_by.Get();
    return mojo::internal::Deserialize<mojo::StringDataView>(
        pointer, output, message_);
  }
  inline void GetImageUrlDataView(
      ::url::mojom::UrlDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadImageUrl(UserType* output) {
    
static_assert(
    mojo::internal::IsValidUserTypeForOptionalValue<
        ::url::mojom::UrlDataView, UserType>(),
    "Attempting to read the optional `image_url` 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 `MaybeReadImageUrl` instead "
    "of `ReadImageUrl if you're fine with null values being "
    "silently ignored in this case.");
    auto* pointer = data_->image_url.Get();
    return mojo::internal::Deserialize<::url::mojom::UrlDataView>(
        pointer, output, message_);
  }
  inline void GetCategoryDataView(
      mojo::StringDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadCategory(UserType* output) {
    
static_assert(
    mojo::internal::IsValidUserTypeForOptionalValue<
        mojo::StringDataView, UserType>(),
    "Attempting to read the optional `category` 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 `MaybeReadCategory` instead "
    "of `ReadCategory if you're fine with null values being "
    "silently ignored in this case.");
    auto* pointer = data_->category.Get();
    return mojo::internal::Deserialize<mojo::StringDataView>(
        pointer, output, message_);
  }
  inline void GetCreationTimeDataView(
      ::mojo_base::mojom::TimeDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadCreationTime(UserType* output) {
    
static_assert(
    mojo::internal::IsValidUserTypeForOptionalValue<
        ::mojo_base::mojom::TimeDataView, UserType>(),
    "Attempting to read the optional `creation_time` 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 `MaybeReadCreationTime` instead "
    "of `ReadCreationTime if you're fine with null values being "
    "silently ignored in this case.");
    auto* pointer = data_->creation_time.Get();
    return mojo::internal::Deserialize<::mojo_base::mojom::TimeDataView>(
        pointer, output, message_);
  }
 private:
  internal::SkillPreview_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class SkillDataView {
 public:
  SkillDataView() = default;

  SkillDataView(
      internal::Skill_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  inline void GetPreviewDataView(
      SkillPreviewDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadPreview(UserType* output) {
    
    auto* pointer = data_->preview.Get();
    return mojo::internal::Deserialize<::glic::mojom::SkillPreviewDataView>(
        pointer, output, message_);
  }
  inline void GetPromptDataView(
      mojo::StringDataView* output);

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

  template <typename UserType>
  [[nodiscard]] bool ReadSourceSkillId(UserType* output) {
    
static_assert(
    mojo::internal::IsValidUserTypeForOptionalValue<
        mojo::StringDataView, UserType>(),
    "Attempting to read the optional `source_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 `MaybeReadSourceSkillId` instead "
    "of `ReadSourceSkillId if you're fine with null values being "
    "silently ignored in this case.");
    auto* pointer = data_->source_skill_id.Get();
    return mojo::internal::Deserialize<mojo::StringDataView>(
        pointer, output, message_);
  }
 private:
  internal::Skill_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class CreateSkillRequestDataView {
 public:
  CreateSkillRequestDataView() = default;

  CreateSkillRequestDataView(
      internal::CreateSkillRequest_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

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

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

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

  template <typename UserType>
  [[nodiscard]] bool ReadIcon(UserType* output) {
    
    auto* pointer = data_->icon.Get();
    return mojo::internal::Deserialize<mojo::StringDataView>(
        pointer, output, message_);
  }
  template <typename UserType>
  [[nodiscard]] bool ReadSource(UserType* output) const {
    auto data_value = data_->source;
    return mojo::internal::Deserialize<::glic::mojom::SkillSource>(
        data_value, output);
  }
  SkillSource source() const {
    return ::mojo::internal::ToKnownEnumValueHelper(
          static_cast<::glic::mojom::SkillSource>(data_->source));
  }
  inline void GetPromptDataView(
      mojo::StringDataView* output);

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

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


class UpdateSkillRequestDataView {
 public:
  UpdateSkillRequestDataView() = default;

  UpdateSkillRequestDataView(
      internal::UpdateSkillRequest_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

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

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


class ZeroStateSuggestionsDataView {
 public:
  ZeroStateSuggestionsDataView() = default;

  ZeroStateSuggestionsDataView(
      internal::ZeroStateSuggestions_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  inline void GetSuggestionsDataView(
      mojo::ArrayDataView<SuggestionContentDataView>* output);

  template <typename UserType>
  [[nodiscard]] bool ReadSuggestions(UserType* output) {
    
    auto* pointer = data_->suggestions.Get();
    return mojo::internal::Deserialize<mojo::ArrayDataView<::glic::mojom::SuggestionContentDataView>>(
        pointer, output, message_);
  }
  int32_t tab_id() const {
    return data_->tab_id;
  }
  inline void GetUrlDataView(
      ::url::mojom::UrlDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadUrl(UserType* output) {
    
    auto* pointer = data_->url.Get();
    return mojo::internal::Deserialize<::url::mojom::UrlDataView>(
        pointer, output, message_);
  }
 private:
  internal::ZeroStateSuggestions_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class ZeroStateSuggestionsV2DataView {
 public:
  ZeroStateSuggestionsV2DataView() = default;

  ZeroStateSuggestionsV2DataView(
      internal::ZeroStateSuggestionsV2_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  inline void GetSuggestionsDataView(
      mojo::ArrayDataView<SuggestionContentDataView>* output);

  template <typename UserType>
  [[nodiscard]] bool ReadSuggestions(UserType* output) {
    
    auto* pointer = data_->suggestions.Get();
    return mojo::internal::Deserialize<mojo::ArrayDataView<::glic::mojom::SuggestionContentDataView>>(
        pointer, output, message_);
  }
  bool is_pending() const {
    return data_->is_pending;
  }
  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);
  }
  InvocationSource invocation_source() const {
    return ::mojo::internal::ToKnownEnumValueHelper(
          static_cast<::glic::mojom::InvocationSource>(data_->invocation_source));
  }
 private:
  internal::ZeroStateSuggestionsV2_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class ZeroStateSuggestionsOptionsDataView {
 public:
  ZeroStateSuggestionsOptionsDataView() = default;

  ZeroStateSuggestionsOptionsDataView(
      internal::ZeroStateSuggestionsOptions_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  bool is_first_run() const {
    return data_->is_first_run;
  }
  inline void GetSupportedToolsDataView(
      mojo::ArrayDataView<mojo::StringDataView>* output);

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


class PinCandidateDataView {
 public:
  PinCandidateDataView() = default;

  PinCandidateDataView(
      internal::PinCandidate_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  inline void GetTabDataDataView(
      TabDataDataView* output);

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


class PinTabsOptionsDataView {
 public:
  PinTabsOptionsDataView() = default;

  PinTabsOptionsDataView(
      internal::PinTabsOptions_Data* data,
      mojo::Message* message)
      : data_(data) {}

  bool is_null() const { return !data_; }
  template <typename UserType>
  [[nodiscard]] bool ReadPinTrigger(UserType* output) const {
    auto data_value = data_->pin_trigger;
    return mojo::internal::Deserialize<::glic::mojom::PinTrigger>(
        data_value, output);
  }
  PinTrigger pin_trigger() const {
    return ::mojo::internal::ToKnownEnumValueHelper(
          static_cast<::glic::mojom::PinTrigger>(data_->pin_trigger));
  }
 private:
  internal::PinTabsOptions_Data* data_ = nullptr;
};


class UnpinTabsOptionsDataView {
 public:
  UnpinTabsOptionsDataView() = default;

  UnpinTabsOptionsDataView(
      internal::UnpinTabsOptions_Data* data,
      mojo::Message* message)
      : data_(data) {}

  bool is_null() const { return !data_; }
  template <typename UserType>
  [[nodiscard]] bool ReadUnpinTrigger(UserType* output) const {
    auto data_value = data_->unpin_trigger;
    return mojo::internal::Deserialize<::glic::mojom::UnpinTrigger>(
        data_value, output);
  }
  UnpinTrigger unpin_trigger() const {
    return ::mojo::internal::ToKnownEnumValueHelper(
          static_cast<::glic::mojom::UnpinTrigger>(data_->unpin_trigger));
  }
 private:
  internal::UnpinTabsOptions_Data* data_ = nullptr;
};


class OpenPinnedTabPickerOptionsDataView {
 public:
  OpenPinnedTabPickerOptionsDataView() = default;

  OpenPinnedTabPickerOptionsDataView(
      internal::OpenPinnedTabPickerOptions_Data* data,
      mojo::Message* message)
      : data_(data) {}

  bool is_null() const { return !data_; }
 private:
  internal::OpenPinnedTabPickerOptions_Data* data_ = nullptr;
};


class CreateActorTabOptionsDataView {
 public:
  CreateActorTabOptionsDataView() = default;

  CreateActorTabOptionsDataView(
      internal::CreateActorTabOptions_Data* data,
      mojo::Message* message)
      : data_(data) {}

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

    return data_->initiator_tab_id_$flag
        ? std::make_optional(data_->initiator_tab_id_$value)
        : std::nullopt;
  }
  std::optional<int32_t> initiator_window_id() const {

    return data_->initiator_window_id_$flag
        ? std::make_optional(data_->initiator_window_id_$value)
        : std::nullopt;
  }
  bool open_in_background() const {
    return data_->open_in_background;
  }
 private:
  internal::CreateActorTabOptions_Data* data_ = nullptr;
};


class CaptureRegionParamsDataView {
 public:
  CaptureRegionParamsDataView() = default;

  CaptureRegionParamsDataView(
      internal::CaptureRegionParams_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  int32_t tab_id() const {
    return data_->tab_id;
  }
  inline void GetOptionsDataView(
      TabContextOptionsDataView* output);

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


class ActivateTabOptionsDataView {
 public:
  ActivateTabOptionsDataView() = default;

  ActivateTabOptionsDataView(
      internal::ActivateTabOptions_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

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

  template <typename UserType>
  [[nodiscard]] bool ReadPattern(UserType* output) {
    
    auto* pointer = data_->pattern.Get();
    return mojo::internal::Deserialize<mojo::StringDataView>(
        pointer, output, message_);
  }
  std::optional<int32_t> fallback_window_id() const {

    return data_->fallback_window_id_$flag
        ? std::make_optional(data_->fallback_window_id_$value)
        : std::nullopt;
  }
 private:
  internal::ActivateTabOptions_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class CreateTabOptionsDataView {
 public:
  CreateTabOptionsDataView() = default;

  CreateTabOptionsDataView(
      internal::CreateTabOptions_Data* data,
      mojo::Message* message)
      : data_(data) {}

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

    return data_->window_id_$flag
        ? std::make_optional(data_->window_id_$value)
        : std::nullopt;
  }
 private:
  internal::CreateTabOptions_Data* data_ = nullptr;
};


class ConversationInfoDataView {
 public:
  ConversationInfoDataView() = default;

  ConversationInfoDataView(
      internal::ConversationInfo_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

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

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

  template <typename UserType>
  [[nodiscard]] bool ReadConversationTitle(UserType* output) {
    
    auto* pointer = data_->conversation_title.Get();
    return mojo::internal::Deserialize<mojo::StringDataView>(
        pointer, output, message_);
  }
  inline void GetClientDataDataView(
      ::mojo_base::mojom::ByteStringDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadClientData(UserType* output) {
    
static_assert(
    mojo::internal::IsValidUserTypeForOptionalValue<
        ::mojo_base::mojom::ByteStringDataView, UserType>(),
    "Attempting to read the optional `client_data` 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 `MaybeReadClientData` instead "
    "of `ReadClientData if you're fine with null values being "
    "silently ignored in this case.");
    auto* pointer = data_->client_data.Get();
    return mojo::internal::Deserialize<::mojo_base::mojom::ByteStringDataView>(
        pointer, output, message_);
  }
  inline void GetTurnIdDataView(
      mojo::StringDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadTurnId(UserType* output) {
    
static_assert(
    mojo::internal::IsValidUserTypeForOptionalValue<
        mojo::StringDataView, UserType>(),
    "Attempting to read the optional `turn_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 `MaybeReadTurnId` instead "
    "of `ReadTurnId if you're fine with null values being "
    "silently ignored in this case.");
    auto* pointer = data_->turn_id.Get();
    return mojo::internal::Deserialize<mojo::StringDataView>(
        pointer, output, message_);
  }
 private:
  internal::ConversationInfo_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class PanelOpeningDataDataView {
 public:
  PanelOpeningDataDataView() = default;

  PanelOpeningDataDataView(
      internal::PanelOpeningData_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  inline void GetPanelStateDataView(
      PanelStateDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadPanelState(UserType* output) {
    
    auto* pointer = data_->panel_state.Get();
    return mojo::internal::Deserialize<::glic::mojom::PanelStateDataView>(
        pointer, output, message_);
  }
  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);
  }
  InvocationSource invocation_source() const {
    return ::mojo::internal::ToKnownEnumValueHelper(
          static_cast<::glic::mojom::InvocationSource>(data_->invocation_source));
  }
  inline void GetPromptSuggestionDataView(
      mojo::StringDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadPromptSuggestion(UserType* output) {
    
static_assert(
    mojo::internal::IsValidUserTypeForOptionalValue<
        mojo::StringDataView, UserType>(),
    "Attempting to read the optional `prompt_suggestion` 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 `MaybeReadPromptSuggestion` instead "
    "of `ReadPromptSuggestion if you're fine with null values being "
    "silently ignored in this case.");
    auto* pointer = data_->prompt_suggestion.Get();
    return mojo::internal::Deserialize<mojo::StringDataView>(
        pointer, output, message_);
  }
  bool auto_send() const {
    return data_->auto_send;
  }
  inline void GetSkillToInvokeDataView(
      SkillDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadSkillToInvoke(UserType* output) {
    
static_assert(
    mojo::internal::IsValidUserTypeForOptionalValue<
        ::glic::mojom::SkillDataView, UserType>(),
    "Attempting to read the optional `skill_to_invoke` 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 `MaybeReadSkillToInvoke` instead "
    "of `ReadSkillToInvoke if you're fine with null values being "
    "silently ignored in this case.");
    auto* pointer = data_->skill_to_invoke.Get();
    return mojo::internal::Deserialize<::glic::mojom::SkillDataView>(
        pointer, output, message_);
  }
  inline void GetRecentlyActiveConversationsDataView(
      mojo::ArrayDataView<ConversationInfoDataView>* output);

  template <typename UserType>
  [[nodiscard]] bool ReadRecentlyActiveConversations(UserType* output) {
    
static_assert(
    mojo::internal::IsValidUserTypeForOptionalValue<
        mojo::ArrayDataView<::glic::mojom::ConversationInfoDataView>, UserType>(),
    "Attempting to read the optional `recently_active_conversations` 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 `MaybeReadRecentlyActiveConversations` instead "
    "of `ReadRecentlyActiveConversations if you're fine with null values being "
    "silently ignored in this case.");
    auto* pointer = data_->recently_active_conversations.Get();
    return mojo::internal::Deserialize<mojo::ArrayDataView<::glic::mojom::ConversationInfoDataView>>(
        pointer, output, message_);
  }
  inline void GetConversationInfoDataView(
      ConversationInfoDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadConversationInfo(UserType* output) {
    
    auto* pointer = data_->conversation_info.Get();
    return mojo::internal::Deserialize<::glic::mojom::ConversationInfoDataView>(
        pointer, output, message_);
  }
  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);
  }
  FreOverride fre_override() const {
    return ::mojo::internal::ToKnownEnumValueHelper(
          static_cast<::glic::mojom::FreOverride>(data_->fre_override));
  }
 private:
  internal::PanelOpeningData_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class PanelStateDataView {
 public:
  PanelStateDataView() = default;

  PanelStateDataView(
      internal::PanelState_Data* data,
      mojo::Message* message)
      : data_(data) {}

  bool is_null() const { return !data_; }
  template <typename UserType>
  [[nodiscard]] bool ReadKind(UserType* output) const {
    auto data_value = data_->kind;
    return mojo::internal::Deserialize<::glic::mojom::PanelStateKind>(
        data_value, output);
  }
  PanelStateKind kind() const {
    return ::mojo::internal::ToKnownEnumValueHelper(
          static_cast<::glic::mojom::PanelStateKind>(data_->kind));
  }
  std::optional<int32_t> window_id() const {

    return data_->window_id_$flag
        ? std::make_optional(data_->window_id_$value)
        : std::nullopt;
  }
 private:
  internal::PanelState_Data* data_ = nullptr;
};


class SkillsPayloadDataView {
 public:
  SkillsPayloadDataView() = default;

  SkillsPayloadDataView(
      internal::SkillsPayload_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

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

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

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

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


class UniversalCartPayloadDataView {
 public:
  UniversalCartPayloadDataView() = default;

  UniversalCartPayloadDataView(
      internal::UniversalCartPayload_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  inline void GetSerializedMetadataDataView(
      mojo::ArrayDataView<uint8_t>* output);

  template <typename UserType>
  [[nodiscard]] bool ReadSerializedMetadata(UserType* output) {
    
    auto* pointer = data_->serialized_metadata.Get();
    return mojo::internal::Deserialize<mojo::ArrayDataView<uint8_t>>(
        pointer, output, message_);
  }
 private:
  internal::UniversalCartPayload_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class InvokeOptionsDataView {
 public:
  InvokeOptionsDataView() = default;

  InvokeOptionsDataView(
      internal::InvokeOptions_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);
  }
  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) {
    
static_assert(
    mojo::internal::IsValidUserTypeForOptionalValue<
        mojo::ArrayDataView<mojo::StringDataView>, UserType>(),
    "Attempting to read the optional `prompts` 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 `MaybeReadPrompts` instead "
    "of `ReadPrompts if you're fine with null values being "
    "silently ignored in this case.");
    auto* pointer = data_->prompts.Get();
    return mojo::internal::Deserialize<mojo::ArrayDataView<mojo::StringDataView>>(
        pointer, output, message_);
  }
  inline void GetContextDataView(
      AdditionalContextDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadContext(UserType* output) {
    
static_assert(
    mojo::internal::IsValidUserTypeForOptionalValue<
        ::glic::mojom::AdditionalContextDataView, UserType>(),
    "Attempting to read the optional `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 `MaybeReadContext` instead "
    "of `ReadContext if you're fine with null values being "
    "silently ignored in this case.");
    auto* pointer = data_->context.Get();
    return mojo::internal::Deserialize<::glic::mojom::AdditionalContextDataView>(
        pointer, output, message_);
  }
  bool auto_submit() const {
    return data_->auto_submit;
  }
  template <typename UserType>
  [[nodiscard]] bool ReadFeatureMode(UserType* output) const {
    auto data_value = data_->feature_mode;
    return mojo::internal::Deserialize<::glic::mojom::FeatureMode>(
        data_value, output);
  }
  ::glic::mojom::FeatureMode feature_mode() const {
    return ::mojo::internal::ToKnownEnumValueHelper(
          static_cast<::glic::mojom::FeatureMode>(data_->feature_mode));
  }
  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);
  }
  ActuationTarget actuation_target() const {
    return ::mojo::internal::ToKnownEnumValueHelper(
          static_cast<::glic::mojom::ActuationTarget>(data_->actuation_target));
  }
  bool disable_zero_state_suggestions() const {
    return data_->disable_zero_state_suggestions;
  }
  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 GetZssConfigDataView(
      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 GetPayloadDataView(
      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_);
  }
  std::optional<int32_t> actuation_tab_id() const {
    if (data_->header_.version < 1) {
      return std::nullopt;
    }

    return data_->actuation_tab_id_$flag
        ? std::make_optional(data_->actuation_tab_id_$value)
        : std::nullopt;
  }
 private:
  internal::InvokeOptions_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class OnResponseStoppedDetailsDataView {
 public:
  OnResponseStoppedDetailsDataView() = default;

  OnResponseStoppedDetailsDataView(
      internal::OnResponseStoppedDetails_Data* data,
      mojo::Message* message)
      : data_(data) {}

  bool is_null() const { return !data_; }
  template <typename UserType>
  [[nodiscard]] bool ReadCause(UserType* output) const {
    auto data_value = data_->cause;
    return mojo::internal::Deserialize<::glic::mojom::ResponseStopCause>(
        data_value, output);
  }
  ResponseStopCause cause() const {
    return ::mojo::internal::ToKnownEnumValueHelper(
          static_cast<::glic::mojom::ResponseStopCause>(data_->cause));
  }
 private:
  internal::OnResponseStoppedDetails_Data* data_ = nullptr;
};


class OpenPanelInfoDataView {
 public:
  OpenPanelInfoDataView() = default;

  OpenPanelInfoDataView(
      internal::OpenPanelInfo_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  template <typename UserType>
  [[nodiscard]] bool ReadWebClientMode(UserType* output) const {
    auto data_value = data_->web_client_mode;
    return mojo::internal::Deserialize<::glic::mojom::WebClientMode>(
        data_value, output);
  }
  WebClientMode web_client_mode() const {
    return ::mojo::internal::ToKnownEnumValueHelper(
          static_cast<::glic::mojom::WebClientMode>(data_->web_client_mode));
  }
  inline void GetPanelSizeDataView(
      ::gfx::mojom::SizeDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadPanelSize(UserType* output) {
    
static_assert(
    mojo::internal::IsValidUserTypeForOptionalValue<
        ::gfx::mojom::SizeDataView, UserType>(),
    "Attempting to read the optional `panelSize` 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 `MaybeReadPanelSize` instead "
    "of `ReadPanelSize if you're fine with null values being "
    "silently ignored in this case.");
    auto* pointer = data_->panelSize.Get();
    return mojo::internal::Deserialize<::gfx::mojom::SizeDataView>(
        pointer, output, message_);
  }
  inline void GetResizeDurationDataView(
      ::mojo_base::mojom::TimeDeltaDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadResizeDuration(UserType* output) {
    
    auto* pointer = data_->resizeDuration.Get();
    return mojo::internal::Deserialize<::mojo_base::mojom::TimeDeltaDataView>(
        pointer, output, message_);
  }
  bool can_user_resize() const {
    return data_->can_user_resize;
  }
 private:
  internal::OpenPanelInfo_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class ContextDataDataView {
 public:
  ContextDataDataView() = default;

  ContextDataDataView(
      internal::ContextData_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

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

  template <typename UserType>
  [[nodiscard]] bool ReadMimeType(UserType* output) {
    
    auto* pointer = data_->mime_type.Get();
    return mojo::internal::Deserialize<mojo::StringDataView>(
        pointer, output, message_);
  }
  inline void GetDataDataView(
      ::mojo_base::mojom::BigBufferDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadData(UserType* output) {
    
    auto* pointer = !data_->data.is_null() ? &data_->data : nullptr;
    return mojo::internal::Deserialize<::mojo_base::mojom::BigBufferDataView>(
        pointer, output, message_);
  }
  inline void GetFilenameDataView(
      mojo::StringDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadFilename(UserType* output) {
    
static_assert(
    mojo::internal::IsValidUserTypeForOptionalValue<
        mojo::StringDataView, UserType>(),
    "Attempting to read the optional `filename` 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 `MaybeReadFilename` instead "
    "of `ReadFilename if you're fine with null values being "
    "silently ignored in this case.");
    auto* pointer = data_->filename.Get();
    return mojo::internal::Deserialize<mojo::StringDataView>(
        pointer, output, message_);
  }
 private:
  internal::ContextData_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class ParentConversationMetadataDataView {
 public:
  ParentConversationMetadataDataView() = default;

  ParentConversationMetadataDataView(
      internal::ParentConversationMetadata_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

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

  template <typename UserType>
  [[nodiscard]] bool ReadConversationId(UserType* output) {
    
static_assert(
    mojo::internal::IsValidUserTypeForOptionalValue<
        mojo::StringDataView, UserType>(),
    "Attempting to read the optional `conversation_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 `MaybeReadConversationId` instead "
    "of `ReadConversationId if you're fine with null values being "
    "silently ignored in this case.");
    auto* pointer = data_->conversation_id.Get();
    return mojo::internal::Deserialize<mojo::StringDataView>(
        pointer, output, message_);
  }
  inline void GetConversationTitleDataView(
      mojo::StringDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadConversationTitle(UserType* output) {
    
static_assert(
    mojo::internal::IsValidUserTypeForOptionalValue<
        mojo::StringDataView, UserType>(),
    "Attempting to read the optional `conversation_title` 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 `MaybeReadConversationTitle` instead "
    "of `ReadConversationTitle if you're fine with null values being "
    "silently ignored in this case.");
    auto* pointer = data_->conversation_title.Get();
    return mojo::internal::Deserialize<mojo::StringDataView>(
        pointer, output, message_);
  }
 private:
  internal::ParentConversationMetadata_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class AdditionalContextDataView {
 public:
  AdditionalContextDataView() = default;

  AdditionalContextDataView(
      internal::AdditionalContext_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

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

  template <typename UserType>
  [[nodiscard]] bool ReadName(UserType* output) {
    
static_assert(
    mojo::internal::IsValidUserTypeForOptionalValue<
        mojo::StringDataView, UserType>(),
    "Attempting to read the optional `name` 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 `MaybeReadName` instead "
    "of `ReadName if you're fine with null values being "
    "silently ignored in this case.");
    auto* pointer = data_->name.Get();
    return mojo::internal::Deserialize<mojo::StringDataView>(
        pointer, output, message_);
  }
  std::optional<int32_t> tab_id() const {

    return data_->tab_id_$flag
        ? std::make_optional(data_->tab_id_$value)
        : std::nullopt;
  }
  inline void GetOriginDataView(
      ::url::mojom::OriginDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadOrigin(UserType* output) {
    
static_assert(
    mojo::internal::IsValidUserTypeForOptionalValue<
        ::url::mojom::OriginDataView, UserType>(),
    "Attempting to read the optional `origin` 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 `MaybeReadOrigin` instead "
    "of `ReadOrigin if you're fine with null values being "
    "silently ignored in this case.");
    auto* pointer = data_->origin.Get();
    return mojo::internal::Deserialize<::url::mojom::OriginDataView>(
        pointer, output, message_);
  }
  inline void GetFrameUrlDataView(
      ::url::mojom::UrlDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadFrameUrl(UserType* output) {
    
static_assert(
    mojo::internal::IsValidUserTypeForOptionalValue<
        ::url::mojom::UrlDataView, UserType>(),
    "Attempting to read the optional `frameUrl` 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 `MaybeReadFrameUrl` instead "
    "of `ReadFrameUrl if you're fine with null values being "
    "silently ignored in this case.");
    auto* pointer = data_->frameUrl.Get();
    return mojo::internal::Deserialize<::url::mojom::UrlDataView>(
        pointer, output, message_);
  }
  inline void GetPartsDataView(
      mojo::ArrayDataView<AdditionalContextPartDataView>* output);

  template <typename UserType>
  [[nodiscard]] bool ReadParts(UserType* output) {
    
    auto* pointer = data_->parts.Get();
    return mojo::internal::Deserialize<mojo::ArrayDataView<::glic::mojom::AdditionalContextPartDataView>>(
        pointer, output, message_);
  }
 private:
  internal::AdditionalContext_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class ExperimentalTriggeringUpdateDataView {
 public:
  ExperimentalTriggeringUpdateDataView() = default;

  ExperimentalTriggeringUpdateDataView(
      internal::ExperimentalTriggeringUpdate_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

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

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

  template <typename UserType>
  [[nodiscard]] bool ReadMetadata(UserType* output) {
    
static_assert(
    mojo::internal::IsValidUserTypeForOptionalValue<
        mojo::MapDataView<mojo::StringDataView, mojo::StringDataView>, UserType>(),
    "Attempting to read the optional `metadata` 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 `MaybeReadMetadata` instead "
    "of `ReadMetadata if you're fine with null values being "
    "silently ignored in this case.");
    auto* pointer = data_->metadata.Get();
    return mojo::internal::Deserialize<mojo::MapDataView<mojo::StringDataView, mojo::StringDataView>>(
        pointer, output, message_);
  }
 private:
  internal::ExperimentalTriggeringUpdate_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class TabContextResultDataView {
 public:
  TabContextResultDataView() = default;

  TabContextResultDataView(
      internal::TabContextResult_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  inline void GetTabDataDataView(
      TabDataDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadTabData(UserType* output) {
    
    auto* pointer = data_->tab_data.Get();
    return mojo::internal::Deserialize<::glic::mojom::TabDataDataView>(
        pointer, output, message_);
  }
  inline void GetWebPageDataDataView(
      WebPageDataDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadWebPageData(UserType* output) {
    
static_assert(
    mojo::internal::IsValidUserTypeForOptionalValue<
        ::glic::mojom::WebPageDataDataView, UserType>(),
    "Attempting to read the optional `web_page_data` 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 `MaybeReadWebPageData` instead "
    "of `ReadWebPageData if you're fine with null values being "
    "silently ignored in this case.");
    auto* pointer = data_->web_page_data.Get();
    return mojo::internal::Deserialize<::glic::mojom::WebPageDataDataView>(
        pointer, output, message_);
  }
  inline void GetViewportScreenshotDataView(
      ScreenshotDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadViewportScreenshot(UserType* output) {
    
static_assert(
    mojo::internal::IsValidUserTypeForOptionalValue<
        ::glic::mojom::ScreenshotDataView, UserType>(),
    "Attempting to read the optional `viewport_screenshot` 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 `MaybeReadViewportScreenshot` instead "
    "of `ReadViewportScreenshot if you're fine with null values being "
    "silently ignored in this case.");
    auto* pointer = data_->viewport_screenshot.Get();
    return mojo::internal::Deserialize<::glic::mojom::ScreenshotDataView>(
        pointer, output, message_);
  }
  inline void GetScreenshotInfoDataView(
      ::mojo_base::mojom::ProtoWrapperDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadScreenshotInfo(UserType* output) {
    
static_assert(
    mojo::internal::IsValidUserTypeForOptionalValue<
        ::mojo_base::mojom::ProtoWrapperDataView, UserType>(),
    "Attempting to read the optional `screenshot_info` 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 `MaybeReadScreenshotInfo` instead "
    "of `ReadScreenshotInfo if you're fine with null values being "
    "silently ignored in this case.");
    auto* pointer = data_->screenshot_info.Get();
    return mojo::internal::Deserialize<::mojo_base::mojom::ProtoWrapperDataView>(
        pointer, output, message_);
  }
  inline void GetPdfDocumentDataDataView(
      PdfDocumentDataDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadPdfDocumentData(UserType* output) {
    
static_assert(
    mojo::internal::IsValidUserTypeForOptionalValue<
        ::glic::mojom::PdfDocumentDataDataView, UserType>(),
    "Attempting to read the optional `pdf_document_data` 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 `MaybeReadPdfDocumentData` instead "
    "of `ReadPdfDocumentData if you're fine with null values being "
    "silently ignored in this case.");
    auto* pointer = data_->pdf_document_data.Get();
    return mojo::internal::Deserialize<::glic::mojom::PdfDocumentDataDataView>(
        pointer, output, message_);
  }
  inline void GetAnnotatedPageDataDataView(
      AnnotatedPageDataDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadAnnotatedPageData(UserType* output) {
    
static_assert(
    mojo::internal::IsValidUserTypeForOptionalValue<
        ::glic::mojom::AnnotatedPageDataDataView, UserType>(),
    "Attempting to read the optional `annotated_page_data` 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 `MaybeReadAnnotatedPageData` instead "
    "of `ReadAnnotatedPageData if you're fine with null values being "
    "silently ignored in this case.");
    auto* pointer = data_->annotated_page_data.Get();
    return mojo::internal::Deserialize<::glic::mojom::AnnotatedPageDataDataView>(
        pointer, output, message_);
  }
 private:
  internal::TabContextResult_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class WebPageDataDataView {
 public:
  WebPageDataDataView() = default;

  WebPageDataDataView(
      internal::WebPageData_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  inline void GetMainDocumentDataView(
      DocumentDataDataView* output);

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


class DocumentDataDataView {
 public:
  DocumentDataDataView() = default;

  DocumentDataDataView(
      internal::DocumentData_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  inline void GetOriginDataView(
      ::url::mojom::OriginDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadOrigin(UserType* output) {
    
    auto* pointer = data_->origin.Get();
    return mojo::internal::Deserialize<::url::mojom::OriginDataView>(
        pointer, output, message_);
  }
  inline void GetInnerTextDataView(
      mojo::StringDataView* output);

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


class PdfDocumentDataDataView {
 public:
  PdfDocumentDataDataView() = default;

  PdfDocumentDataDataView(
      internal::PdfDocumentData_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  inline void GetOriginDataView(
      ::url::mojom::OriginDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadOrigin(UserType* output) {
    
    auto* pointer = data_->origin.Get();
    return mojo::internal::Deserialize<::url::mojom::OriginDataView>(
        pointer, output, message_);
  }
  inline void GetPdfDataDataView(
      mojo::ArrayDataView<uint8_t>* output);

  template <typename UserType>
  [[nodiscard]] bool ReadPdfData(UserType* output) {
    
static_assert(
    mojo::internal::IsValidUserTypeForOptionalValue<
        mojo::ArrayDataView<uint8_t>, UserType>(),
    "Attempting to read the optional `pdf_data` 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 `MaybeReadPdfData` instead "
    "of `ReadPdfData if you're fine with null values being "
    "silently ignored in this case.");
    auto* pointer = data_->pdf_data.Get();
    return mojo::internal::Deserialize<mojo::ArrayDataView<uint8_t>>(
        pointer, output, message_);
  }
  bool pdf_size_limit_exceeded() const {
    return data_->pdf_size_limit_exceeded;
  }
 private:
  internal::PdfDocumentData_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class TabDataDataView {
 public:
  TabDataDataView() = default;

  TabDataDataView(
      internal::TabData_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  int32_t tab_id() const {
    return data_->tab_id;
  }
  int32_t window_id() const {
    return data_->window_id;
  }
  inline void GetUrlDataView(
      ::url::mojom::UrlDataView* output);

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

  template <typename UserType>
  [[nodiscard]] bool ReadTitle(UserType* output) {
    
static_assert(
    mojo::internal::IsValidUserTypeForOptionalValue<
        mojo::StringDataView, UserType>(),
    "Attempting to read the optional `title` 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 `MaybeReadTitle` instead "
    "of `ReadTitle if you're fine with null values being "
    "silently ignored in this case.");
    auto* pointer = data_->title.Get();
    return mojo::internal::Deserialize<mojo::StringDataView>(
        pointer, output, message_);
  }
  inline void GetFaviconDataView(
      ::skia::mojom::BitmapN32DataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadFavicon(UserType* output) {
    
static_assert(
    mojo::internal::IsValidUserTypeForOptionalValue<
        ::skia::mojom::BitmapN32DataView, UserType>(),
    "Attempting to read the optional `favicon` 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 `MaybeReadFavicon` instead "
    "of `ReadFavicon if you're fine with null values being "
    "silently ignored in this case.");
    auto* pointer = data_->favicon.Get();
    return mojo::internal::Deserialize<::skia::mojom::BitmapN32DataView>(
        pointer, output, message_);
  }
  inline void GetFaviconUrlDataView(
      ::url::mojom::UrlDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadFaviconUrl(UserType* output) {
    
static_assert(
    mojo::internal::IsValidUserTypeForOptionalValue<
        ::url::mojom::UrlDataView, UserType>(),
    "Attempting to read the optional `favicon_url` 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 `MaybeReadFaviconUrl` instead "
    "of `ReadFaviconUrl if you're fine with null values being "
    "silently ignored in this case.");
    auto* pointer = data_->favicon_url.Get();
    return mojo::internal::Deserialize<::url::mojom::UrlDataView>(
        pointer, output, message_);
  }
  inline void GetDocumentMimeTypeDataView(
      mojo::StringDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadDocumentMimeType(UserType* output) {
    
    auto* pointer = data_->document_mime_type.Get();
    return mojo::internal::Deserialize<mojo::StringDataView>(
        pointer, output, message_);
  }
  std::optional<bool> is_observable() const {

    return data_->is_observable_$flag
        ? std::make_optional(!!data_->is_observable_$value)
        : std::nullopt;
  }
  std::optional<bool> is_media_active() const {

    return data_->is_media_active_$flag
        ? std::make_optional(!!data_->is_media_active_$value)
        : std::nullopt;
  }
  std::optional<bool> is_tab_content_captured() const {

    return data_->is_tab_content_captured_$flag
        ? std::make_optional(!!data_->is_tab_content_captured_$value)
        : std::nullopt;
  }
  std::optional<bool> is_active_in_window() const {

    return data_->is_active_in_window_$flag
        ? std::make_optional(!!data_->is_active_in_window_$value)
        : std::nullopt;
  }
  std::optional<bool> is_window_active() const {

    return data_->is_window_active_$flag
        ? std::make_optional(!!data_->is_window_active_$value)
        : std::nullopt;
  }
  inline void GetLightweightPageFeaturesDataView(
      mojo::ArrayDataView<LightweightPageFeature>* output);

  template <typename UserType>
  [[nodiscard]] bool ReadLightweightPageFeatures(UserType* output) {
    
static_assert(
    mojo::internal::IsValidUserTypeForOptionalValue<
        mojo::ArrayDataView<::glic::mojom::LightweightPageFeature>, UserType>(),
    "Attempting to read the optional `lightweight_page_features` 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 `MaybeReadLightweightPageFeatures` instead "
    "of `ReadLightweightPageFeatures if you're fine with null values being "
    "silently ignored in this case.");
    auto* pointer = data_->lightweight_page_features.Get();
    return mojo::internal::Deserialize<mojo::ArrayDataView<::glic::mojom::LightweightPageFeature>>(
        pointer, output, message_);
  }
 private:
  internal::TabData_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class NoFocusedTabDataDataView {
 public:
  NoFocusedTabDataDataView() = default;

  NoFocusedTabDataDataView(
      internal::NoFocusedTabData_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  inline void GetActiveTabDataDataView(
      TabDataDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadActiveTabData(UserType* output) {
    
static_assert(
    mojo::internal::IsValidUserTypeForOptionalValue<
        ::glic::mojom::TabDataDataView, UserType>(),
    "Attempting to read the optional `active_tab_data` 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 `MaybeReadActiveTabData` instead "
    "of `ReadActiveTabData if you're fine with null values being "
    "silently ignored in this case.");
    auto* pointer = data_->active_tab_data.Get();
    return mojo::internal::Deserialize<::glic::mojom::TabDataDataView>(
        pointer, output, message_);
  }
  inline void GetNoFocusReasonDataView(
      mojo::StringDataView* output);

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


class AnnotatedPageDataDataView {
 public:
  AnnotatedPageDataDataView() = default;

  AnnotatedPageDataDataView(
      internal::AnnotatedPageData_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  inline void GetAnnotatedPageContentDataView(
      ::mojo_base::mojom::ProtoWrapperDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadAnnotatedPageContent(UserType* output) {
    
static_assert(
    mojo::internal::IsValidUserTypeForOptionalValue<
        ::mojo_base::mojom::ProtoWrapperDataView, UserType>(),
    "Attempting to read the optional `annotated_page_content` 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 `MaybeReadAnnotatedPageContent` instead "
    "of `ReadAnnotatedPageContent if you're fine with null values being "
    "silently ignored in this case.");
    auto* pointer = data_->annotated_page_content.Get();
    return mojo::internal::Deserialize<::mojo_base::mojom::ProtoWrapperDataView>(
        pointer, output, message_);
  }
  inline void GetMetadataDataView(
      ::blink::mojom::PageMetadataDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadMetadata(UserType* output) {
    
static_assert(
    mojo::internal::IsValidUserTypeForOptionalValue<
        ::blink::mojom::PageMetadataDataView, UserType>(),
    "Attempting to read the optional `metadata` 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 `MaybeReadMetadata` instead "
    "of `ReadMetadata if you're fine with null values being "
    "silently ignored in this case.");
    auto* pointer = data_->metadata.Get();
    return mojo::internal::Deserialize<::blink::mojom::PageMetadataDataView>(
        pointer, output, message_);
  }
 private:
  internal::AnnotatedPageData_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class ImageOriginAnnotationsDataView {
 public:
  ImageOriginAnnotationsDataView() = default;

  ImageOriginAnnotationsDataView(
      internal::ImageOriginAnnotations_Data* data,
      mojo::Message* message)
      : data_(data) {}

  bool is_null() const { return !data_; }
 private:
  internal::ImageOriginAnnotations_Data* data_ = nullptr;
};


class JournalDataView {
 public:
  JournalDataView() = default;

  JournalDataView(
      internal::Journal_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  inline void GetDataDataView(
      mojo::ArrayDataView<uint8_t>* output);

  template <typename UserType>
  [[nodiscard]] bool ReadData(UserType* output) {
    
    auto* pointer = data_->data.Get();
    return mojo::internal::Deserialize<mojo::ArrayDataView<uint8_t>>(
        pointer, output, message_);
  }
 private:
  internal::Journal_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class PendingCapturedRegionDataView {
 public:
  PendingCapturedRegionDataView() = default;

  PendingCapturedRegionDataView(
      internal::PendingCapturedRegion_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  inline void GetIdDataView(
      ::mojo_base::mojom::UnguessableTokenDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadId(UserType* output) {
    
    auto* pointer = data_->id.Get();
    return mojo::internal::Deserialize<::mojo_base::mojom::UnguessableTokenDataView>(
        pointer, output, message_);
  }
  inline void GetRegionDataView(
      CapturedRegionDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadRegion(UserType* output) {
    
    auto* pointer = !data_->region.is_null() ? &data_->region : nullptr;
    return mojo::internal::Deserialize<::glic::mojom::CapturedRegionDataView>(
        pointer, output, message_);
  }
 private:
  internal::PendingCapturedRegion_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class CaptureRegionResultDataView {
 public:
  CaptureRegionResultDataView() = default;

  CaptureRegionResultDataView(
      internal::CaptureRegionResult_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  int32_t tab_id() const {
    return data_->tab_id;
  }
  inline void GetRegionDataView(
      CapturedRegionDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadRegion(UserType* output) {
    
    auto* pointer = !data_->region.is_null() ? &data_->region : nullptr;
    return mojo::internal::Deserialize<::glic::mojom::CapturedRegionDataView>(
        pointer, output, message_);
  }
 private:
  internal::CaptureRegionResult_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class ScreenshotDataView {
 public:
  ScreenshotDataView() = default;

  ScreenshotDataView(
      internal::Screenshot_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  uint32_t width_pixels() const {
    return data_->width_pixels;
  }
  uint32_t height_pixels() const {
    return data_->height_pixels;
  }
  inline void GetDataDataView(
      mojo::ArrayDataView<uint8_t>* output);

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

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

  template <typename UserType>
  [[nodiscard]] bool ReadOriginAnnotations(UserType* output) {
    
    auto* pointer = data_->origin_annotations.Get();
    return mojo::internal::Deserialize<::glic::mojom::ImageOriginAnnotationsDataView>(
        pointer, output, message_);
  }
  template <typename UserType>
  [[nodiscard]] bool ReadEncryptionScheme(UserType* output) const {
    auto data_value = data_->encryption_scheme;
    return mojo::internal::Deserialize<::glic::mojom::ScreenshotEncryptionScheme>(
        data_value, output);
  }
  ScreenshotEncryptionScheme encryption_scheme() const {
    return ::mojo::internal::ToKnownEnumValueHelper(
          static_cast<::glic::mojom::ScreenshotEncryptionScheme>(data_->encryption_scheme));
  }
 private:
  internal::Screenshot_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class ImageInfoDataView {
 public:
  ImageInfoDataView() = default;

  ImageInfoDataView(
      internal::ImageInfo_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

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

  template <typename UserType>
  [[nodiscard]] bool ReadCaption(UserType* output) {
    
static_assert(
    mojo::internal::IsValidUserTypeForOptionalValue<
        mojo::StringDataView, UserType>(),
    "Attempting to read the optional `caption` 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 `MaybeReadCaption` instead "
    "of `ReadCaption if you're fine with null values being "
    "silently ignored in this case.");
    auto* pointer = data_->caption.Get();
    return mojo::internal::Deserialize<mojo::StringDataView>(
        pointer, output, message_);
  }
  inline void GetSourceOriginDataView(
      ::url::mojom::OriginDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadSourceOrigin(UserType* output) {
    
static_assert(
    mojo::internal::IsValidUserTypeForOptionalValue<
        ::url::mojom::OriginDataView, UserType>(),
    "Attempting to read the optional `source_origin` 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 `MaybeReadSourceOrigin` instead "
    "of `ReadSourceOrigin if you're fine with null values being "
    "silently ignored in this case.");
    auto* pointer = data_->source_origin.Get();
    return mojo::internal::Deserialize<::url::mojom::OriginDataView>(
        pointer, output, message_);
  }
  inline void GetUrlDataView(
      ::url::mojom::UrlDataView* output);

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

  template <typename UserType>
  [[nodiscard]] bool ReadMimeType(UserType* output) {
    
static_assert(
    mojo::internal::IsValidUserTypeForOptionalValue<
        mojo::StringDataView, UserType>(),
    "Attempting to read the optional `mime_type` 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 `MaybeReadMimeType` instead "
    "of `ReadMimeType if you're fine with null values being "
    "silently ignored in this case.");
    auto* pointer = data_->mime_type.Get();
    return mojo::internal::Deserialize<mojo::StringDataView>(
        pointer, output, message_);
  }
 private:
  internal::ImageInfo_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};


class ImageBytesResultDataView {
 public:
  ImageBytesResultDataView() = default;

  ImageBytesResultDataView(
      internal::ImageBytesResult_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const { return !data_; }
  inline void GetBytesDataView(
      ::mojo_base::mojom::BigBufferDataView* output);

  template <typename UserType>
  [[nodiscard]] bool ReadBytes(UserType* output) {
    
    auto* pointer = !data_->bytes.is_null() ? &data_->bytes : nullptr;
    return mojo::internal::Deserialize<::mojo_base::mojom::BigBufferDataView>(
        pointer, output, message_);
  }
  inline void GetImageInfoDataView(
      ImageInfoDataView* output);

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


class OpenSettingsOptionsDataView {
 public:
  OpenSettingsOptionsDataView() = default;

  OpenSettingsOptionsDataView(
      internal::OpenSettingsOptions_Data* data,
      mojo::Message* message)
      : data_(data) {}

  bool is_null() const { return !data_; }
  template <typename UserType>
  [[nodiscard]] bool ReadHighlightField(UserType* output) const {
    auto data_value = data_->highlightField;
    return mojo::internal::Deserialize<::glic::mojom::SettingsPageField>(
        data_value, output);
  }
  SettingsPageField highlightField() const {
    return ::mojo::internal::ToKnownEnumValueHelper(
          static_cast<::glic::mojom::SettingsPageField>(data_->highlightField));
  }
 private:
  internal::OpenSettingsOptions_Data* data_ = nullptr;
};


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

  InvokeConversationSelectionDataView() = default;

  InvokeConversationSelectionDataView(
      internal::InvokeConversationSelection_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const {
    // For inlined unions, |data_| is always non-null. In that case we need to
    // check |data_->is_null()|.
    return !data_ || data_->is_null();
  }

  Tag tag() const { return data_->tag; }
  bool is_default_conversation() const { return data_->tag == Tag::kDefaultConversation; }
  inline void GetDefaultConversationDataView(
      DefaultConversationDataView* output) const;

  template <typename UserType>
  [[nodiscard]] bool ReadDefaultConversation(UserType* output) const {
    
    CHECK(is_default_conversation());
    return mojo::internal::Deserialize<::glic::mojom::DefaultConversationDataView>(
        data_->data.f_default_conversation.Get(), output, message_);
  }
  bool is_new_conversation() const { return data_->tag == Tag::kNewConversation; }
  inline void GetNewConversationDataView(
      NewConversationDataView* output) const;

  template <typename UserType>
  [[nodiscard]] bool ReadNewConversation(UserType* output) const {
    
    CHECK(is_new_conversation());
    return mojo::internal::Deserialize<::glic::mojom::NewConversationDataView>(
        data_->data.f_new_conversation.Get(), output, message_);
  }
  bool is_conversation_id() const { return data_->tag == Tag::kConversationId; }
  inline void GetConversationIdDataView(
      mojo::StringDataView* output) const;

  template <typename UserType>
  [[nodiscard]] bool ReadConversationId(UserType* output) const {
    
    CHECK(is_conversation_id());
    return mojo::internal::Deserialize<mojo::StringDataView>(
        data_->data.f_conversation_id.Get(), output, message_);
  }

 private:
  internal::InvokeConversationSelection_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};



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

  InvokeTargetSurfaceDataView() = default;

  InvokeTargetSurfaceDataView(
      internal::InvokeTargetSurface_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const {
    // For inlined unions, |data_| is always non-null. In that case we need to
    // check |data_->is_null()|.
    return !data_ || data_->is_null();
  }

  Tag tag() const { return data_->tag; }
  bool is_default_surface() const { return data_->tag == Tag::kDefaultSurface; }
  inline void GetDefaultSurfaceDataView(
      DefaultSurfaceMojoDataView* output) const;

  template <typename UserType>
  [[nodiscard]] bool ReadDefaultSurface(UserType* output) const {
    
    CHECK(is_default_surface());
    return mojo::internal::Deserialize<::glic::mojom::DefaultSurfaceMojoDataView>(
        data_->data.f_default_surface.Get(), output, message_);
  }
  bool is_new_tab() const { return data_->tag == Tag::kNewTab; }
  inline void GetNewTabDataView(
      NewTabMojoDataView* output) const;

  template <typename UserType>
  [[nodiscard]] bool ReadNewTab(UserType* output) const {
    
    CHECK(is_new_tab());
    return mojo::internal::Deserialize<::glic::mojom::NewTabMojoDataView>(
        data_->data.f_new_tab.Get(), output, message_);
  }

 private:
  internal::InvokeTargetSurface_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};



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

  GetContextResultDataView() = default;

  GetContextResultDataView(
      internal::GetContextResult_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const {
    // For inlined unions, |data_| is always non-null. In that case we need to
    // check |data_->is_null()|.
    return !data_ || data_->is_null();
  }

  Tag tag() const { return data_->tag; }
  bool is_error_reason() const { return data_->tag == Tag::kErrorReason; }
  inline void GetErrorReasonDataView(
      mojo::StringDataView* output) const;

  template <typename UserType>
  [[nodiscard]] bool ReadErrorReason(UserType* output) const {
    
    CHECK(is_error_reason());
    return mojo::internal::Deserialize<mojo::StringDataView>(
        data_->data.f_error_reason.Get(), output, message_);
  }
  bool is_tab_context() const { return data_->tag == Tag::kTabContext; }
  inline void GetTabContextDataView(
      TabContextResultDataView* output) const;

  template <typename UserType>
  [[nodiscard]] bool ReadTabContext(UserType* output) const {
    
    CHECK(is_tab_context());
    return mojo::internal::Deserialize<::glic::mojom::TabContextResultDataView>(
        data_->data.f_tab_context.Get(), output, message_);
  }

 private:
  internal::GetContextResult_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};



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

  CaptureScreenshotResultDataView() = default;

  CaptureScreenshotResultDataView(
      internal::CaptureScreenshotResult_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const {
    // For inlined unions, |data_| is always non-null. In that case we need to
    // check |data_->is_null()|.
    return !data_ || data_->is_null();
  }

  Tag tag() const { return data_->tag; }
  bool is_error_reason() const { return data_->tag == Tag::kErrorReason; }
  template <typename UserType>
  [[nodiscard]] bool ReadErrorReason(UserType* output) const {
    CHECK(is_error_reason());
    return mojo::internal::Deserialize<::glic::mojom::CaptureScreenshotErrorReason>(
        data_->data.f_error_reason, output);
  }
  CaptureScreenshotErrorReason error_reason() const {
    CHECK(is_error_reason());
    // TODO(dcheng): This seems incorrect, as it bypasses enum traits.
    return ::mojo::internal::ToKnownEnumValueHelper(
        static_cast<::glic::mojom::CaptureScreenshotErrorReason>(data_->data.f_error_reason));
  }
  bool is_screenshot() const { return data_->tag == Tag::kScreenshot; }
  inline void GetScreenshotDataView(
      ScreenshotDataView* output) const;

  template <typename UserType>
  [[nodiscard]] bool ReadScreenshot(UserType* output) const {
    
    CHECK(is_screenshot());
    return mojo::internal::Deserialize<::glic::mojom::ScreenshotDataView>(
        data_->data.f_screenshot.Get(), output, message_);
  }

 private:
  internal::CaptureScreenshotResult_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};



class ScrollToSelectorDataView {
 public:
  using Tag = internal::ScrollToSelector_Data::ScrollToSelector_Tag;

  ScrollToSelectorDataView() = default;

  ScrollToSelectorDataView(
      internal::ScrollToSelector_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const {
    // For inlined unions, |data_| is always non-null. In that case we need to
    // check |data_->is_null()|.
    return !data_ || data_->is_null();
  }

  Tag tag() const { return data_->tag; }
  bool is_exact_text() const { return data_->tag == Tag::kExactText; }
  inline void GetExactTextDataView(
      ScrollToTextSelectorDataView* output) const;

  template <typename UserType>
  [[nodiscard]] bool ReadExactText(UserType* output) const {
    
    CHECK(is_exact_text());
    return mojo::internal::Deserialize<::glic::mojom::ScrollToTextSelectorDataView>(
        data_->data.f_exact_text.Get(), output, message_);
  }
  bool is_text_fragment() const { return data_->tag == Tag::kTextFragment; }
  inline void GetTextFragmentDataView(
      ScrollToTextFragmentSelectorDataView* output) const;

  template <typename UserType>
  [[nodiscard]] bool ReadTextFragment(UserType* output) const {
    
    CHECK(is_text_fragment());
    return mojo::internal::Deserialize<::glic::mojom::ScrollToTextFragmentSelectorDataView>(
        data_->data.f_text_fragment.Get(), output, message_);
  }
  bool is_node() const { return data_->tag == Tag::kNode; }
  inline void GetNodeDataView(
      ScrollToNodeSelectorDataView* output) const;

  template <typename UserType>
  [[nodiscard]] bool ReadNode(UserType* output) const {
    
    CHECK(is_node());
    return mojo::internal::Deserialize<::glic::mojom::ScrollToNodeSelectorDataView>(
        data_->data.f_node.Get(), output, message_);
  }

 private:
  internal::ScrollToSelector_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};



class InvocationPayloadDataView {
 public:
  using Tag = internal::InvocationPayload_Data::InvocationPayload_Tag;

  InvocationPayloadDataView() = default;

  InvocationPayloadDataView(
      internal::InvocationPayload_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const {
    // For inlined unions, |data_| is always non-null. In that case we need to
    // check |data_->is_null()|.
    return !data_ || data_->is_null();
  }

  Tag tag() const { return data_->tag; }
  bool is_universal_cart() const { return data_->tag == Tag::kUniversalCart; }
  inline void GetUniversalCartDataView(
      UniversalCartPayloadDataView* output) const;

  template <typename UserType>
  [[nodiscard]] bool ReadUniversalCart(UserType* output) const {
    
    CHECK(is_universal_cart());
    return mojo::internal::Deserialize<::glic::mojom::UniversalCartPayloadDataView>(
        data_->data.f_universal_cart.Get(), output, message_);
  }
  bool is_skills_payload() const { return data_->tag == Tag::kSkillsPayload; }
  inline void GetSkillsPayloadDataView(
      SkillsPayloadDataView* output) const;

  template <typename UserType>
  [[nodiscard]] bool ReadSkillsPayload(UserType* output) const {
    
    CHECK(is_skills_payload());
    return mojo::internal::Deserialize<::glic::mojom::SkillsPayloadDataView>(
        data_->data.f_skills_payload.Get(), output, message_);
  }

 private:
  internal::InvocationPayload_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};



class AdditionalContextPartDataView {
 public:
  using Tag = internal::AdditionalContextPart_Data::AdditionalContextPart_Tag;

  AdditionalContextPartDataView() = default;

  AdditionalContextPartDataView(
      internal::AdditionalContextPart_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const {
    // For inlined unions, |data_| is always non-null. In that case we need to
    // check |data_->is_null()|.
    return !data_ || data_->is_null();
  }

  Tag tag() const { return data_->tag; }
  bool is_data() const { return data_->tag == Tag::kData; }
  inline void GetDataDataView(
      ContextDataDataView* output) const;

  template <typename UserType>
  [[nodiscard]] bool ReadData(UserType* output) const {
    
    CHECK(is_data());
    return mojo::internal::Deserialize<::glic::mojom::ContextDataDataView>(
        data_->data.f_data.Get(), output, message_);
  }
  bool is_screenshot() const { return data_->tag == Tag::kScreenshot; }
  inline void GetScreenshotDataView(
      ScreenshotDataView* output) const;

  template <typename UserType>
  [[nodiscard]] bool ReadScreenshot(UserType* output) const {
    
    CHECK(is_screenshot());
    return mojo::internal::Deserialize<::glic::mojom::ScreenshotDataView>(
        data_->data.f_screenshot.Get(), output, message_);
  }
  bool is_web_page_data() const { return data_->tag == Tag::kWebPageData; }
  inline void GetWebPageDataDataView(
      WebPageDataDataView* output) const;

  template <typename UserType>
  [[nodiscard]] bool ReadWebPageData(UserType* output) const {
    
    CHECK(is_web_page_data());
    return mojo::internal::Deserialize<::glic::mojom::WebPageDataDataView>(
        data_->data.f_web_page_data.Get(), output, message_);
  }
  bool is_annotated_page_data() const { return data_->tag == Tag::kAnnotatedPageData; }
  inline void GetAnnotatedPageDataDataView(
      AnnotatedPageDataDataView* output) const;

  template <typename UserType>
  [[nodiscard]] bool ReadAnnotatedPageData(UserType* output) const {
    
    CHECK(is_annotated_page_data());
    return mojo::internal::Deserialize<::glic::mojom::AnnotatedPageDataDataView>(
        data_->data.f_annotated_page_data.Get(), output, message_);
  }
  bool is_pdf_document_data() const { return data_->tag == Tag::kPdfDocumentData; }
  inline void GetPdfDocumentDataDataView(
      PdfDocumentDataDataView* output) const;

  template <typename UserType>
  [[nodiscard]] bool ReadPdfDocumentData(UserType* output) const {
    
    CHECK(is_pdf_document_data());
    return mojo::internal::Deserialize<::glic::mojom::PdfDocumentDataDataView>(
        data_->data.f_pdf_document_data.Get(), output, message_);
  }
  bool is_tab_context() const { return data_->tag == Tag::kTabContext; }
  inline void GetTabContextDataView(
      TabContextResultDataView* output) const;

  template <typename UserType>
  [[nodiscard]] bool ReadTabContext(UserType* output) const {
    
    CHECK(is_tab_context());
    return mojo::internal::Deserialize<::glic::mojom::TabContextResultDataView>(
        data_->data.f_tab_context.Get(), output, message_);
  }
  bool is_region() const { return data_->tag == Tag::kRegion; }
  inline void GetRegionDataView(
      CapturedRegionDataView* output) const;

  template <typename UserType>
  [[nodiscard]] bool ReadRegion(UserType* output) const {
    
    CHECK(is_region());
    return mojo::internal::Deserialize<::glic::mojom::CapturedRegionDataView>(
        data_->data.f_region.Get(), output, message_);
  }
  bool is_pending_region() const { return data_->tag == Tag::kPendingRegion; }
  inline void GetPendingRegionDataView(
      PendingCapturedRegionDataView* output) const;

  template <typename UserType>
  [[nodiscard]] bool ReadPendingRegion(UserType* output) const {
    
    CHECK(is_pending_region());
    return mojo::internal::Deserialize<::glic::mojom::PendingCapturedRegionDataView>(
        data_->data.f_pending_region.Get(), output, message_);
  }
  bool is_parent_conversation_metadata() const { return data_->tag == Tag::kParentConversationMetadata; }
  inline void GetParentConversationMetadataDataView(
      ParentConversationMetadataDataView* output) const;

  template <typename UserType>
  [[nodiscard]] bool ReadParentConversationMetadata(UserType* output) const {
    
    CHECK(is_parent_conversation_metadata());
    return mojo::internal::Deserialize<::glic::mojom::ParentConversationMetadataDataView>(
        data_->data.f_parent_conversation_metadata.Get(), output, message_);
  }

 private:
  internal::AdditionalContextPart_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};



class FocusedTabDataDataView {
 public:
  using Tag = internal::FocusedTabData_Data::FocusedTabData_Tag;

  FocusedTabDataDataView() = default;

  FocusedTabDataDataView(
      internal::FocusedTabData_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const {
    // For inlined unions, |data_| is always non-null. In that case we need to
    // check |data_->is_null()|.
    return !data_ || data_->is_null();
  }

  Tag tag() const { return data_->tag; }
  bool is_focused_tab() const { return data_->tag == Tag::kFocusedTab; }
  inline void GetFocusedTabDataView(
      TabDataDataView* output) const;

  template <typename UserType>
  [[nodiscard]] bool ReadFocusedTab(UserType* output) const {
    
    CHECK(is_focused_tab());
    return mojo::internal::Deserialize<::glic::mojom::TabDataDataView>(
        data_->data.f_focused_tab.Get(), output, message_);
  }
  bool is_no_focused_tab_data() const { return data_->tag == Tag::kNoFocusedTabData; }
  inline void GetNoFocusedTabDataDataView(
      NoFocusedTabDataDataView* output) const;

  template <typename UserType>
  [[nodiscard]] bool ReadNoFocusedTabData(UserType* output) const {
    
    CHECK(is_no_focused_tab_data());
    return mojo::internal::Deserialize<::glic::mojom::NoFocusedTabDataDataView>(
        data_->data.f_no_focused_tab_data.Get(), output, message_);
  }

 private:
  internal::FocusedTabData_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};



class CapturedRegionDataView {
 public:
  using Tag = internal::CapturedRegion_Data::CapturedRegion_Tag;

  CapturedRegionDataView() = default;

  CapturedRegionDataView(
      internal::CapturedRegion_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const {
    // For inlined unions, |data_| is always non-null. In that case we need to
    // check |data_->is_null()|.
    return !data_ || data_->is_null();
  }

  Tag tag() const { return data_->tag; }
  bool is_rect() const { return data_->tag == Tag::kRect; }
  inline void GetRectDataView(
      ::gfx::mojom::RectDataView* output) const;

  template <typename UserType>
  [[nodiscard]] bool ReadRect(UserType* output) const {
    
    CHECK(is_rect());
    return mojo::internal::Deserialize<::gfx::mojom::RectDataView>(
        data_->data.f_rect.Get(), output, message_);
  }
  bool is_polyline() const { return data_->tag == Tag::kPolyline; }
  inline void GetPolylineDataView(
      mojo::ArrayDataView<::gfx::mojom::PointDataView>* output) const;

  template <typename UserType>
  [[nodiscard]] bool ReadPolyline(UserType* output) const {
    
    CHECK(is_polyline());
    return mojo::internal::Deserialize<mojo::ArrayDataView<::gfx::mojom::PointDataView>>(
        data_->data.f_polyline.Get(), output, message_);
  }

 private:
  internal::CapturedRegion_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};



class GetImageBytesResultDataView {
 public:
  using Tag = internal::GetImageBytesResult_Data::GetImageBytesResult_Tag;

  GetImageBytesResultDataView() = default;

  GetImageBytesResultDataView(
      internal::GetImageBytesResult_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const {
    // For inlined unions, |data_| is always non-null. In that case we need to
    // check |data_->is_null()|.
    return !data_ || data_->is_null();
  }

  Tag tag() const { return data_->tag; }
  bool is_image_bytes() const { return data_->tag == Tag::kImageBytes; }
  inline void GetImageBytesDataView(
      ImageBytesResultDataView* output) const;

  template <typename UserType>
  [[nodiscard]] bool ReadImageBytes(UserType* output) const {
    
    CHECK(is_image_bytes());
    return mojo::internal::Deserialize<::glic::mojom::ImageBytesResultDataView>(
        data_->data.f_image_bytes.Get(), output, message_);
  }
  bool is_error_reason() const { return data_->tag == Tag::kErrorReason; }
  inline void GetErrorReasonDataView(
      mojo::StringDataView* output) const;

  template <typename UserType>
  [[nodiscard]] bool ReadErrorReason(UserType* output) const {
    
    CHECK(is_error_reason());
    return mojo::internal::Deserialize<mojo::StringDataView>(
        data_->data.f_error_reason.Get(), output, message_);
  }

 private:
  internal::GetImageBytesResult_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};



class ActorHandler_CreateTask_ResponseParam_ResultDataView {
 public:
  using Tag = internal::ActorHandler_CreateTask_ResponseParam_Result_Data::ActorHandler_CreateTask_ResponseParam_Result_Tag;

  ActorHandler_CreateTask_ResponseParam_ResultDataView() = default;

  ActorHandler_CreateTask_ResponseParam_ResultDataView(
      internal::ActorHandler_CreateTask_ResponseParam_Result_Data* data,
      mojo::Message* message)
      : data_(data) {}

  bool is_null() const {
    // For inlined unions, |data_| is always non-null. In that case we need to
    // check |data_->is_null()|.
    return !data_ || data_->is_null();
  }

  Tag tag() const { return data_->tag; }
  bool is_success() const { return data_->tag == Tag::kSuccess; }
  int32_t success() const {
    CHECK(is_success());
    return data_->data.f_success;
  }
  bool is_failure() const { return data_->tag == Tag::kFailure; }
  template <typename UserType>
  [[nodiscard]] bool ReadFailure(UserType* output) const {
    CHECK(is_failure());
    return mojo::internal::Deserialize<::glic::mojom::CreateTaskErrorReason>(
        data_->data.f_failure, output);
  }
  CreateTaskErrorReason failure() const {
    CHECK(is_failure());
    // TODO(dcheng): This seems incorrect, as it bypasses enum traits.
    return ::mojo::internal::ToKnownEnumValueHelper(
        static_cast<::glic::mojom::CreateTaskErrorReason>(data_->data.f_failure));
  }

 private:
  internal::ActorHandler_CreateTask_ResponseParam_Result_Data* data_ = nullptr;
};



class ActorHandler_PerformActions_ResponseParam_ResultDataView {
 public:
  using Tag = internal::ActorHandler_PerformActions_ResponseParam_Result_Data::ActorHandler_PerformActions_ResponseParam_Result_Tag;

  ActorHandler_PerformActions_ResponseParam_ResultDataView() = default;

  ActorHandler_PerformActions_ResponseParam_ResultDataView(
      internal::ActorHandler_PerformActions_ResponseParam_Result_Data* data,
      mojo::Message* message)
      : data_(data), message_(message) {}

  bool is_null() const {
    // For inlined unions, |data_| is always non-null. In that case we need to
    // check |data_->is_null()|.
    return !data_ || data_->is_null();
  }

  Tag tag() const { return data_->tag; }
  bool is_success() const { return data_->tag == Tag::kSuccess; }
  inline void GetSuccessDataView(
      ::mojo_base::mojom::ProtoWrapperDataView* output) const;

  template <typename UserType>
  [[nodiscard]] bool ReadSuccess(UserType* output) const {
    
    CHECK(is_success());
    return mojo::internal::Deserialize<::mojo_base::mojom::ProtoWrapperDataView>(
        data_->data.f_success.Get(), output, message_);
  }
  bool is_failure() const { return data_->tag == Tag::kFailure; }
  template <typename UserType>
  [[nodiscard]] bool ReadFailure(UserType* output) const {
    CHECK(is_failure());
    return mojo::internal::Deserialize<::glic::mojom::PerformActionsErrorReason>(
        data_->data.f_failure, output);
  }
  PerformActionsErrorReason failure() const {
    CHECK(is_failure());
    // TODO(dcheng): This seems incorrect, as it bypasses enum traits.
    return ::mojo::internal::ToKnownEnumValueHelper(
        static_cast<::glic::mojom::PerformActionsErrorReason>(data_->data.f_failure));
  }

 private:
  internal::ActorHandler_PerformActions_ResponseParam_Result_Data* data_ = nullptr;
  mojo::Message* message_ = nullptr;
};



}  // glic::mojom

#endif  // CHROME_BROWSER_GLIC_HOST_GLIC_MOJOM_DATA_VIEW_H_