// chrome/browser/glic/host/glic.mojom-shared.cc is auto generated by mojom_bindings_generator.py, do not edit

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

#include "chrome/browser/glic/host/glic.mojom-shared.h"
#include <ostream>
#include <utility>
#include "base/strings/stringprintf.h"
#include "mojo/public/cpp/bindings/lib/validate_params.h"
#include "mojo/public/cpp/bindings/lib/validation_errors.h"
#include "mojo/public/cpp/bindings/lib/validation_util.h"
#include "third_party/perfetto/include/perfetto/tracing/traced_value.h"

#include "chrome/browser/glic/host/glic.mojom-params-data.h"
namespace glic {
namespace mojom {

NOINLINE static const char* GlicExperimentalTriggeringStateToStringHelper(GlicExperimentalTriggeringState value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case GlicExperimentalTriggeringState::kUnavailable:
      return "kUnavailable";
    case GlicExperimentalTriggeringState::kNeedsOptIn:
      return "kNeedsOptIn";
    case GlicExperimentalTriggeringState::kReady:
      return "kReady";
    default:
      return nullptr;
  }
}

std::string GlicExperimentalTriggeringStateToString(GlicExperimentalTriggeringState value) {
  const char *str = GlicExperimentalTriggeringStateToStringHelper(value);
  if (!str) {
    return base::StringPrintf("Unknown GlicExperimentalTriggeringState value: %i", static_cast<int32_t>(value));
  }
  return str;
}

std::ostream& operator<<(std::ostream& os, GlicExperimentalTriggeringState value) {
  return os << GlicExperimentalTriggeringStateToString(value);
}

NOINLINE static const char* FileUploadPolicyStateToStringHelper(FileUploadPolicyState value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case FileUploadPolicyState::kEnabled:
      return "kEnabled";
    case FileUploadPolicyState::kDisabled:
      return "kDisabled";
    default:
      return nullptr;
  }
}

std::string FileUploadPolicyStateToString(FileUploadPolicyState value) {
  const char *str = FileUploadPolicyStateToStringHelper(value);
  if (!str) {
    return base::StringPrintf("Unknown FileUploadPolicyState value: %i", static_cast<int32_t>(value));
  }
  return str;
}

std::ostream& operator<<(std::ostream& os, FileUploadPolicyState value) {
  return os << FileUploadPolicyStateToString(value);
}

NOINLINE static const char* ActuationEligibilityToStringHelper(ActuationEligibility value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case ActuationEligibility::kEligible:
      return "kEligible";
    case ActuationEligibility::kMissingAccountCapability:
      return "kMissingAccountCapability";
    case ActuationEligibility::kMissingChromeBenefits:
      return "kMissingChromeBenefits";
    case ActuationEligibility::kDisabledByPolicy:
      return "kDisabledByPolicy";
    case ActuationEligibility::kEnterpriseWithoutManagement:
      return "kEnterpriseWithoutManagement";
    case ActuationEligibility::kPlatformUnsupported:
      return "kPlatformUnsupported";
    default:
      return nullptr;
  }
}

std::string ActuationEligibilityToString(ActuationEligibility value) {
  const char *str = ActuationEligibilityToStringHelper(value);
  if (!str) {
    return base::StringPrintf("Unknown ActuationEligibility value: %i", static_cast<int32_t>(value));
  }
  return str;
}

std::ostream& operator<<(std::ostream& os, ActuationEligibility value) {
  return os << ActuationEligibilityToString(value);
}

NOINLINE static const char* MetricUserInputReactionTypeToStringHelper(MetricUserInputReactionType value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case MetricUserInputReactionType::kUnknown:
      return "kUnknown";
    case MetricUserInputReactionType::kCanned:
      return "kCanned";
    case MetricUserInputReactionType::kModel:
      return "kModel";
    default:
      return nullptr;
  }
}

std::string MetricUserInputReactionTypeToString(MetricUserInputReactionType value) {
  const char *str = MetricUserInputReactionTypeToStringHelper(value);
  if (!str) {
    return base::StringPrintf("Unknown MetricUserInputReactionType value: %i", static_cast<int32_t>(value));
  }
  return str;
}

std::ostream& operator<<(std::ostream& os, MetricUserInputReactionType value) {
  return os << MetricUserInputReactionTypeToString(value);
}

NOINLINE static const char* PerformActionsErrorReasonToStringHelper(PerformActionsErrorReason value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case PerformActionsErrorReason::kUnknown:
      return "kUnknown";
    case PerformActionsErrorReason::kInvalidProto:
      return "kInvalidProto";
    case PerformActionsErrorReason::kMissingTaskId:
      return "kMissingTaskId";
    default:
      return nullptr;
  }
}

std::string PerformActionsErrorReasonToString(PerformActionsErrorReason value) {
  const char *str = PerformActionsErrorReasonToStringHelper(value);
  if (!str) {
    return base::StringPrintf("Unknown PerformActionsErrorReason value: %i", static_cast<int32_t>(value));
  }
  return str;
}

std::ostream& operator<<(std::ostream& os, PerformActionsErrorReason value) {
  return os << PerformActionsErrorReasonToString(value);
}

NOINLINE static const char* CreateTaskErrorReasonToStringHelper(CreateTaskErrorReason value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case CreateTaskErrorReason::kUnknown:
      return "kUnknown";
    case CreateTaskErrorReason::kTaskSystemUnavailable:
      return "kTaskSystemUnavailable";
    case CreateTaskErrorReason::kExistingActiveTask:
      return "kExistingActiveTask";
    case CreateTaskErrorReason::kBlockedByPolicy:
      return "kBlockedByPolicy";
    case CreateTaskErrorReason::kConversationNotRegistered:
      return "kConversationNotRegistered";
    default:
      return nullptr;
  }
}

std::string CreateTaskErrorReasonToString(CreateTaskErrorReason value) {
  const char *str = CreateTaskErrorReasonToStringHelper(value);
  if (!str) {
    return base::StringPrintf("Unknown CreateTaskErrorReason value: %i", static_cast<int32_t>(value));
  }
  return str;
}

std::ostream& operator<<(std::ostream& os, CreateTaskErrorReason value) {
  return os << CreateTaskErrorReasonToString(value);
}

NOINLINE static const char* ActorTaskStateToStringHelper(ActorTaskState value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case ActorTaskState::kUnknown:
      return "kUnknown";
    case ActorTaskState::kIdle:
      return "kIdle";
    case ActorTaskState::kActing:
      return "kActing";
    case ActorTaskState::kPaused:
      return "kPaused";
    case ActorTaskState::kStopped:
      return "kStopped";
    default:
      return nullptr;
  }
}

std::string ActorTaskStateToString(ActorTaskState value) {
  const char *str = ActorTaskStateToStringHelper(value);
  if (!str) {
    return base::StringPrintf("Unknown ActorTaskState value: %i", static_cast<int32_t>(value));
  }
  return str;
}

std::ostream& operator<<(std::ostream& os, ActorTaskState value) {
  return os << ActorTaskStateToString(value);
}

NOINLINE static const char* ActorTaskPauseReasonToStringHelper(ActorTaskPauseReason value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case ActorTaskPauseReason::kPausedByModel:
      return "kPausedByModel";
    case ActorTaskPauseReason::kPausedByUser:
      return "kPausedByUser";
    default:
      return nullptr;
  }
}

std::string ActorTaskPauseReasonToString(ActorTaskPauseReason value) {
  const char *str = ActorTaskPauseReasonToStringHelper(value);
  if (!str) {
    return base::StringPrintf("Unknown ActorTaskPauseReason value: %i", static_cast<int32_t>(value));
  }
  return str;
}

std::ostream& operator<<(std::ostream& os, ActorTaskPauseReason value) {
  return os << ActorTaskPauseReasonToString(value);
}

NOINLINE static const char* ActorTaskStopReasonToStringHelper(ActorTaskStopReason value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case ActorTaskStopReason::kTaskComplete:
      return "kTaskComplete";
    case ActorTaskStopReason::kStoppedByUser:
      return "kStoppedByUser";
    case ActorTaskStopReason::kModelError:
      return "kModelError";
    case ActorTaskStopReason::kUserStartedNewChat:
      return "kUserStartedNewChat";
    case ActorTaskStopReason::kUserLoadedPreviousChat:
      return "kUserLoadedPreviousChat";
    default:
      return nullptr;
  }
}

std::string ActorTaskStopReasonToString(ActorTaskStopReason value) {
  const char *str = ActorTaskStopReasonToStringHelper(value);
  if (!str) {
    return base::StringPrintf("Unknown ActorTaskStopReason value: %i", static_cast<int32_t>(value));
  }
  return str;
}

std::ostream& operator<<(std::ostream& os, ActorTaskStopReason value) {
  return os << ActorTaskStopReasonToString(value);
}

NOINLINE static const char* ActorTaskInterruptReasonToStringHelper(ActorTaskInterruptReason value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case ActorTaskInterruptReason::kUnknownReason:
      return "kUnknownReason";
    case ActorTaskInterruptReason::kTaskComplete:
      return "kTaskComplete";
    case ActorTaskInterruptReason::kWaitingUserInput:
      return "kWaitingUserInput";
    case ActorTaskInterruptReason::kWaitingUserClarification:
      return "kWaitingUserClarification";
    case ActorTaskInterruptReason::kWaitingUserConfirmation:
      return "kWaitingUserConfirmation";
    case ActorTaskInterruptReason::kWaitingUserTakeOver:
      return "kWaitingUserTakeOver";
    case ActorTaskInterruptReason::kWaitingIrrelevantUserInput:
      return "kWaitingIrrelevantUserInput";
    case ActorTaskInterruptReason::kWaitingUnsafeCounterAbuseVerdict:
      return "kWaitingUnsafeCounterAbuseVerdict";
    case ActorTaskInterruptReason::kWaitingForExperimentalTriggeringConsent:
      return "kWaitingForExperimentalTriggeringConsent";
    default:
      return nullptr;
  }
}

std::string ActorTaskInterruptReasonToString(ActorTaskInterruptReason value) {
  const char *str = ActorTaskInterruptReasonToStringHelper(value);
  if (!str) {
    return base::StringPrintf("Unknown ActorTaskInterruptReason value: %i", static_cast<int32_t>(value));
  }
  return str;
}

std::ostream& operator<<(std::ostream& os, ActorTaskInterruptReason value) {
  return os << ActorTaskInterruptReasonToString(value);
}

NOINLINE static const char* CaptureScreenshotErrorReasonToStringHelper(CaptureScreenshotErrorReason value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case CaptureScreenshotErrorReason::kUnknown:
      return "kUnknown";
    case CaptureScreenshotErrorReason::kScreenCaptureRequestThrottled:
      return "kScreenCaptureRequestThrottled";
    case CaptureScreenshotErrorReason::kUserCancelledScreenPickerDialog:
      return "kUserCancelledScreenPickerDialog";
    default:
      return nullptr;
  }
}

std::string CaptureScreenshotErrorReasonToString(CaptureScreenshotErrorReason value) {
  const char *str = CaptureScreenshotErrorReasonToStringHelper(value);
  if (!str) {
    return base::StringPrintf("Unknown CaptureScreenshotErrorReason value: %i", static_cast<int32_t>(value));
  }
  return str;
}

std::ostream& operator<<(std::ostream& os, CaptureScreenshotErrorReason value) {
  return os << CaptureScreenshotErrorReasonToString(value);
}

NOINLINE static const char* SbThreatTypeToStringHelper(SbThreatType value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case SbThreatType::kUnspecified:
      return "kUnspecified";
    case SbThreatType::kSocialEngineering:
      return "kSocialEngineering";
    case SbThreatType::kMalware:
      return "kMalware";
    case SbThreatType::kUnwantedSoftware:
      return "kUnwantedSoftware";
    default:
      return nullptr;
  }
}

std::string SbThreatTypeToString(SbThreatType value) {
  const char *str = SbThreatTypeToStringHelper(value);
  if (!str) {
    return base::StringPrintf("Unknown SbThreatType value: %i", static_cast<int32_t>(value));
  }
  return str;
}

std::ostream& operator<<(std::ostream& os, SbThreatType value) {
  return os << SbThreatTypeToString(value);
}

NOINLINE static const char* PlatformToStringHelper(Platform value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case Platform::kUnknown:
      return "kUnknown";
    case Platform::kMacOS:
      return "kMacOS";
    case Platform::kWindows:
      return "kWindows";
    case Platform::kLinux:
      return "kLinux";
    case Platform::kChromeOS:
      return "kChromeOS";
    case Platform::kAndroid:
      return "kAndroid";
    default:
      return nullptr;
  }
}

std::string PlatformToString(Platform value) {
  const char *str = PlatformToStringHelper(value);
  if (!str) {
    return base::StringPrintf("Unknown Platform value: %i", static_cast<int32_t>(value));
  }
  return str;
}

std::ostream& operator<<(std::ostream& os, Platform value) {
  return os << PlatformToString(value);
}

NOINLINE static const char* FormFactorToStringHelper(FormFactor value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case FormFactor::kUnknown:
      return "kUnknown";
    case FormFactor::kDesktop:
      return "kDesktop";
    case FormFactor::kPhone:
      return "kPhone";
    case FormFactor::kTablet:
      return "kTablet";
    default:
      return nullptr;
  }
}

std::string FormFactorToString(FormFactor value) {
  const char *str = FormFactorToStringHelper(value);
  if (!str) {
    return base::StringPrintf("Unknown FormFactor value: %i", static_cast<int32_t>(value));
  }
  return str;
}

std::ostream& operator<<(std::ostream& os, FormFactor value) {
  return os << FormFactorToString(value);
}

NOINLINE static const char* ScreenshotImageFormatToStringHelper(ScreenshotImageFormat value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case ScreenshotImageFormat::kJpeg:
      return "kJpeg";
    case ScreenshotImageFormat::kPng:
      return "kPng";
    case ScreenshotImageFormat::kWebp:
      return "kWebp";
    default:
      return nullptr;
  }
}

std::string ScreenshotImageFormatToString(ScreenshotImageFormat value) {
  const char *str = ScreenshotImageFormatToStringHelper(value);
  if (!str) {
    return base::StringPrintf("Unknown ScreenshotImageFormat value: %i", static_cast<int32_t>(value));
  }
  return str;
}

std::ostream& operator<<(std::ostream& os, ScreenshotImageFormat value) {
  return os << ScreenshotImageFormatToString(value);
}

NOINLINE static const char* ScreenshotCompressionQualityToStringHelper(ScreenshotCompressionQuality value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case ScreenshotCompressionQuality::kNone:
      return "kNone";
    case ScreenshotCompressionQuality::kLow:
      return "kLow";
    case ScreenshotCompressionQuality::kMedium:
      return "kMedium";
    case ScreenshotCompressionQuality::kHigh:
      return "kHigh";
    default:
      return nullptr;
  }
}

std::string ScreenshotCompressionQualityToString(ScreenshotCompressionQuality value) {
  const char *str = ScreenshotCompressionQualityToStringHelper(value);
  if (!str) {
    return base::StringPrintf("Unknown ScreenshotCompressionQuality value: %i", static_cast<int32_t>(value));
  }
  return str;
}

std::ostream& operator<<(std::ostream& os, ScreenshotCompressionQuality value) {
  return os << ScreenshotCompressionQualityToString(value);
}

NOINLINE static const char* ScrollToErrorReasonToStringHelper(ScrollToErrorReason value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case ScrollToErrorReason::kNotSupported:
      return "kNotSupported";
    case ScrollToErrorReason::kNewerScrollToCall:
      return "kNewerScrollToCall";
    case ScrollToErrorReason::kNoFocusedTab:
      return "kNoFocusedTab";
    case ScrollToErrorReason::kNoMatchFound:
      return "kNoMatchFound";
    case ScrollToErrorReason::kFocusedTabChangedOrNavigated:
      return "kFocusedTabChangedOrNavigated";
    case ScrollToErrorReason::kNoMatchingDocument:
      return "kNoMatchingDocument";
    case ScrollToErrorReason::kSearchRangeInvalid:
      return "kSearchRangeInvalid";
    case ScrollToErrorReason::kTabContextPermissionDisabled:
      return "kTabContextPermissionDisabled";
    case ScrollToErrorReason::kDroppedByWebClient:
      return "kDroppedByWebClient";
    default:
      return nullptr;
  }
}

std::string ScrollToErrorReasonToString(ScrollToErrorReason value) {
  const char *str = ScrollToErrorReasonToStringHelper(value);
  if (!str) {
    return base::StringPrintf("Unknown ScrollToErrorReason value: %i", static_cast<int32_t>(value));
  }
  return str;
}

std::ostream& operator<<(std::ostream& os, ScrollToErrorReason value) {
  return os << ScrollToErrorReasonToString(value);
}

NOINLINE static const char* SkillSourceToStringHelper(SkillSource value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case SkillSource::kUnknown:
      return "kUnknown";
    case SkillSource::kFirstParty:
      return "kFirstParty";
    case SkillSource::kUserCreated:
      return "kUserCreated";
    case SkillSource::kDerivedFromFirstParty:
      return "kDerivedFromFirstParty";
    case SkillSource::kEnterprise:
      return "kEnterprise";
    case SkillSource::kDerivedFromEnterprise:
      return "kDerivedFromEnterprise";
    default:
      return nullptr;
  }
}

std::string SkillSourceToString(SkillSource value) {
  const char *str = SkillSourceToStringHelper(value);
  if (!str) {
    return base::StringPrintf("Unknown SkillSource value: %i", static_cast<int32_t>(value));
  }
  return str;
}

std::ostream& operator<<(std::ostream& os, SkillSource value) {
  return os << SkillSourceToString(value);
}

NOINLINE static const char* SkillsWebClientEventToStringHelper(SkillsWebClientEvent value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case SkillsWebClientEvent::kUnknown:
      return "kUnknown";
    case SkillsWebClientEvent::kUsedFirstPartySkill:
      return "kUsedFirstPartySkill";
    case SkillsWebClientEvent::kUsedUserCreatedSkill:
      return "kUsedUserCreatedSkill";
    case SkillsWebClientEvent::kUsedDerivedFirstPartySkill:
      return "kUsedDerivedFirstPartySkill";
    case SkillsWebClientEvent::kOpenedMenu:
      return "kOpenedMenu";
    case SkillsWebClientEvent::kClickedManageFromMenu:
      return "kClickedManageFromMenu";
    case SkillsWebClientEvent::kClickedAddFromMenu:
      return "kClickedAddFromMenu";
    case SkillsWebClientEvent::kClickedEditFromMenu:
      return "kClickedEditFromMenu";
    case SkillsWebClientEvent::kClickedAddOn1pSkill:
      return "kClickedAddOn1pSkill";
    case SkillsWebClientEvent::kClickedSaveAsSkillHoverChip:
      return "kClickedSaveAsSkillHoverChip";
    case SkillsWebClientEvent::kClickedEditSkillHoverChip:
      return "kClickedEditSkillHoverChip";
    case SkillsWebClientEvent::kClickedBrowseSkillFromPlusMenu:
      return "kClickedBrowseSkillFromPlusMenu";
    case SkillsWebClientEvent::kClickedSkillFromPlusMenu:
      return "kClickedSkillFromPlusMenu";
    case SkillsWebClientEvent::kClickedManageSkillFromPlusMenu:
      return "kClickedManageSkillFromPlusMenu";
    case SkillsWebClientEvent::kClickedMoreFromMenu:
      return "kClickedMoreFromMenu";
    case SkillsWebClientEvent::kClickedManageSkillFromMenu:
      return "kClickedManageSkillFromMenu";
    case SkillsWebClientEvent::kClickedSkillFromMenu:
      return "kClickedSkillFromMenu";
    case SkillsWebClientEvent::kClickedBrowseSkillsFromMenu:
      return "kClickedBrowseSkillsFromMenu";
    case SkillsWebClientEvent::kSkillBuilderClickedPromoChip:
      return "kSkillBuilderClickedPromoChip";
    case SkillsWebClientEvent::kSkillBuilderPromptGenerated:
      return "kSkillBuilderPromptGenerated";
    case SkillsWebClientEvent::kSkillBuilderClickedSaveAsSkill:
      return "kSkillBuilderClickedSaveAsSkill";
    default:
      return nullptr;
  }
}

std::string SkillsWebClientEventToString(SkillsWebClientEvent value) {
  const char *str = SkillsWebClientEventToStringHelper(value);
  if (!str) {
    return base::StringPrintf("Unknown SkillsWebClientEvent value: %i", static_cast<int32_t>(value));
  }
  return str;
}

std::ostream& operator<<(std::ostream& os, SkillsWebClientEvent value) {
  return os << SkillsWebClientEventToString(value);
}

NOINLINE static const char* PinTriggerToStringHelper(PinTrigger value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case PinTrigger::kWebClientUnknown:
      return "kWebClientUnknown";
    case PinTrigger::kCandidatesToggle:
      return "kCandidatesToggle";
    case PinTrigger::kAtMention:
      return "kAtMention";
    case PinTrigger::kActuation:
      return "kActuation";
    default:
      return nullptr;
  }
}

std::string PinTriggerToString(PinTrigger value) {
  const char *str = PinTriggerToStringHelper(value);
  if (!str) {
    return base::StringPrintf("Unknown PinTrigger value: %i", static_cast<int32_t>(value));
  }
  return str;
}

std::ostream& operator<<(std::ostream& os, PinTrigger value) {
  return os << PinTriggerToString(value);
}

NOINLINE static const char* UnpinTriggerToStringHelper(UnpinTrigger value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case UnpinTrigger::kWebClientUnknown:
      return "kWebClientUnknown";
    case UnpinTrigger::kCandidatesToggle:
      return "kCandidatesToggle";
    case UnpinTrigger::kChip:
      return "kChip";
    case UnpinTrigger::kActuation:
      return "kActuation";
    default:
      return nullptr;
  }
}

std::string UnpinTriggerToString(UnpinTrigger value) {
  const char *str = UnpinTriggerToStringHelper(value);
  if (!str) {
    return base::StringPrintf("Unknown UnpinTrigger value: %i", static_cast<int32_t>(value));
  }
  return str;
}

std::ostream& operator<<(std::ostream& os, UnpinTrigger value) {
  return os << UnpinTriggerToString(value);
}

NOINLINE static const char* CancelActionsResultToStringHelper(CancelActionsResult value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case CancelActionsResult::kUnknown:
      return "kUnknown";
    case CancelActionsResult::kSuccess:
      return "kSuccess";
    case CancelActionsResult::kTaskNotFound:
      return "kTaskNotFound";
    case CancelActionsResult::kFailed:
      return "kFailed";
    default:
      return nullptr;
  }
}

std::string CancelActionsResultToString(CancelActionsResult value) {
  const char *str = CancelActionsResultToStringHelper(value);
  if (!str) {
    return base::StringPrintf("Unknown CancelActionsResult value: %i", static_cast<int32_t>(value));
  }
  return str;
}

std::ostream& operator<<(std::ostream& os, CancelActionsResult value) {
  return os << CancelActionsResultToString(value);
}

NOINLINE static const char* SwitchConversationErrorReasonToStringHelper(SwitchConversationErrorReason value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case SwitchConversationErrorReason::kUnknown:
      return "kUnknown";
    default:
      return nullptr;
  }
}

std::string SwitchConversationErrorReasonToString(SwitchConversationErrorReason value) {
  const char *str = SwitchConversationErrorReasonToStringHelper(value);
  if (!str) {
    return base::StringPrintf("Unknown SwitchConversationErrorReason value: %i", static_cast<int32_t>(value));
  }
  return str;
}

std::ostream& operator<<(std::ostream& os, SwitchConversationErrorReason value) {
  return os << SwitchConversationErrorReasonToString(value);
}

NOINLINE static const char* RegisterConversationErrorReasonToStringHelper(RegisterConversationErrorReason value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case RegisterConversationErrorReason::kUnknown:
      return "kUnknown";
    case RegisterConversationErrorReason::kInstanceAlreadyHasConversationId:
      return "kInstanceAlreadyHasConversationId";
    default:
      return nullptr;
  }
}

std::string RegisterConversationErrorReasonToString(RegisterConversationErrorReason value) {
  const char *str = RegisterConversationErrorReasonToStringHelper(value);
  if (!str) {
    return base::StringPrintf("Unknown RegisterConversationErrorReason value: %i", static_cast<int32_t>(value));
  }
  return str;
}

std::ostream& operator<<(std::ostream& os, RegisterConversationErrorReason value) {
  return os << RegisterConversationErrorReasonToString(value);
}

NOINLINE static const char* PanelStateKindToStringHelper(PanelStateKind value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case PanelStateKind::kHidden:
      return "kHidden";
    case PanelStateKind::kDetached:
      return "kDetached";
    case PanelStateKind::kAttached:
      return "kAttached";
    default:
      return nullptr;
  }
}

std::string PanelStateKindToString(PanelStateKind value) {
  const char *str = PanelStateKindToStringHelper(value);
  if (!str) {
    return base::StringPrintf("Unknown PanelStateKind value: %i", static_cast<int32_t>(value));
  }
  return str;
}

std::ostream& operator<<(std::ostream& os, PanelStateKind value) {
  return os << PanelStateKindToString(value);
}

NOINLINE static const char* FreOverrideToStringHelper(FreOverride value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case FreOverride::kUnspecified:
      return "kUnspecified";
    case FreOverride::kTrustFirstText:
      return "kTrustFirstText";
    case FreOverride::kTrustFirstClick:
      return "kTrustFirstClick";
    case FreOverride::kTrustFirstInline:
      return "kTrustFirstInline";
    default:
      return nullptr;
  }
}

std::string FreOverrideToString(FreOverride value) {
  const char *str = FreOverrideToStringHelper(value);
  if (!str) {
    return base::StringPrintf("Unknown FreOverride value: %i", static_cast<int32_t>(value));
  }
  return str;
}

std::ostream& operator<<(std::ostream& os, FreOverride value) {
  return os << FreOverrideToString(value);
}

NOINLINE static const char* InvocationSourceToStringHelper(InvocationSource value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case InvocationSource::kOsButton:
      return "kOsButton";
    case InvocationSource::kOsButtonMenu:
      return "kOsButtonMenu";
    case InvocationSource::kOsHotkey:
      return "kOsHotkey";
    case InvocationSource::kTopChromeButton:
      return "kTopChromeButton";
    case InvocationSource::kFre:
      return "kFre";
    case InvocationSource::kProfilePicker:
      return "kProfilePicker";
    case InvocationSource::kNudge:
      return "kNudge";
    case InvocationSource::kThreeDotsMenu:
      return "kThreeDotsMenu";
    case InvocationSource::kUnsupported:
      return "kUnsupported";
    case InvocationSource::kWhatsNew:
      return "kWhatsNew";
    case InvocationSource::kAfterSignIn:
      return "kAfterSignIn";
    case InvocationSource::kSharedTab:
      return "kSharedTab";
    case InvocationSource::kActorTaskIcon:
      return "kActorTaskIcon";
    case InvocationSource::kSharedImage:
      return "kSharedImage";
    case InvocationSource::kHandoffButton:
      return "kHandoffButton";
    case InvocationSource::kSkills:
      return "kSkills";
    case InvocationSource::kAutoOpenedByContextualCue:
      return "kAutoOpenedByContextualCue";
    case InvocationSource::kPdfSummarizeButton:
      return "kPdfSummarizeButton";
    case InvocationSource::kNavigationCapture:
      return "kNavigationCapture";
    case InvocationSource::kAutoOpenedForPdf:
      return "kAutoOpenedForPdf";
    case InvocationSource::kCaptureRegionHotkey:
      return "kCaptureRegionHotkey";
    case InvocationSource::kIph:
      return "kIph";
    case InvocationSource::kAnchoredContextualCue:
      return "kAnchoredContextualCue";
    case InvocationSource::kWebContentsContextMenu:
      return "kWebContentsContextMenu";
    case InvocationSource::kTextSelectionNudge:
      return "kTextSelectionNudge";
    case InvocationSource::kTextSelectionWidget:
      return "kTextSelectionWidget";
    case InvocationSource::kZeroStateAutoSummarize:
      return "kZeroStateAutoSummarize";
    case InvocationSource::kUniversalCart:
      return "kUniversalCart";
    case InvocationSource::kExperimentalTriggering:
      return "kExperimentalTriggering";
    case InvocationSource::kPasswordChange:
      return "kPasswordChange";
    case InvocationSource::kAutofill:
      return "kAutofill";
    case InvocationSource::kToolbarButton:
      return "kToolbarButton";
    case InvocationSource::kIndigoPageAction:
      return "kIndigoPageAction";
    case InvocationSource::kWebDragDrop:
      return "kWebDragDrop";
    case InvocationSource::kPromotionPage:
      return "kPromotionPage";
    case InvocationSource::kDaisyChainOnNewTab:
      return "kDaisyChainOnNewTab";
    case InvocationSource::kDaisyChainOnFollowLink:
      return "kDaisyChainOnFollowLink";
    case InvocationSource::kConversationSwitch:
      return "kConversationSwitch";
    case InvocationSource::kDetachAttachButton:
      return "kDetachAttachButton";
    case InvocationSource::kTabRestore:
      return "kTabRestore";
    case InvocationSource::kReshowInactive:
      return "kReshowInactive";
    case InvocationSource::kTabContextMenu:
      return "kTabContextMenu";
    case InvocationSource::kWebContinuity:
      return "kWebContinuity";
    default:
      return nullptr;
  }
}

std::string InvocationSourceToString(InvocationSource value) {
  const char *str = InvocationSourceToStringHelper(value);
  if (!str) {
    return base::StringPrintf("Unknown InvocationSource value: %i", static_cast<int32_t>(value));
  }
  return str;
}

std::ostream& operator<<(std::ostream& os, InvocationSource value) {
  return os << InvocationSourceToString(value);
}

NOINLINE static const char* ActuationTargetToStringHelper(ActuationTarget value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case ActuationTarget::kUnknown:
      return "kUnknown";
    case ActuationTarget::kAgentDecides:
      return "kAgentDecides";
    case ActuationTarget::kCurrentTab:
      return "kCurrentTab";
    case ActuationTarget::kNewTab:
      return "kNewTab";
    case ActuationTarget::kTargetSurface:
      return "kTargetSurface";
    default:
      return nullptr;
  }
}

std::string ActuationTargetToString(ActuationTarget value) {
  const char *str = ActuationTargetToStringHelper(value);
  if (!str) {
    return base::StringPrintf("Unknown ActuationTarget value: %i", static_cast<int32_t>(value));
  }
  return str;
}

std::ostream& operator<<(std::ostream& os, ActuationTarget value) {
  return os << ActuationTargetToString(value);
}

NOINLINE static const char* WebClientModeToStringHelper(WebClientMode value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case WebClientMode::kText:
      return "kText";
    case WebClientMode::kAudio:
      return "kAudio";
    case WebClientMode::kUnknown:
      return "kUnknown";
    default:
      return nullptr;
  }
}

std::string WebClientModeToString(WebClientMode value) {
  const char *str = WebClientModeToStringHelper(value);
  if (!str) {
    return base::StringPrintf("Unknown WebClientMode value: %i", static_cast<int32_t>(value));
  }
  return str;
}

std::ostream& operator<<(std::ostream& os, WebClientMode value) {
  return os << WebClientModeToString(value);
}

NOINLINE static const char* PromptTypeToStringHelper(PromptType value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case PromptType::kUnspecified:
      return "kUnspecified";
    case PromptType::kTypedText:
      return "kTypedText";
    case PromptType::kZeroStateSuggestions:
      return "kZeroStateSuggestions";
    case PromptType::kAutoPrompt:
      return "kAutoPrompt";
    case PromptType::kAudio:
      return "kAudio";
    default:
      return nullptr;
  }
}

std::string PromptTypeToString(PromptType value) {
  const char *str = PromptTypeToStringHelper(value);
  if (!str) {
    return base::StringPrintf("Unknown PromptType value: %i", static_cast<int32_t>(value));
  }
  return str;
}

std::ostream& operator<<(std::ostream& os, PromptType value) {
  return os << PromptTypeToString(value);
}

NOINLINE static const char* MicrophoneStatusToStringHelper(MicrophoneStatus value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case MicrophoneStatus::kNotListening:
      return "kNotListening";
    case MicrophoneStatus::kListening:
      return "kListening";
    case MicrophoneStatus::kUnknown:
      return "kUnknown";
    default:
      return nullptr;
  }
}

std::string MicrophoneStatusToString(MicrophoneStatus value) {
  const char *str = MicrophoneStatusToStringHelper(value);
  if (!str) {
    return base::StringPrintf("Unknown MicrophoneStatus value: %i", static_cast<int32_t>(value));
  }
  return str;
}

std::ostream& operator<<(std::ostream& os, MicrophoneStatus value) {
  return os << MicrophoneStatusToString(value);
}

NOINLINE static const char* WebClientModelToStringHelper(WebClientModel value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case WebClientModel::kDefault:
      return "kDefault";
    case WebClientModel::kActor:
      return "kActor";
    default:
      return nullptr;
  }
}

std::string WebClientModelToString(WebClientModel value) {
  const char *str = WebClientModelToStringHelper(value);
  if (!str) {
    return base::StringPrintf("Unknown WebClientModel value: %i", static_cast<int32_t>(value));
  }
  return str;
}

std::ostream& operator<<(std::ostream& os, WebClientModel value) {
  return os << WebClientModelToString(value);
}

NOINLINE static const char* WebUseCounterToStringHelper(WebUseCounter value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case WebUseCounter::kDefault:
      return "kDefault";
    case WebUseCounter::kSubmitPromptWithAutoMode:
      return "kSubmitPromptWithAutoMode";
    case WebUseCounter::kTaskInterruptedForUserConfirmation:
      return "kTaskInterruptedForUserConfirmation";
    case WebUseCounter::kTaskInterruptedForUserClarification:
      return "kTaskInterruptedForUserClarification";
    case WebUseCounter::kSelectionToggledViaSharedMenu:
      return "kSelectionToggledViaSharedMenu";
    case WebUseCounter::kSelectionToggledViaHotKey:
      return "kSelectionToggledViaHotKey";
    case WebUseCounter::kSubmitPromptWithTextSelectionCue:
      return "kSubmitPromptWithTextSelectionCue";
    default:
      return nullptr;
  }
}

std::string WebUseCounterToString(WebUseCounter value) {
  const char *str = WebUseCounterToStringHelper(value);
  if (!str) {
    return base::StringPrintf("Unknown WebUseCounter value: %i", static_cast<int32_t>(value));
  }
  return str;
}

std::ostream& operator<<(std::ostream& os, WebUseCounter value) {
  return os << WebUseCounterToString(value);
}

NOINLINE static const char* ClientErrorDialogTypeToStringHelper(ClientErrorDialogType value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case ClientErrorDialogType::kUnknown:
      return "kUnknown";
    case ClientErrorDialogType::kDisabledByOrganization:
      return "kDisabledByOrganization";
    case ClientErrorDialogType::kGenericAvailability:
      return "kGenericAvailability";
    case ClientErrorDialogType::kIneligibleAccount:
      return "kIneligibleAccount";
    case ClientErrorDialogType::kSignout:
      return "kSignout";
    case ClientErrorDialogType::kUnsupportedLocation:
      return "kUnsupportedLocation";
    default:
      return nullptr;
  }
}

std::string ClientErrorDialogTypeToString(ClientErrorDialogType value) {
  const char *str = ClientErrorDialogTypeToStringHelper(value);
  if (!str) {
    return base::StringPrintf("Unknown ClientErrorDialogType value: %i", static_cast<int32_t>(value));
  }
  return str;
}

std::ostream& operator<<(std::ostream& os, ClientErrorDialogType value) {
  return os << ClientErrorDialogTypeToString(value);
}

NOINLINE static const char* ResponseStopCauseToStringHelper(ResponseStopCause value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case ResponseStopCause::kUnknown:
      return "kUnknown";
    case ResponseStopCause::kUser:
      return "kUser";
    case ResponseStopCause::kOther:
      return "kOther";
    default:
      return nullptr;
  }
}

std::string ResponseStopCauseToString(ResponseStopCause value) {
  const char *str = ResponseStopCauseToStringHelper(value);
  if (!str) {
    return base::StringPrintf("Unknown ResponseStopCause value: %i", static_cast<int32_t>(value));
  }
  return str;
}

std::ostream& operator<<(std::ostream& os, ResponseStopCause value) {
  return os << ResponseStopCauseToString(value);
}

NOINLINE static const char* AdditionalContextSourceToStringHelper(AdditionalContextSource value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case AdditionalContextSource::kShareContextMenu:
      return "kShareContextMenu";
    case AdditionalContextSource::kRegionSelection:
      return "kRegionSelection";
    case AdditionalContextSource::kUnknown:
      return "kUnknown";
    case AdditionalContextSource::kTextSelection:
      return "kTextSelection";
    case AdditionalContextSource::kWebDragDrop:
      return "kWebDragDrop";
    case AdditionalContextSource::kExperimentalTriggering:
      return "kExperimentalTriggering";
    default:
      return nullptr;
  }
}

std::string AdditionalContextSourceToString(AdditionalContextSource value) {
  const char *str = AdditionalContextSourceToStringHelper(value);
  if (!str) {
    return base::StringPrintf("Unknown AdditionalContextSource value: %i", static_cast<int32_t>(value));
  }
  return str;
}

std::ostream& operator<<(std::ostream& os, AdditionalContextSource value) {
  return os << AdditionalContextSourceToString(value);
}

NOINLINE static const char* ExperimentalTriggeringUpdateTypeToStringHelper(ExperimentalTriggeringUpdateType value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case ExperimentalTriggeringUpdateType::kUnknown:
      return "kUnknown";
    case ExperimentalTriggeringUpdateType::kWorklog:
      return "kWorklog";
    case ExperimentalTriggeringUpdateType::kPaused:
      return "kPaused";
    case ExperimentalTriggeringUpdateType::kTerminalCompletion:
      return "kTerminalCompletion";
    case ExperimentalTriggeringUpdateType::kTerminalStopped:
      return "kTerminalStopped";
    case ExperimentalTriggeringUpdateType::kTerminalFailed:
      return "kTerminalFailed";
    case ExperimentalTriggeringUpdateType::kYieldToUser:
      return "kYieldToUser";
    case ExperimentalTriggeringUpdateType::kResumed:
      return "kResumed";
    default:
      return nullptr;
  }
}

std::string ExperimentalTriggeringUpdateTypeToString(ExperimentalTriggeringUpdateType value) {
  const char *str = ExperimentalTriggeringUpdateTypeToStringHelper(value);
  if (!str) {
    return base::StringPrintf("Unknown ExperimentalTriggeringUpdateType value: %i", static_cast<int32_t>(value));
  }
  return str;
}

std::ostream& operator<<(std::ostream& os, ExperimentalTriggeringUpdateType value) {
  return os << ExperimentalTriggeringUpdateTypeToString(value);
}

NOINLINE static const char* SubscriberObservationTypeToStringHelper(SubscriberObservationType value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case SubscriberObservationType::kUpdate:
      return "kUpdate";
    case SubscriberObservationType::kComplete:
      return "kComplete";
    case SubscriberObservationType::kError:
      return "kError";
    default:
      return nullptr;
  }
}

std::string SubscriberObservationTypeToString(SubscriberObservationType value) {
  const char *str = SubscriberObservationTypeToStringHelper(value);
  if (!str) {
    return base::StringPrintf("Unknown SubscriberObservationType value: %i", static_cast<int32_t>(value));
  }
  return str;
}

std::ostream& operator<<(std::ostream& os, SubscriberObservationType value) {
  return os << SubscriberObservationTypeToString(value);
}

NOINLINE static const char* LightweightPageFeatureToStringHelper(LightweightPageFeature value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case LightweightPageFeature::kUnknown:
      return "kUnknown";
    case LightweightPageFeature::kYtAskButtonPresent:
      return "kYtAskButtonPresent";
    default:
      return nullptr;
  }
}

std::string LightweightPageFeatureToString(LightweightPageFeature value) {
  const char *str = LightweightPageFeatureToStringHelper(value);
  if (!str) {
    return base::StringPrintf("Unknown LightweightPageFeature value: %i", static_cast<int32_t>(value));
  }
  return str;
}

std::ostream& operator<<(std::ostream& os, LightweightPageFeature value) {
  return os << LightweightPageFeatureToString(value);
}

NOINLINE static const char* CaptureRegionErrorReasonToStringHelper(CaptureRegionErrorReason value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case CaptureRegionErrorReason::kUnknown:
      return "kUnknown";
    case CaptureRegionErrorReason::kNoFocusableTab:
      return "kNoFocusableTab";
    default:
      return nullptr;
  }
}

std::string CaptureRegionErrorReasonToString(CaptureRegionErrorReason value) {
  const char *str = CaptureRegionErrorReasonToStringHelper(value);
  if (!str) {
    return base::StringPrintf("Unknown CaptureRegionErrorReason value: %i", static_cast<int32_t>(value));
  }
  return str;
}

std::ostream& operator<<(std::ostream& os, CaptureRegionErrorReason value) {
  return os << CaptureRegionErrorReasonToString(value);
}

NOINLINE static const char* ScreenshotEncryptionSchemeToStringHelper(ScreenshotEncryptionScheme value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case ScreenshotEncryptionScheme::kUnknown:
      return "kUnknown";
    case ScreenshotEncryptionScheme::kNone:
      return "kNone";
    case ScreenshotEncryptionScheme::kRfc8291:
      return "kRfc8291";
    default:
      return nullptr;
  }
}

std::string ScreenshotEncryptionSchemeToString(ScreenshotEncryptionScheme value) {
  const char *str = ScreenshotEncryptionSchemeToStringHelper(value);
  if (!str) {
    return base::StringPrintf("Unknown ScreenshotEncryptionScheme value: %i", static_cast<int32_t>(value));
  }
  return str;
}

std::ostream& operator<<(std::ostream& os, ScreenshotEncryptionScheme value) {
  return os << ScreenshotEncryptionSchemeToString(value);
}

NOINLINE static const char* SettingsPageFieldToStringHelper(SettingsPageField value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case SettingsPageField::kNone:
      return "kNone";
    case SettingsPageField::kOsHotkey:
      return "kOsHotkey";
    case SettingsPageField::kOsEntrypointToggle:
      return "kOsEntrypointToggle";
    case SettingsPageField::kLocationPermission:
      return "kLocationPermission";
    default:
      return nullptr;
  }
}

std::string SettingsPageFieldToString(SettingsPageField value) {
  const char *str = SettingsPageFieldToStringHelper(value);
  if (!str) {
    return base::StringPrintf("Unknown SettingsPageField value: %i", static_cast<int32_t>(value));
  }
  return str;
}

std::ostream& operator<<(std::ostream& os, SettingsPageField value) {
  return os << SettingsPageFieldToString(value);
}

NOINLINE static const char* HostCapabilityToStringHelper(HostCapability value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case HostCapability::kScrollToPdf:
      return "kScrollToPdf";
    case HostCapability::kResetSizeAndLocationOnOpen:
      return "kResetSizeAndLocationOnOpen";
    case HostCapability::kGetModelQualityClientId:
      return "kGetModelQualityClientId";
    case HostCapability::kMultiInstance:
      return "kMultiInstance";
    case HostCapability::kTrustFirstOnboardingArm1:
      return "kTrustFirstOnboardingArm1";
    case HostCapability::kTrustFirstOnboardingArm2:
      return "kTrustFirstOnboardingArm2";
    case HostCapability::kShareAdditionalImageContext:
      return "kShareAdditionalImageContext";
    case HostCapability::kPdfZeroState:
      return "kPdfZeroState";
    case HostCapability::kInvoke:
      return "kInvoke";
    case HostCapability::kNoLiveMode:
      return "kNoLiveMode";
    case HostCapability::kAutoLoginSignInWithGoogle:
      return "kAutoLoginSignInWithGoogle";
    case HostCapability::kShareImageViaInvoke:
      return "kShareImageViaInvoke";
    case HostCapability::kImgWebDragDrop:
      return "kImgWebDragDrop";
    case HostCapability::kNoWebUiLoader:
      return "kNoWebUiLoader";
    case HostCapability::kEnforcesPasteEligibility:
      return "kEnforcesPasteEligibility";
    case HostCapability::kAttemptOtpFilling:
      return "kAttemptOtpFilling";
    default:
      return nullptr;
  }
}

std::string HostCapabilityToString(HostCapability value) {
  const char *str = HostCapabilityToStringHelper(value);
  if (!str) {
    return base::StringPrintf("Unknown HostCapability value: %i", static_cast<int32_t>(value));
  }
  return str;
}

std::ostream& operator<<(std::ostream& os, HostCapability value) {
  return os << HostCapabilityToString(value);
}

NOINLINE static const char* ClientCapabilitiesToStringHelper(ClientCapabilities value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case ClientCapabilities::kIgnoresTabDataFavicons:
      return "kIgnoresTabDataFavicons";
    default:
      return nullptr;
  }
}

std::string ClientCapabilitiesToString(ClientCapabilities value) {
  const char *str = ClientCapabilitiesToStringHelper(value);
  if (!str) {
    return base::StringPrintf("Unknown ClientCapabilities value: %i", static_cast<int32_t>(value));
  }
  return str;
}

std::ostream& operator<<(std::ostream& os, ClientCapabilities value) {
  return os << ClientCapabilitiesToString(value);
}

namespace internal {
// static
bool InvokeConversationSelection_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context,
    bool inlined) {
  if (!data) {
    DCHECK(!inlined);
    return true;
  }

  // If it is inlined, the alignment is already enforced by its enclosing
  // object. We don't have to validate that.
  DCHECK(!inlined || mojo::internal::IsAligned(data));

  if (!inlined &&
      !mojo::internal::ValidateNonInlinedUnionHeaderAndClaimMemory(
          data, validation_context)) {
    return false;
  }

  const InvokeConversationSelection_Data* object = static_cast<const InvokeConversationSelection_Data*>(data);

  if (inlined && object->is_null())
    return true;

  switch (object->tag) {

    case InvokeConversationSelection_Tag::kDefaultConversation: {

      if (!mojo::internal::ValidatePointerNonNullable(
              object->data.f_default_conversation, 1, validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateStruct(object->data.f_default_conversation, validation_context))
        return false;
      return true;
    }
    case InvokeConversationSelection_Tag::kNewConversation: {

      if (!mojo::internal::ValidatePointerNonNullable(
              object->data.f_new_conversation, 2, validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateStruct(object->data.f_new_conversation, validation_context))
        return false;
      return true;
    }
    case InvokeConversationSelection_Tag::kConversationId: {

      if (!mojo::internal::ValidatePointerNonNullable(
              object->data.f_conversation_id, 3, validation_context)) {
        return false;
      }
      constexpr const mojo::internal::ContainerValidateParams& conversation_id_validate_params =
          mojo::internal::GetArrayValidator<0, false, nullptr>();
      if (!mojo::internal::ValidateContainer(object->data.f_conversation_id, validation_context,
                                             &conversation_id_validate_params)) {
        return false;
      }
      return true;
    }
    default: {

      ReportValidationError(
          validation_context,
          mojo::internal::VALIDATION_ERROR_UNKNOWN_UNION_TAG,
          "unknown tag in InvokeConversationSelection");
      return false;
    }
  }
}
// static
bool InvokeTargetSurface_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context,
    bool inlined) {
  if (!data) {
    DCHECK(!inlined);
    return true;
  }

  // If it is inlined, the alignment is already enforced by its enclosing
  // object. We don't have to validate that.
  DCHECK(!inlined || mojo::internal::IsAligned(data));

  if (!inlined &&
      !mojo::internal::ValidateNonInlinedUnionHeaderAndClaimMemory(
          data, validation_context)) {
    return false;
  }

  const InvokeTargetSurface_Data* object = static_cast<const InvokeTargetSurface_Data*>(data);

  if (inlined && object->is_null())
    return true;

  switch (object->tag) {

    case InvokeTargetSurface_Tag::kDefaultSurface: {

      if (!mojo::internal::ValidatePointerNonNullable(
              object->data.f_default_surface, 1, validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateStruct(object->data.f_default_surface, validation_context))
        return false;
      return true;
    }
    case InvokeTargetSurface_Tag::kNewTab: {

      if (!mojo::internal::ValidatePointerNonNullable(
              object->data.f_new_tab, 2, validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateStruct(object->data.f_new_tab, validation_context))
        return false;
      return true;
    }
    default: {

      ReportValidationError(
          validation_context,
          mojo::internal::VALIDATION_ERROR_UNKNOWN_UNION_TAG,
          "unknown tag in InvokeTargetSurface");
      return false;
    }
  }
}
// static
bool GetContextResult_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context,
    bool inlined) {
  if (!data) {
    DCHECK(!inlined);
    return true;
  }

  // If it is inlined, the alignment is already enforced by its enclosing
  // object. We don't have to validate that.
  DCHECK(!inlined || mojo::internal::IsAligned(data));

  if (!inlined &&
      !mojo::internal::ValidateNonInlinedUnionHeaderAndClaimMemory(
          data, validation_context)) {
    return false;
  }

  const GetContextResult_Data* object = static_cast<const GetContextResult_Data*>(data);

  if (inlined && object->is_null())
    return true;

  switch (object->tag) {

    case GetContextResult_Tag::kErrorReason: {

      if (!mojo::internal::ValidatePointerNonNullable(
              object->data.f_error_reason, 1, validation_context)) {
        return false;
      }
      constexpr const mojo::internal::ContainerValidateParams& error_reason_validate_params =
          mojo::internal::GetArrayValidator<0, false, nullptr>();
      if (!mojo::internal::ValidateContainer(object->data.f_error_reason, validation_context,
                                             &error_reason_validate_params)) {
        return false;
      }
      return true;
    }
    case GetContextResult_Tag::kTabContext: {

      if (!mojo::internal::ValidatePointerNonNullable(
              object->data.f_tab_context, 2, validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateStruct(object->data.f_tab_context, validation_context))
        return false;
      return true;
    }
    default: {

      ReportValidationError(
          validation_context,
          mojo::internal::VALIDATION_ERROR_UNKNOWN_UNION_TAG,
          "unknown tag in GetContextResult");
      return false;
    }
  }
}
// static
bool CaptureScreenshotResult_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context,
    bool inlined) {
  if (!data) {
    DCHECK(!inlined);
    return true;
  }

  // If it is inlined, the alignment is already enforced by its enclosing
  // object. We don't have to validate that.
  DCHECK(!inlined || mojo::internal::IsAligned(data));

  if (!inlined &&
      !mojo::internal::ValidateNonInlinedUnionHeaderAndClaimMemory(
          data, validation_context)) {
    return false;
  }

  const CaptureScreenshotResult_Data* object = static_cast<const CaptureScreenshotResult_Data*>(data);

  if (inlined && object->is_null())
    return true;

  switch (object->tag) {

    case CaptureScreenshotResult_Tag::kErrorReason: {


      if (!::glic::mojom::internal::CaptureScreenshotErrorReason_Data
            ::Validate(object->data.f_error_reason, validation_context))
        return false;
      return true;
    }
    case CaptureScreenshotResult_Tag::kScreenshot: {

      if (!mojo::internal::ValidatePointerNonNullable(
              object->data.f_screenshot, 2, validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateStruct(object->data.f_screenshot, validation_context))
        return false;
      return true;
    }
    default: {

      ReportValidationError(
          validation_context,
          mojo::internal::VALIDATION_ERROR_UNKNOWN_UNION_TAG,
          "unknown tag in CaptureScreenshotResult");
      return false;
    }
  }
}
// static
bool ScrollToSelector_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context,
    bool inlined) {
  if (!data) {
    DCHECK(!inlined);
    return true;
  }

  // If it is inlined, the alignment is already enforced by its enclosing
  // object. We don't have to validate that.
  DCHECK(!inlined || mojo::internal::IsAligned(data));

  if (!inlined &&
      !mojo::internal::ValidateNonInlinedUnionHeaderAndClaimMemory(
          data, validation_context)) {
    return false;
  }

  const ScrollToSelector_Data* object = static_cast<const ScrollToSelector_Data*>(data);

  if (inlined && object->is_null())
    return true;

  switch (object->tag) {

    case ScrollToSelector_Tag::kExactText: {

      if (!mojo::internal::ValidatePointerNonNullable(
              object->data.f_exact_text, 1, validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateStruct(object->data.f_exact_text, validation_context))
        return false;
      return true;
    }
    case ScrollToSelector_Tag::kTextFragment: {

      if (!mojo::internal::ValidatePointerNonNullable(
              object->data.f_text_fragment, 2, validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateStruct(object->data.f_text_fragment, validation_context))
        return false;
      return true;
    }
    case ScrollToSelector_Tag::kNode: {

      if (!mojo::internal::ValidatePointerNonNullable(
              object->data.f_node, 3, validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateStruct(object->data.f_node, validation_context))
        return false;
      return true;
    }
    default: {

      ReportValidationError(
          validation_context,
          mojo::internal::VALIDATION_ERROR_UNKNOWN_UNION_TAG,
          "unknown tag in ScrollToSelector");
      return false;
    }
  }
}
// static
bool InvocationPayload_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context,
    bool inlined) {
  if (!data) {
    DCHECK(!inlined);
    return true;
  }

  // If it is inlined, the alignment is already enforced by its enclosing
  // object. We don't have to validate that.
  DCHECK(!inlined || mojo::internal::IsAligned(data));

  if (!inlined &&
      !mojo::internal::ValidateNonInlinedUnionHeaderAndClaimMemory(
          data, validation_context)) {
    return false;
  }

  const InvocationPayload_Data* object = static_cast<const InvocationPayload_Data*>(data);

  if (inlined && object->is_null())
    return true;

  switch (object->tag) {

    case InvocationPayload_Tag::kUniversalCart: {

      if (!mojo::internal::ValidatePointerNonNullable(
              object->data.f_universal_cart, 1, validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateStruct(object->data.f_universal_cart, validation_context))
        return false;
      return true;
    }
    case InvocationPayload_Tag::kSkillsPayload: {

      if (!mojo::internal::ValidatePointerNonNullable(
              object->data.f_skills_payload, 2, validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateStruct(object->data.f_skills_payload, validation_context))
        return false;
      return true;
    }
    default: {

      ReportValidationError(
          validation_context,
          mojo::internal::VALIDATION_ERROR_UNKNOWN_UNION_TAG,
          "unknown tag in InvocationPayload");
      return false;
    }
  }
}
// static
bool AdditionalContextPart_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context,
    bool inlined) {
  if (!data) {
    DCHECK(!inlined);
    return true;
  }

  // If it is inlined, the alignment is already enforced by its enclosing
  // object. We don't have to validate that.
  DCHECK(!inlined || mojo::internal::IsAligned(data));

  if (!inlined &&
      !mojo::internal::ValidateNonInlinedUnionHeaderAndClaimMemory(
          data, validation_context)) {
    return false;
  }

  const AdditionalContextPart_Data* object = static_cast<const AdditionalContextPart_Data*>(data);

  if (inlined && object->is_null())
    return true;

  switch (object->tag) {

    case AdditionalContextPart_Tag::kData: {

      if (!mojo::internal::ValidatePointerNonNullable(
              object->data.f_data, 1, validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateStruct(object->data.f_data, validation_context))
        return false;
      return true;
    }
    case AdditionalContextPart_Tag::kScreenshot: {

      if (!mojo::internal::ValidatePointerNonNullable(
              object->data.f_screenshot, 2, validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateStruct(object->data.f_screenshot, validation_context))
        return false;
      return true;
    }
    case AdditionalContextPart_Tag::kWebPageData: {

      if (!mojo::internal::ValidatePointerNonNullable(
              object->data.f_web_page_data, 3, validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateStruct(object->data.f_web_page_data, validation_context))
        return false;
      return true;
    }
    case AdditionalContextPart_Tag::kAnnotatedPageData: {

      if (!mojo::internal::ValidatePointerNonNullable(
              object->data.f_annotated_page_data, 4, validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateStruct(object->data.f_annotated_page_data, validation_context))
        return false;
      return true;
    }
    case AdditionalContextPart_Tag::kPdfDocumentData: {

      if (!mojo::internal::ValidatePointerNonNullable(
              object->data.f_pdf_document_data, 5, validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateStruct(object->data.f_pdf_document_data, validation_context))
        return false;
      return true;
    }
    case AdditionalContextPart_Tag::kTabContext: {

      if (!mojo::internal::ValidatePointerNonNullable(
              object->data.f_tab_context, 6, validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateStruct(object->data.f_tab_context, validation_context))
        return false;
      return true;
    }
    case AdditionalContextPart_Tag::kRegion: {

      if (!mojo::internal::ValidatePointerNonNullable(
              object->data.f_region, 7, validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateNonInlinedUnion(object->data.f_region,
                                                   validation_context))
        return false;
      return true;
    }
    case AdditionalContextPart_Tag::kPendingRegion: {

      if (!mojo::internal::ValidatePointerNonNullable(
              object->data.f_pending_region, 8, validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateStruct(object->data.f_pending_region, validation_context))
        return false;
      return true;
    }
    case AdditionalContextPart_Tag::kParentConversationMetadata: {

      if (!mojo::internal::ValidatePointerNonNullable(
              object->data.f_parent_conversation_metadata, 9, validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateStruct(object->data.f_parent_conversation_metadata, validation_context))
        return false;
      return true;
    }
    default: {

      ReportValidationError(
          validation_context,
          mojo::internal::VALIDATION_ERROR_UNKNOWN_UNION_TAG,
          "unknown tag in AdditionalContextPart");
      return false;
    }
  }
}
// static
bool FocusedTabData_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context,
    bool inlined) {
  if (!data) {
    DCHECK(!inlined);
    return true;
  }

  // If it is inlined, the alignment is already enforced by its enclosing
  // object. We don't have to validate that.
  DCHECK(!inlined || mojo::internal::IsAligned(data));

  if (!inlined &&
      !mojo::internal::ValidateNonInlinedUnionHeaderAndClaimMemory(
          data, validation_context)) {
    return false;
  }

  const FocusedTabData_Data* object = static_cast<const FocusedTabData_Data*>(data);

  if (inlined && object->is_null())
    return true;

  switch (object->tag) {

    case FocusedTabData_Tag::kFocusedTab: {

      if (!mojo::internal::ValidatePointerNonNullable(
              object->data.f_focused_tab, 1, validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateStruct(object->data.f_focused_tab, validation_context))
        return false;
      return true;
    }
    case FocusedTabData_Tag::kNoFocusedTabData: {

      if (!mojo::internal::ValidatePointerNonNullable(
              object->data.f_no_focused_tab_data, 2, validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateStruct(object->data.f_no_focused_tab_data, validation_context))
        return false;
      return true;
    }
    default: {

      ReportValidationError(
          validation_context,
          mojo::internal::VALIDATION_ERROR_UNKNOWN_UNION_TAG,
          "unknown tag in FocusedTabData");
      return false;
    }
  }
}
// static
bool CapturedRegion_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context,
    bool inlined) {
  if (!data) {
    DCHECK(!inlined);
    return true;
  }

  // If it is inlined, the alignment is already enforced by its enclosing
  // object. We don't have to validate that.
  DCHECK(!inlined || mojo::internal::IsAligned(data));

  if (!inlined &&
      !mojo::internal::ValidateNonInlinedUnionHeaderAndClaimMemory(
          data, validation_context)) {
    return false;
  }

  const CapturedRegion_Data* object = static_cast<const CapturedRegion_Data*>(data);

  if (inlined && object->is_null())
    return true;

  switch (object->tag) {

    case CapturedRegion_Tag::kRect: {

      if (!mojo::internal::ValidatePointerNonNullable(
              object->data.f_rect, 1, validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateStruct(object->data.f_rect, validation_context))
        return false;
      return true;
    }
    case CapturedRegion_Tag::kPolyline: {

      if (!mojo::internal::ValidatePointerNonNullable(
              object->data.f_polyline, 2, validation_context)) {
        return false;
      }
      constexpr const mojo::internal::ContainerValidateParams& polyline_validate_params =
          mojo::internal::GetArrayValidator<0, false, nullptr>();
      if (!mojo::internal::ValidateContainer(object->data.f_polyline, validation_context,
                                             &polyline_validate_params)) {
        return false;
      }
      return true;
    }
    default: {

      ReportValidationError(
          validation_context,
          mojo::internal::VALIDATION_ERROR_UNKNOWN_UNION_TAG,
          "unknown tag in CapturedRegion");
      return false;
    }
  }
}
// static
bool GetImageBytesResult_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context,
    bool inlined) {
  if (!data) {
    DCHECK(!inlined);
    return true;
  }

  // If it is inlined, the alignment is already enforced by its enclosing
  // object. We don't have to validate that.
  DCHECK(!inlined || mojo::internal::IsAligned(data));

  if (!inlined &&
      !mojo::internal::ValidateNonInlinedUnionHeaderAndClaimMemory(
          data, validation_context)) {
    return false;
  }

  const GetImageBytesResult_Data* object = static_cast<const GetImageBytesResult_Data*>(data);

  if (inlined && object->is_null())
    return true;

  switch (object->tag) {

    case GetImageBytesResult_Tag::kImageBytes: {

      if (!mojo::internal::ValidatePointerNonNullable(
              object->data.f_image_bytes, 1, validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateStruct(object->data.f_image_bytes, validation_context))
        return false;
      return true;
    }
    case GetImageBytesResult_Tag::kErrorReason: {

      if (!mojo::internal::ValidatePointerNonNullable(
              object->data.f_error_reason, 2, validation_context)) {
        return false;
      }
      constexpr const mojo::internal::ContainerValidateParams& error_reason_validate_params =
          mojo::internal::GetArrayValidator<0, false, nullptr>();
      if (!mojo::internal::ValidateContainer(object->data.f_error_reason, validation_context,
                                             &error_reason_validate_params)) {
        return false;
      }
      return true;
    }
    default: {

      ReportValidationError(
          validation_context,
          mojo::internal::VALIDATION_ERROR_UNKNOWN_UNION_TAG,
          "unknown tag in GetImageBytesResult");
      return false;
    }
  }
}
// static
bool ActorHandler_CreateTask_ResponseParam_Result_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context,
    bool inlined) {
  if (!data) {
    DCHECK(!inlined);
    return true;
  }

  // If it is inlined, the alignment is already enforced by its enclosing
  // object. We don't have to validate that.
  DCHECK(!inlined || mojo::internal::IsAligned(data));

  if (!inlined &&
      !mojo::internal::ValidateNonInlinedUnionHeaderAndClaimMemory(
          data, validation_context)) {
    return false;
  }

  const ActorHandler_CreateTask_ResponseParam_Result_Data* object = static_cast<const ActorHandler_CreateTask_ResponseParam_Result_Data*>(data);

  if (inlined && object->is_null())
    return true;

  switch (object->tag) {

    case ActorHandler_CreateTask_ResponseParam_Result_Tag::kSuccess: {

      return true;
    }
    case ActorHandler_CreateTask_ResponseParam_Result_Tag::kFailure: {


      if (!::glic::mojom::internal::CreateTaskErrorReason_Data
            ::Validate(object->data.f_failure, validation_context))
        return false;
      return true;
    }
    default: {

      ReportValidationError(
          validation_context,
          mojo::internal::VALIDATION_ERROR_UNKNOWN_UNION_TAG,
          "unknown tag in ActorHandler_CreateTask_ResponseParam_Result");
      return false;
    }
  }
}
// static
bool ActorHandler_PerformActions_ResponseParam_Result_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context,
    bool inlined) {
  if (!data) {
    DCHECK(!inlined);
    return true;
  }

  // If it is inlined, the alignment is already enforced by its enclosing
  // object. We don't have to validate that.
  DCHECK(!inlined || mojo::internal::IsAligned(data));

  if (!inlined &&
      !mojo::internal::ValidateNonInlinedUnionHeaderAndClaimMemory(
          data, validation_context)) {
    return false;
  }

  const ActorHandler_PerformActions_ResponseParam_Result_Data* object = static_cast<const ActorHandler_PerformActions_ResponseParam_Result_Data*>(data);

  if (inlined && object->is_null())
    return true;

  switch (object->tag) {

    case ActorHandler_PerformActions_ResponseParam_Result_Tag::kSuccess: {

      if (!mojo::internal::ValidatePointerNonNullable(
              object->data.f_success, 1, validation_context)) {
        return false;
      }
      if (!mojo::internal::ValidateStruct(object->data.f_success, validation_context))
        return false;
      return true;
    }
    case ActorHandler_PerformActions_ResponseParam_Result_Tag::kFailure: {


      if (!::glic::mojom::internal::PerformActionsErrorReason_Data
            ::Validate(object->data.f_failure, validation_context))
        return false;
      return true;
    }
    default: {

      ReportValidationError(
          validation_context,
          mojo::internal::VALIDATION_ERROR_UNKNOWN_UNION_TAG,
          "unknown tag in ActorHandler_PerformActions_ResponseParam_Result");
      return false;
    }
  }
}


// static
bool GeminiEnterpriseSettings_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 32, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const GeminiEnterpriseSettings_Data* object =
      static_cast<const GeminiEnterpriseSettings_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->project_id, 1, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& project_id_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->project_id, validation_context,
                                         &project_id_validate_params)) {
    return false;
  }

  if (!mojo::internal::ValidatePointerNonNullable(
          object->app_id, 2, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& app_id_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->app_id, validation_context,
                                         &app_id_validate_params)) {
    return false;
  }

  if (!mojo::internal::ValidatePointerNonNullable(
          object->location, 3, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& location_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->location, validation_context,
                                         &location_validate_params)) {
    return false;
  }

  return true;
}

GeminiEnterpriseSettings_Data::GeminiEnterpriseSettings_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ProfileEnablement_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 32, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ProfileEnablement_Data* object =
      static_cast<const ProfileEnablement_Data*>(data);

  if (!mojo::internal::ValidateStruct(object->gemini_enterprise_settings, validation_context))
    return false;


  if (!::glic::mojom::internal::ActuationEligibility_Data
        ::Validate(object->actuation_eligibility, validation_context))
    return false;


  if (!::glic::mojom::internal::ActuationEligibility_Data
        ::Validate(object->glic_api_actuation_eligibility, validation_context))
    return false;


  if (!::glic::mojom::internal::GlicExperimentalTriggeringState_Data
        ::Validate(object->glic_experimental_triggering_state, validation_context))
    return false;

  return true;
}

ProfileEnablement_Data::ProfileEnablement_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ConfigInfo_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 56, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ConfigInfo_Data* object =
      static_cast<const ConfigInfo_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->guest_url, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->guest_url, validation_context))
    return false;

  if (!mojo::internal::ValidatePointerNonNullable(
          object->autopush_guest_url, 2, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->autopush_guest_url, validation_context))
    return false;

  if (!mojo::internal::ValidatePointerNonNullable(
          object->staging_guest_url, 3, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->staging_guest_url, validation_context))
    return false;

  if (!mojo::internal::ValidatePointerNonNullable(
          object->preprod_guest_url, 4, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->preprod_guest_url, validation_context))
    return false;

  if (!mojo::internal::ValidatePointerNonNullable(
          object->prod_guest_url, 5, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->prod_guest_url, validation_context))
    return false;

  if (!mojo::internal::ValidatePointerNonNullable(
          object->web_continuity_originating_host_url, 6, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->web_continuity_originating_host_url, validation_context))
    return false;

  return true;
}

ConfigInfo_Data::ConfigInfo_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool DefaultConversation_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 8, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const DefaultConversation_Data* object =
      static_cast<const DefaultConversation_Data*>(data);

  return true;
}

DefaultConversation_Data::DefaultConversation_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool NewConversation_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 8, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const NewConversation_Data* object =
      static_cast<const NewConversation_Data*>(data);

  return true;
}

NewConversation_Data::NewConversation_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool DefaultSurfaceMojo_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 8, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const DefaultSurfaceMojo_Data* object =
      static_cast<const DefaultSurfaceMojo_Data*>(data);

  return true;
}

DefaultSurfaceMojo_Data::DefaultSurfaceMojo_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool NewTabMojo_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const NewTabMojo_Data* object =
      static_cast<const NewTabMojo_Data*>(data);

  return true;
}

NewTabMojo_Data::NewTabMojo_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ZssConfig_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ZssConfig_Data* object =
      static_cast<const ZssConfig_Data*>(data);

  constexpr const mojo::internal::ContainerValidateParams& additional_content_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->additional_content, validation_context,
                                         &additional_content_validate_params)) {
    return false;
  }

  return true;
}

ZssConfig_Data::ZssConfig_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool GetContextResultWithActionResultCode_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 32, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const GetContextResultWithActionResultCode_Data* object =
      static_cast<const GetContextResultWithActionResultCode_Data*>(data);

  if (!mojo::internal::ValidateInlinedUnionNonNullable(
          object->get_context_result, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateInlinedUnion(object->get_context_result, validation_context))
    return false;

  return true;
}

GetContextResultWithActionResultCode_Data::GetContextResultWithActionResultCode_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool UserProfileInfo_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 56, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const UserProfileInfo_Data* object =
      static_cast<const UserProfileInfo_Data*>(data);

  if (!mojo::internal::ValidateStruct(object->avatar_icon, validation_context))
    return false;

  if (!mojo::internal::ValidatePointerNonNullable(
          object->display_name, 2, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& display_name_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->display_name, validation_context,
                                         &display_name_validate_params)) {
    return false;
  }

  if (!mojo::internal::ValidatePointerNonNullable(
          object->given_name, 3, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& given_name_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->given_name, validation_context,
                                         &given_name_validate_params)) {
    return false;
  }

  if (!mojo::internal::ValidatePointerNonNullable(
          object->local_profile_name, 4, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& local_profile_name_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->local_profile_name, validation_context,
                                         &local_profile_name_validate_params)) {
    return false;
  }

  if (!mojo::internal::ValidatePointerNonNullable(
          object->email, 5, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& email_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->email, validation_context,
                                         &email_validate_params)) {
    return false;
  }

  return true;
}

UserProfileInfo_Data::UserProfileInfo_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool SafeBrowsingVerdict_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const SafeBrowsingVerdict_Data* object =
      static_cast<const SafeBrowsingVerdict_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->url, 1, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& url_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->url, validation_context,
                                         &url_validate_params)) {
    return false;
  }


  if (!::glic::mojom::internal::SbThreatType_Data
        ::Validate(object->threat_type, validation_context))
    return false;

  return true;
}

SafeBrowsingVerdict_Data::SafeBrowsingVerdict_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool CounterAbuseVerdict_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const CounterAbuseVerdict_Data* object =
      static_cast<const CounterAbuseVerdict_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->sb_verdict_result, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->sb_verdict_result, validation_context))
    return false;

  return true;
}

CounterAbuseVerdict_Data::CounterAbuseVerdict_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientInitialState_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 96, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientInitialState_Data* object =
      static_cast<const WebClientInitialState_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->panel_state, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->panel_state, validation_context))
    return false;

  if (!mojo::internal::ValidateInlinedUnionNonNullable(
          object->focused_tab_data, 2, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateInlinedUnion(object->focused_tab_data, validation_context))
    return false;

  if (!mojo::internal::ValidatePointerNonNullable(
          object->hotkey, 8, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& hotkey_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->hotkey, validation_context,
                                         &hotkey_validate_params)) {
    return false;
  }

  if (!mojo::internal::ValidatePointerNonNullable(
          object->chrome_version, 9, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->chrome_version, validation_context))
    return false;


  if (!::glic::mojom::internal::Platform_Data
        ::Validate(object->platform, validation_context))
    return false;


  if (!::glic::mojom::internal::FormFactor_Data
        ::Validate(object->form_factor, validation_context))
    return false;

  if (!mojo::internal::ValidatePointerNonNullable(
          object->host_capabilities, 26, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& host_capabilities_validate_params =
      mojo::internal::GetArrayOfEnumsValidator<0, false, ::glic::mojom::internal::HostCapability_Data::Validate>();
  if (!mojo::internal::ValidateContainer(object->host_capabilities, validation_context,
                                         &host_capabilities_validate_params)) {
    return false;
  }

  if (!mojo::internal::ValidateStruct(object->gemini_enterprise_settings, validation_context))
    return false;


  if (!::glic::mojom::internal::FileUploadPolicyState_Data
        ::Validate(object->file_upload_policy_state, validation_context))
    return false;

  return true;
}

WebClientInitialState_Data::WebClientInitialState_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ScreenshotCollectionOptions_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ScreenshotCollectionOptions_Data* object =
      static_cast<const ScreenshotCollectionOptions_Data*>(data);


  if (!::glic::mojom::internal::ScreenshotImageFormat_Data
        ::Validate(object->screenshot_image_format, validation_context))
    return false;


  if (!::glic::mojom::internal::ScreenshotCompressionQuality_Data
        ::Validate(object->screenshot_compression_quality, validation_context))
    return false;

  return true;
}

ScreenshotCollectionOptions_Data::ScreenshotCollectionOptions_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool TabContextOptions_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 40, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const TabContextOptions_Data* object =
      static_cast<const TabContextOptions_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->screenshot_collection_options, 9, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->screenshot_collection_options, validation_context))
    return false;

  return true;
}

TabContextOptions_Data::TabContextOptions_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool GetPinCandidatesOptions_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const GetPinCandidatesOptions_Data* object =
      static_cast<const GetPinCandidatesOptions_Data*>(data);

  constexpr const mojo::internal::ContainerValidateParams& query_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->query, validation_context,
                                         &query_validate_params)) {
    return false;
  }

  return true;
}

GetPinCandidatesOptions_Data::GetPinCandidatesOptions_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ScrollToParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 48, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ScrollToParams_Data* object =
      static_cast<const ScrollToParams_Data*>(data);

  if (!mojo::internal::ValidateInlinedUnionNonNullable(
          object->selector, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateInlinedUnion(object->selector, validation_context))
    return false;

  if (!mojo::internal::ValidateStruct(object->document_id, validation_context))
    return false;

  if (!mojo::internal::ValidateStruct(object->url, validation_context))
    return false;

  return true;
}

ScrollToParams_Data::ScrollToParams_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ScrollToTextSelector_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ScrollToTextSelector_Data* object =
      static_cast<const ScrollToTextSelector_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->text, 1, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& text_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->text, validation_context,
                                         &text_validate_params)) {
    return false;
  }

  return true;
}

ScrollToTextSelector_Data::ScrollToTextSelector_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ScrollToTextFragmentSelector_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 32, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ScrollToTextFragmentSelector_Data* object =
      static_cast<const ScrollToTextFragmentSelector_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->text_start, 1, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& text_start_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->text_start, validation_context,
                                         &text_start_validate_params)) {
    return false;
  }

  if (!mojo::internal::ValidatePointerNonNullable(
          object->text_end, 2, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& text_end_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->text_end, validation_context,
                                         &text_end_validate_params)) {
    return false;
  }

  return true;
}

ScrollToTextFragmentSelector_Data::ScrollToTextFragmentSelector_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ScrollToNodeSelector_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ScrollToNodeSelector_Data* object =
      static_cast<const ScrollToNodeSelector_Data*>(data);

  return true;
}

ScrollToNodeSelector_Data::ScrollToNodeSelector_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool SuggestionContent_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const SuggestionContent_Data* object =
      static_cast<const SuggestionContent_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->suggestion, 1, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& suggestion_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->suggestion, validation_context,
                                         &suggestion_validate_params)) {
    return false;
  }

  return true;
}

SuggestionContent_Data::SuggestionContent_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool SkillPreview_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 80, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const SkillPreview_Data* object =
      static_cast<const SkillPreview_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->id, 1, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& id_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->id, validation_context,
                                         &id_validate_params)) {
    return false;
  }

  if (!mojo::internal::ValidatePointerNonNullable(
          object->name, 2, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& name_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->name, validation_context,
                                         &name_validate_params)) {
    return false;
  }

  if (!mojo::internal::ValidatePointerNonNullable(
          object->icon, 3, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& icon_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->icon, validation_context,
                                         &icon_validate_params)) {
    return false;
  }


  if (!::glic::mojom::internal::SkillSource_Data
        ::Validate(object->source, validation_context))
    return false;

  if (!mojo::internal::ValidatePointerNonNullable(
          object->description, 5, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& description_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->description, validation_context,
                                         &description_validate_params)) {
    return false;
  }

  constexpr const mojo::internal::ContainerValidateParams& curated_by_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->curated_by, validation_context,
                                         &curated_by_validate_params)) {
    return false;
  }

  if (!mojo::internal::ValidateStruct(object->image_url, validation_context))
    return false;

  constexpr const mojo::internal::ContainerValidateParams& category_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->category, validation_context,
                                         &category_validate_params)) {
    return false;
  }

  if (!mojo::internal::ValidateStruct(object->creation_time, validation_context))
    return false;

  return true;
}

SkillPreview_Data::SkillPreview_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool Skill_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 32, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const Skill_Data* object =
      static_cast<const Skill_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->preview, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->preview, validation_context))
    return false;

  if (!mojo::internal::ValidatePointerNonNullable(
          object->prompt, 2, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& prompt_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->prompt, validation_context,
                                         &prompt_validate_params)) {
    return false;
  }

  constexpr const mojo::internal::ContainerValidateParams& source_skill_id_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->source_skill_id, validation_context,
                                         &source_skill_id_validate_params)) {
    return false;
  }

  return true;
}

Skill_Data::Skill_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool CreateSkillRequest_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 56, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const CreateSkillRequest_Data* object =
      static_cast<const CreateSkillRequest_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->id, 1, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& id_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->id, validation_context,
                                         &id_validate_params)) {
    return false;
  }

  if (!mojo::internal::ValidatePointerNonNullable(
          object->name, 2, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& name_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->name, validation_context,
                                         &name_validate_params)) {
    return false;
  }

  if (!mojo::internal::ValidatePointerNonNullable(
          object->icon, 3, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& icon_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->icon, validation_context,
                                         &icon_validate_params)) {
    return false;
  }


  if (!::glic::mojom::internal::SkillSource_Data
        ::Validate(object->source, validation_context))
    return false;

  if (!mojo::internal::ValidatePointerNonNullable(
          object->prompt, 5, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& prompt_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->prompt, validation_context,
                                         &prompt_validate_params)) {
    return false;
  }

  if (!mojo::internal::ValidatePointerNonNullable(
          object->description, 6, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& description_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->description, validation_context,
                                         &description_validate_params)) {
    return false;
  }

  return true;
}

CreateSkillRequest_Data::CreateSkillRequest_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool UpdateSkillRequest_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const UpdateSkillRequest_Data* object =
      static_cast<const UpdateSkillRequest_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->id, 1, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& id_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->id, validation_context,
                                         &id_validate_params)) {
    return false;
  }

  return true;
}

UpdateSkillRequest_Data::UpdateSkillRequest_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ZeroStateSuggestions_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 32, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ZeroStateSuggestions_Data* object =
      static_cast<const ZeroStateSuggestions_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->suggestions, 1, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& suggestions_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->suggestions, validation_context,
                                         &suggestions_validate_params)) {
    return false;
  }

  if (!mojo::internal::ValidatePointerNonNullable(
          object->url, 3, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->url, validation_context))
    return false;

  return true;
}

ZeroStateSuggestions_Data::ZeroStateSuggestions_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ZeroStateSuggestionsV2_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ZeroStateSuggestionsV2_Data* object =
      static_cast<const ZeroStateSuggestionsV2_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->suggestions, 1, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& suggestions_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->suggestions, validation_context,
                                         &suggestions_validate_params)) {
    return false;
  }


  if (!::glic::mojom::internal::InvocationSource_Data
        ::Validate(object->invocation_source, validation_context))
    return false;

  return true;
}

ZeroStateSuggestionsV2_Data::ZeroStateSuggestionsV2_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ZeroStateSuggestionsOptions_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ZeroStateSuggestionsOptions_Data* object =
      static_cast<const ZeroStateSuggestionsOptions_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->supported_tools, 2, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& supported_tools_validate_params =
      mojo::internal::GetArrayValidator<0, false, &mojo::internal::GetArrayValidator<0, false, nullptr>()>();
  if (!mojo::internal::ValidateContainer(object->supported_tools, validation_context,
                                         &supported_tools_validate_params)) {
    return false;
  }

  return true;
}

ZeroStateSuggestionsOptions_Data::ZeroStateSuggestionsOptions_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool PinCandidate_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const PinCandidate_Data* object =
      static_cast<const PinCandidate_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->tab_data, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->tab_data, validation_context))
    return false;

  return true;
}

PinCandidate_Data::PinCandidate_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool PinTabsOptions_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const PinTabsOptions_Data* object =
      static_cast<const PinTabsOptions_Data*>(data);


  if (!::glic::mojom::internal::PinTrigger_Data
        ::Validate(object->pin_trigger, validation_context))
    return false;

  return true;
}

PinTabsOptions_Data::PinTabsOptions_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool UnpinTabsOptions_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const UnpinTabsOptions_Data* object =
      static_cast<const UnpinTabsOptions_Data*>(data);


  if (!::glic::mojom::internal::UnpinTrigger_Data
        ::Validate(object->unpin_trigger, validation_context))
    return false;

  return true;
}

UnpinTabsOptions_Data::UnpinTabsOptions_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool OpenPinnedTabPickerOptions_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 8, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const OpenPinnedTabPickerOptions_Data* object =
      static_cast<const OpenPinnedTabPickerOptions_Data*>(data);

  return true;
}

OpenPinnedTabPickerOptions_Data::OpenPinnedTabPickerOptions_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool CreateActorTabOptions_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const CreateActorTabOptions_Data* object =
      static_cast<const CreateActorTabOptions_Data*>(data);

  return true;
}

CreateActorTabOptions_Data::CreateActorTabOptions_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool CaptureRegionParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const CaptureRegionParams_Data* object =
      static_cast<const CaptureRegionParams_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->options, 2, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->options, validation_context))
    return false;

  return true;
}

CaptureRegionParams_Data::CaptureRegionParams_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ActivateTabOptions_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ActivateTabOptions_Data* object =
      static_cast<const ActivateTabOptions_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->pattern, 1, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& pattern_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->pattern, validation_context,
                                         &pattern_validate_params)) {
    return false;
  }

  return true;
}

ActivateTabOptions_Data::ActivateTabOptions_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool CreateTabOptions_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const CreateTabOptions_Data* object =
      static_cast<const CreateTabOptions_Data*>(data);

  return true;
}

CreateTabOptions_Data::CreateTabOptions_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ConversationInfo_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 40, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ConversationInfo_Data* object =
      static_cast<const ConversationInfo_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->conversation_id, 1, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& conversation_id_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->conversation_id, validation_context,
                                         &conversation_id_validate_params)) {
    return false;
  }

  if (!mojo::internal::ValidatePointerNonNullable(
          object->conversation_title, 2, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& conversation_title_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->conversation_title, validation_context,
                                         &conversation_title_validate_params)) {
    return false;
  }

  if (!mojo::internal::ValidateStruct(object->client_data, validation_context))
    return false;

  constexpr const mojo::internal::ContainerValidateParams& turn_id_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->turn_id, validation_context,
                                         &turn_id_validate_params)) {
    return false;
  }

  return true;
}

ConversationInfo_Data::ConversationInfo_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool PanelOpeningData_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 64, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const PanelOpeningData_Data* object =
      static_cast<const PanelOpeningData_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->panel_state, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->panel_state, validation_context))
    return false;


  if (!::glic::mojom::internal::InvocationSource_Data
        ::Validate(object->invocation_source, validation_context))
    return false;

  constexpr const mojo::internal::ContainerValidateParams& prompt_suggestion_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->prompt_suggestion, validation_context,
                                         &prompt_suggestion_validate_params)) {
    return false;
  }

  if (!mojo::internal::ValidateStruct(object->skill_to_invoke, validation_context))
    return false;

  constexpr const mojo::internal::ContainerValidateParams& recently_active_conversations_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->recently_active_conversations, validation_context,
                                         &recently_active_conversations_validate_params)) {
    return false;
  }

  if (!mojo::internal::ValidatePointerNonNullable(
          object->conversation_info, 7, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->conversation_info, validation_context))
    return false;


  if (!::glic::mojom::internal::FreOverride_Data
        ::Validate(object->fre_override, validation_context))
    return false;

  return true;
}

PanelOpeningData_Data::PanelOpeningData_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool PanelState_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const PanelState_Data* object =
      static_cast<const PanelState_Data*>(data);


  if (!::glic::mojom::internal::PanelStateKind_Data
        ::Validate(object->kind, validation_context))
    return false;

  return true;
}

PanelState_Data::PanelState_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool SkillsPayload_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 32, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const SkillsPayload_Data* object =
      static_cast<const SkillsPayload_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->skill_id, 1, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& skill_id_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->skill_id, validation_context,
                                         &skill_id_validate_params)) {
    return false;
  }

  if (!mojo::internal::ValidatePointerNonNullable(
          object->skill_name, 2, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& skill_name_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->skill_name, validation_context,
                                         &skill_name_validate_params)) {
    return false;
  }

  if (!mojo::internal::ValidatePointerNonNullable(
          object->skill_icon, 3, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& skill_icon_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->skill_icon, validation_context,
                                         &skill_icon_validate_params)) {
    return false;
  }

  return true;
}

SkillsPayload_Data::SkillsPayload_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool UniversalCartPayload_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const UniversalCartPayload_Data* object =
      static_cast<const UniversalCartPayload_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->serialized_metadata, 1, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& serialized_metadata_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->serialized_metadata, validation_context,
                                         &serialized_metadata_validate_params)) {
    return false;
  }

  return true;
}

UniversalCartPayload_Data::UniversalCartPayload_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool InvokeOptions_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  static constexpr mojo::internal::StructVersionSize kVersionSizes[] = {
    { 0, 72 },
    { 1, 80 },
  };
  if (!ValidateStructHeaderAndVersionSizeAndClaimMemory(
          data, kVersionSizes, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const InvokeOptions_Data* object =
      static_cast<const InvokeOptions_Data*>(data);


  if (!::glic::mojom::internal::InvocationSource_Data
        ::Validate(object->invocation_source, validation_context))
    return false;

  constexpr const mojo::internal::ContainerValidateParams& prompts_validate_params =
      mojo::internal::GetArrayValidator<0, false, &mojo::internal::GetArrayValidator<0, false, nullptr>()>();
  if (!mojo::internal::ValidateContainer(object->prompts, validation_context,
                                         &prompts_validate_params)) {
    return false;
  }

  if (!mojo::internal::ValidateStruct(object->context, validation_context))
    return false;


  if (!::glic::mojom::internal::FeatureMode_Data
        ::Validate(object->feature_mode, validation_context))
    return false;


  if (!::glic::mojom::internal::ActuationTarget_Data
        ::Validate(object->actuation_target, validation_context))
    return false;

  constexpr const mojo::internal::ContainerValidateParams& skill_id_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->skill_id, validation_context,
                                         &skill_id_validate_params)) {
    return false;
  }

  if (!mojo::internal::ValidateStruct(object->zss_config, validation_context))
    return false;

  if (!mojo::internal::ValidateInlinedUnion(object->payload, validation_context))
    return false;

  return true;
}

InvokeOptions_Data::InvokeOptions_Data()
    : header_({sizeof(*this), 1}) {}


// static
bool OnResponseStoppedDetails_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const OnResponseStoppedDetails_Data* object =
      static_cast<const OnResponseStoppedDetails_Data*>(data);


  if (!::glic::mojom::internal::ResponseStopCause_Data
        ::Validate(object->cause, validation_context))
    return false;

  return true;
}

OnResponseStoppedDetails_Data::OnResponseStoppedDetails_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool OpenPanelInfo_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 32, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const OpenPanelInfo_Data* object =
      static_cast<const OpenPanelInfo_Data*>(data);


  if (!::glic::mojom::internal::WebClientMode_Data
        ::Validate(object->web_client_mode, validation_context))
    return false;

  if (!mojo::internal::ValidateStruct(object->panelSize, validation_context))
    return false;

  if (!mojo::internal::ValidatePointerNonNullable(
          object->resizeDuration, 3, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->resizeDuration, validation_context))
    return false;

  return true;
}

OpenPanelInfo_Data::OpenPanelInfo_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ContextData_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 40, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ContextData_Data* object =
      static_cast<const ContextData_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->mime_type, 1, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& mime_type_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->mime_type, validation_context,
                                         &mime_type_validate_params)) {
    return false;
  }

  if (!mojo::internal::ValidateInlinedUnionNonNullable(
          object->data, 2, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateInlinedUnion(object->data, validation_context))
    return false;

  constexpr const mojo::internal::ContainerValidateParams& filename_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->filename, validation_context,
                                         &filename_validate_params)) {
    return false;
  }

  return true;
}

ContextData_Data::ContextData_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ParentConversationMetadata_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ParentConversationMetadata_Data* object =
      static_cast<const ParentConversationMetadata_Data*>(data);

  constexpr const mojo::internal::ContainerValidateParams& conversation_id_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->conversation_id, validation_context,
                                         &conversation_id_validate_params)) {
    return false;
  }

  constexpr const mojo::internal::ContainerValidateParams& conversation_title_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->conversation_title, validation_context,
                                         &conversation_title_validate_params)) {
    return false;
  }

  return true;
}

ParentConversationMetadata_Data::ParentConversationMetadata_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool AdditionalContext_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 56, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const AdditionalContext_Data* object =
      static_cast<const AdditionalContext_Data*>(data);


  if (!::glic::mojom::internal::AdditionalContextSource_Data
        ::Validate(object->source, validation_context))
    return false;

  constexpr const mojo::internal::ContainerValidateParams& name_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->name, validation_context,
                                         &name_validate_params)) {
    return false;
  }

  if (!mojo::internal::ValidateStruct(object->origin, validation_context))
    return false;

  if (!mojo::internal::ValidateStruct(object->frameUrl, validation_context))
    return false;

  if (!mojo::internal::ValidatePointerNonNullable(
          object->parts, 7, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& parts_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->parts, validation_context,
                                         &parts_validate_params)) {
    return false;
  }

  return true;
}

AdditionalContext_Data::AdditionalContext_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ExperimentalTriggeringUpdate_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 32, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ExperimentalTriggeringUpdate_Data* object =
      static_cast<const ExperimentalTriggeringUpdate_Data*>(data);


  if (!::glic::mojom::internal::ExperimentalTriggeringUpdateType_Data
        ::Validate(object->type, validation_context))
    return false;

  if (!mojo::internal::ValidatePointerNonNullable(
          object->data, 2, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& data_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->data, validation_context,
                                         &data_validate_params)) {
    return false;
  }

  constexpr const mojo::internal::ContainerValidateParams& metadata_validate_params =
      mojo::internal::GetMapValidator<*&mojo::internal::GetArrayValidator<0, false, &mojo::internal::GetArrayValidator<0, false, nullptr>()>(), *&mojo::internal::GetArrayValidator<0, false, &mojo::internal::GetArrayValidator<0, false, nullptr>()>()>();
  if (!mojo::internal::ValidateContainer(object->metadata, validation_context,
                                         &metadata_validate_params)) {
    return false;
  }

  return true;
}

ExperimentalTriggeringUpdate_Data::ExperimentalTriggeringUpdate_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool TabContextResult_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 56, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const TabContextResult_Data* object =
      static_cast<const TabContextResult_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->tab_data, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->tab_data, validation_context))
    return false;

  if (!mojo::internal::ValidateStruct(object->web_page_data, validation_context))
    return false;

  if (!mojo::internal::ValidateStruct(object->viewport_screenshot, validation_context))
    return false;

  if (!mojo::internal::ValidateStruct(object->screenshot_info, validation_context))
    return false;

  if (!mojo::internal::ValidateStruct(object->pdf_document_data, validation_context))
    return false;

  if (!mojo::internal::ValidateStruct(object->annotated_page_data, validation_context))
    return false;

  return true;
}

TabContextResult_Data::TabContextResult_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebPageData_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebPageData_Data* object =
      static_cast<const WebPageData_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->main_document, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->main_document, validation_context))
    return false;

  return true;
}

WebPageData_Data::WebPageData_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool DocumentData_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 32, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const DocumentData_Data* object =
      static_cast<const DocumentData_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->origin, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->origin, validation_context))
    return false;

  if (!mojo::internal::ValidatePointerNonNullable(
          object->inner_text, 2, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& inner_text_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->inner_text, validation_context,
                                         &inner_text_validate_params)) {
    return false;
  }

  return true;
}

DocumentData_Data::DocumentData_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool PdfDocumentData_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 32, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const PdfDocumentData_Data* object =
      static_cast<const PdfDocumentData_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->origin, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->origin, validation_context))
    return false;

  constexpr const mojo::internal::ContainerValidateParams& pdf_data_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->pdf_data, validation_context,
                                         &pdf_data_validate_params)) {
    return false;
  }

  return true;
}

PdfDocumentData_Data::PdfDocumentData_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool TabData_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 72, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const TabData_Data* object =
      static_cast<const TabData_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->url, 3, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->url, validation_context))
    return false;

  constexpr const mojo::internal::ContainerValidateParams& title_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->title, validation_context,
                                         &title_validate_params)) {
    return false;
  }

  if (!mojo::internal::ValidateStruct(object->favicon, validation_context))
    return false;

  if (!mojo::internal::ValidateStruct(object->favicon_url, validation_context))
    return false;

  if (!mojo::internal::ValidatePointerNonNullable(
          object->document_mime_type, 7, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& document_mime_type_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->document_mime_type, validation_context,
                                         &document_mime_type_validate_params)) {
    return false;
  }

  constexpr const mojo::internal::ContainerValidateParams& lightweight_page_features_validate_params =
      mojo::internal::GetArrayOfEnumsValidator<0, false, ::glic::mojom::internal::LightweightPageFeature_Data::Validate>();
  if (!mojo::internal::ValidateContainer(object->lightweight_page_features, validation_context,
                                         &lightweight_page_features_validate_params)) {
    return false;
  }

  return true;
}

TabData_Data::TabData_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool NoFocusedTabData_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const NoFocusedTabData_Data* object =
      static_cast<const NoFocusedTabData_Data*>(data);

  if (!mojo::internal::ValidateStruct(object->active_tab_data, validation_context))
    return false;

  if (!mojo::internal::ValidatePointerNonNullable(
          object->no_focus_reason, 2, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& no_focus_reason_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->no_focus_reason, validation_context,
                                         &no_focus_reason_validate_params)) {
    return false;
  }

  return true;
}

NoFocusedTabData_Data::NoFocusedTabData_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool AnnotatedPageData_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const AnnotatedPageData_Data* object =
      static_cast<const AnnotatedPageData_Data*>(data);

  if (!mojo::internal::ValidateStruct(object->annotated_page_content, validation_context))
    return false;

  if (!mojo::internal::ValidateStruct(object->metadata, validation_context))
    return false;

  return true;
}

AnnotatedPageData_Data::AnnotatedPageData_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ImageOriginAnnotations_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 8, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ImageOriginAnnotations_Data* object =
      static_cast<const ImageOriginAnnotations_Data*>(data);

  return true;
}

ImageOriginAnnotations_Data::ImageOriginAnnotations_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool Journal_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const Journal_Data* object =
      static_cast<const Journal_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->data, 1, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& data_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->data, validation_context,
                                         &data_validate_params)) {
    return false;
  }

  return true;
}

Journal_Data::Journal_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool PendingCapturedRegion_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 32, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const PendingCapturedRegion_Data* object =
      static_cast<const PendingCapturedRegion_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->id, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->id, validation_context))
    return false;

  if (!mojo::internal::ValidateInlinedUnionNonNullable(
          object->region, 2, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateInlinedUnion(object->region, validation_context))
    return false;

  return true;
}

PendingCapturedRegion_Data::PendingCapturedRegion_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool CaptureRegionResult_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 32, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const CaptureRegionResult_Data* object =
      static_cast<const CaptureRegionResult_Data*>(data);

  if (!mojo::internal::ValidateInlinedUnionNonNullable(
          object->region, 2, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateInlinedUnion(object->region, validation_context))
    return false;

  return true;
}

CaptureRegionResult_Data::CaptureRegionResult_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool Screenshot_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 48, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const Screenshot_Data* object =
      static_cast<const Screenshot_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->data, 3, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& data_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->data, validation_context,
                                         &data_validate_params)) {
    return false;
  }

  if (!mojo::internal::ValidatePointerNonNullable(
          object->mime_type, 4, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& mime_type_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->mime_type, validation_context,
                                         &mime_type_validate_params)) {
    return false;
  }

  if (!mojo::internal::ValidatePointerNonNullable(
          object->origin_annotations, 5, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->origin_annotations, validation_context))
    return false;


  if (!::glic::mojom::internal::ScreenshotEncryptionScheme_Data
        ::Validate(object->encryption_scheme, validation_context))
    return false;

  return true;
}

Screenshot_Data::Screenshot_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ImageInfo_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 40, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ImageInfo_Data* object =
      static_cast<const ImageInfo_Data*>(data);

  constexpr const mojo::internal::ContainerValidateParams& caption_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->caption, validation_context,
                                         &caption_validate_params)) {
    return false;
  }

  if (!mojo::internal::ValidateStruct(object->source_origin, validation_context))
    return false;

  if (!mojo::internal::ValidatePointerNonNullable(
          object->url, 3, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->url, validation_context))
    return false;

  constexpr const mojo::internal::ContainerValidateParams& mime_type_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->mime_type, validation_context,
                                         &mime_type_validate_params)) {
    return false;
  }

  return true;
}

ImageInfo_Data::ImageInfo_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ImageBytesResult_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 32, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ImageBytesResult_Data* object =
      static_cast<const ImageBytesResult_Data*>(data);

  if (!mojo::internal::ValidateInlinedUnionNonNullable(
          object->bytes, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateInlinedUnion(object->bytes, validation_context))
    return false;

  if (!mojo::internal::ValidatePointerNonNullable(
          object->image_info, 2, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->image_info, validation_context))
    return false;

  return true;
}

ImageBytesResult_Data::ImageBytesResult_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool OpenSettingsOptions_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const OpenSettingsOptions_Data* object =
      static_cast<const OpenSettingsOptions_Data*>(data);


  if (!::glic::mojom::internal::SettingsPageField_Data
        ::Validate(object->highlightField, validation_context))
    return false;

  return true;
}

OpenSettingsOptions_Data::OpenSettingsOptions_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool PinCandidatesObserver_OnPinCandidatesChanged_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const PinCandidatesObserver_OnPinCandidatesChanged_Params_Data* object =
      static_cast<const PinCandidatesObserver_OnPinCandidatesChanged_Params_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->candidates, 1, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& candidates_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->candidates, validation_context,
                                         &candidates_validate_params)) {
    return false;
  }

  return true;
}

PinCandidatesObserver_OnPinCandidatesChanged_Params_Data::PinCandidatesObserver_OnPinCandidatesChanged_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ActorClient_RequestToShowCredentialSelectionDialog_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ActorClient_RequestToShowCredentialSelectionDialog_Params_Data* object =
      static_cast<const ActorClient_RequestToShowCredentialSelectionDialog_Params_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->request, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->request, validation_context))
    return false;

  return true;
}

ActorClient_RequestToShowCredentialSelectionDialog_Params_Data::ActorClient_RequestToShowCredentialSelectionDialog_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ActorClient_RequestToShowCredentialSelectionDialog_ResponseParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ActorClient_RequestToShowCredentialSelectionDialog_ResponseParams_Data* object =
      static_cast<const ActorClient_RequestToShowCredentialSelectionDialog_ResponseParams_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->response, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->response, validation_context))
    return false;

  return true;
}

ActorClient_RequestToShowCredentialSelectionDialog_ResponseParams_Data::ActorClient_RequestToShowCredentialSelectionDialog_ResponseParams_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ActorClient_RequestToShowAutofillSuggestionsDialog_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ActorClient_RequestToShowAutofillSuggestionsDialog_Params_Data* object =
      static_cast<const ActorClient_RequestToShowAutofillSuggestionsDialog_Params_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->request, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->request, validation_context))
    return false;

  return true;
}

ActorClient_RequestToShowAutofillSuggestionsDialog_Params_Data::ActorClient_RequestToShowAutofillSuggestionsDialog_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ActorClient_RequestToShowAutofillSuggestionsDialog_ResponseParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ActorClient_RequestToShowAutofillSuggestionsDialog_ResponseParams_Data* object =
      static_cast<const ActorClient_RequestToShowAutofillSuggestionsDialog_ResponseParams_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->response, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->response, validation_context))
    return false;

  return true;
}

ActorClient_RequestToShowAutofillSuggestionsDialog_ResponseParams_Data::ActorClient_RequestToShowAutofillSuggestionsDialog_ResponseParams_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ActorClient_RequestToShowUserConfirmationDialog_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ActorClient_RequestToShowUserConfirmationDialog_Params_Data* object =
      static_cast<const ActorClient_RequestToShowUserConfirmationDialog_Params_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->request, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->request, validation_context))
    return false;

  return true;
}

ActorClient_RequestToShowUserConfirmationDialog_Params_Data::ActorClient_RequestToShowUserConfirmationDialog_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ActorClient_RequestToShowUserConfirmationDialog_ResponseParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ActorClient_RequestToShowUserConfirmationDialog_ResponseParams_Data* object =
      static_cast<const ActorClient_RequestToShowUserConfirmationDialog_ResponseParams_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->response, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->response, validation_context))
    return false;

  return true;
}

ActorClient_RequestToShowUserConfirmationDialog_ResponseParams_Data::ActorClient_RequestToShowUserConfirmationDialog_ResponseParams_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ActorClient_RequestToConfirmNavigation_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ActorClient_RequestToConfirmNavigation_Params_Data* object =
      static_cast<const ActorClient_RequestToConfirmNavigation_Params_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->request, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->request, validation_context))
    return false;

  return true;
}

ActorClient_RequestToConfirmNavigation_Params_Data::ActorClient_RequestToConfirmNavigation_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ActorClient_RequestToConfirmNavigation_ResponseParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ActorClient_RequestToConfirmNavigation_ResponseParams_Data* object =
      static_cast<const ActorClient_RequestToConfirmNavigation_ResponseParams_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->response, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->response, validation_context))
    return false;

  return true;
}

ActorClient_RequestToConfirmNavigation_ResponseParams_Data::ActorClient_RequestToConfirmNavigation_ResponseParams_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ActorClient_NotifyActorTaskStateChanged_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ActorClient_NotifyActorTaskStateChanged_Params_Data* object =
      static_cast<const ActorClient_NotifyActorTaskStateChanged_Params_Data*>(data);


  if (!::glic::mojom::internal::ActorTaskState_Data
        ::Validate(object->state, validation_context))
    return false;

  return true;
}

ActorClient_NotifyActorTaskStateChanged_Params_Data::ActorClient_NotifyActorTaskStateChanged_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ActorClient_RequestToShowGmailOtpOptInDialog_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ActorClient_RequestToShowGmailOtpOptInDialog_Params_Data* object =
      static_cast<const ActorClient_RequestToShowGmailOtpOptInDialog_Params_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->request, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->request, validation_context))
    return false;

  return true;
}

ActorClient_RequestToShowGmailOtpOptInDialog_Params_Data::ActorClient_RequestToShowGmailOtpOptInDialog_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ActorClient_RequestToShowGmailOtpOptInDialog_ResponseParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ActorClient_RequestToShowGmailOtpOptInDialog_ResponseParams_Data* object =
      static_cast<const ActorClient_RequestToShowGmailOtpOptInDialog_ResponseParams_Data*>(data);

  if (!mojo::internal::ValidateInlinedUnionNonNullable(
          object->result, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateInlinedUnion(object->result, validation_context))
    return false;

  return true;
}

ActorClient_RequestToShowGmailOtpOptInDialog_ResponseParams_Data::ActorClient_RequestToShowGmailOtpOptInDialog_ResponseParams_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ActorClient_RequestToShowGmailOtpConfirmationDialog_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ActorClient_RequestToShowGmailOtpConfirmationDialog_Params_Data* object =
      static_cast<const ActorClient_RequestToShowGmailOtpConfirmationDialog_Params_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->request, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->request, validation_context))
    return false;

  return true;
}

ActorClient_RequestToShowGmailOtpConfirmationDialog_Params_Data::ActorClient_RequestToShowGmailOtpConfirmationDialog_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ActorClient_RequestToShowGmailOtpConfirmationDialog_ResponseParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ActorClient_RequestToShowGmailOtpConfirmationDialog_ResponseParams_Data* object =
      static_cast<const ActorClient_RequestToShowGmailOtpConfirmationDialog_ResponseParams_Data*>(data);

  if (!mojo::internal::ValidateInlinedUnionNonNullable(
          object->result, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateInlinedUnion(object->result, validation_context))
    return false;

  return true;
}

ActorClient_RequestToShowGmailOtpConfirmationDialog_ResponseParams_Data::ActorClient_RequestToShowGmailOtpConfirmationDialog_ResponseParams_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ActorHandler_AutofillSuggestionDialogOnFormPresented_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ActorHandler_AutofillSuggestionDialogOnFormPresented_Params_Data* object =
      static_cast<const ActorHandler_AutofillSuggestionDialogOnFormPresented_Params_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->params, 2, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->params, validation_context))
    return false;

  return true;
}

ActorHandler_AutofillSuggestionDialogOnFormPresented_Params_Data::ActorHandler_AutofillSuggestionDialogOnFormPresented_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ActorHandler_AutofillSuggestionDialogOnFormPreviewChanged_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ActorHandler_AutofillSuggestionDialogOnFormPreviewChanged_Params_Data* object =
      static_cast<const ActorHandler_AutofillSuggestionDialogOnFormPreviewChanged_Params_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->params, 2, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->params, validation_context))
    return false;

  return true;
}

ActorHandler_AutofillSuggestionDialogOnFormPreviewChanged_Params_Data::ActorHandler_AutofillSuggestionDialogOnFormPreviewChanged_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ActorHandler_AutofillSuggestionDialogOnFormConfirmed_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ActorHandler_AutofillSuggestionDialogOnFormConfirmed_Params_Data* object =
      static_cast<const ActorHandler_AutofillSuggestionDialogOnFormConfirmed_Params_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->params, 2, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->params, validation_context))
    return false;

  return true;
}

ActorHandler_AutofillSuggestionDialogOnFormConfirmed_Params_Data::ActorHandler_AutofillSuggestionDialogOnFormConfirmed_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ActorHandler_GetContextForActorFromTab_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ActorHandler_GetContextForActorFromTab_Params_Data* object =
      static_cast<const ActorHandler_GetContextForActorFromTab_Params_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->options, 2, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->options, validation_context))
    return false;

  return true;
}

ActorHandler_GetContextForActorFromTab_Params_Data::ActorHandler_GetContextForActorFromTab_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ActorHandler_GetContextForActorFromTab_ResponseParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ActorHandler_GetContextForActorFromTab_ResponseParams_Data* object =
      static_cast<const ActorHandler_GetContextForActorFromTab_ResponseParams_Data*>(data);

  if (!mojo::internal::ValidateInlinedUnionNonNullable(
          object->result, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateInlinedUnion(object->result, validation_context))
    return false;

  return true;
}

ActorHandler_GetContextForActorFromTab_ResponseParams_Data::ActorHandler_GetContextForActorFromTab_ResponseParams_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ActorHandler_CreateTask_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ActorHandler_CreateTask_Params_Data* object =
      static_cast<const ActorHandler_CreateTask_Params_Data*>(data);

  if (!mojo::internal::ValidateStruct(object->task_options, validation_context))
    return false;

  return true;
}

ActorHandler_CreateTask_Params_Data::ActorHandler_CreateTask_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ActorHandler_CreateTask_ResponseParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ActorHandler_CreateTask_ResponseParams_Data* object =
      static_cast<const ActorHandler_CreateTask_ResponseParams_Data*>(data);

  if (!mojo::internal::ValidateInlinedUnionNonNullable(
          object->result, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateInlinedUnion(object->result, validation_context))
    return false;

  return true;
}

ActorHandler_CreateTask_ResponseParams_Data::ActorHandler_CreateTask_ResponseParams_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ActorHandler_PerformActions_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ActorHandler_PerformActions_Params_Data* object =
      static_cast<const ActorHandler_PerformActions_Params_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->actions_proto, 1, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& actions_proto_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->actions_proto, validation_context,
                                         &actions_proto_validate_params)) {
    return false;
  }

  return true;
}

ActorHandler_PerformActions_Params_Data::ActorHandler_PerformActions_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ActorHandler_PerformActions_ResponseParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ActorHandler_PerformActions_ResponseParams_Data* object =
      static_cast<const ActorHandler_PerformActions_ResponseParams_Data*>(data);

  if (!mojo::internal::ValidateInlinedUnionNonNullable(
          object->result, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateInlinedUnion(object->result, validation_context))
    return false;

  return true;
}

ActorHandler_PerformActions_ResponseParams_Data::ActorHandler_PerformActions_ResponseParams_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ActorHandler_CancelActions_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ActorHandler_CancelActions_Params_Data* object =
      static_cast<const ActorHandler_CancelActions_Params_Data*>(data);

  return true;
}

ActorHandler_CancelActions_Params_Data::ActorHandler_CancelActions_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ActorHandler_CancelActions_ResponseParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ActorHandler_CancelActions_ResponseParams_Data* object =
      static_cast<const ActorHandler_CancelActions_ResponseParams_Data*>(data);


  if (!::glic::mojom::internal::CancelActionsResult_Data
        ::Validate(object->result, validation_context))
    return false;

  return true;
}

ActorHandler_CancelActions_ResponseParams_Data::ActorHandler_CancelActions_ResponseParams_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ActorHandler_StopActorTask_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ActorHandler_StopActorTask_Params_Data* object =
      static_cast<const ActorHandler_StopActorTask_Params_Data*>(data);


  if (!::glic::mojom::internal::ActorTaskStopReason_Data
        ::Validate(object->stop_reason, validation_context))
    return false;

  return true;
}

ActorHandler_StopActorTask_Params_Data::ActorHandler_StopActorTask_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ActorHandler_PauseActorTask_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ActorHandler_PauseActorTask_Params_Data* object =
      static_cast<const ActorHandler_PauseActorTask_Params_Data*>(data);


  if (!::glic::mojom::internal::ActorTaskPauseReason_Data
        ::Validate(object->pause_reason, validation_context))
    return false;

  return true;
}

ActorHandler_PauseActorTask_Params_Data::ActorHandler_PauseActorTask_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ActorHandler_ResumeActorTask_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ActorHandler_ResumeActorTask_Params_Data* object =
      static_cast<const ActorHandler_ResumeActorTask_Params_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->context_options, 2, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->context_options, validation_context))
    return false;

  return true;
}

ActorHandler_ResumeActorTask_Params_Data::ActorHandler_ResumeActorTask_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ActorHandler_ResumeActorTask_ResponseParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ActorHandler_ResumeActorTask_ResponseParams_Data* object =
      static_cast<const ActorHandler_ResumeActorTask_ResponseParams_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->result, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->result, validation_context))
    return false;

  return true;
}

ActorHandler_ResumeActorTask_ResponseParams_Data::ActorHandler_ResumeActorTask_ResponseParams_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ActorHandler_InterruptActorTask_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ActorHandler_InterruptActorTask_Params_Data* object =
      static_cast<const ActorHandler_InterruptActorTask_Params_Data*>(data);


  if (!::glic::mojom::internal::ActorTaskInterruptReason_Data
        ::Validate(object->interrupt_reason_$value, validation_context))
    return false;

  return true;
}

ActorHandler_InterruptActorTask_Params_Data::ActorHandler_InterruptActorTask_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ActorHandler_UninterruptActorTask_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ActorHandler_UninterruptActorTask_Params_Data* object =
      static_cast<const ActorHandler_UninterruptActorTask_Params_Data*>(data);

  return true;
}

ActorHandler_UninterruptActorTask_Params_Data::ActorHandler_UninterruptActorTask_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ActorHandler_UpdateActorTaskStepProgress_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ActorHandler_UpdateActorTaskStepProgress_Params_Data* object =
      static_cast<const ActorHandler_UpdateActorTaskStepProgress_Params_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->step_progress, 2, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& step_progress_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->step_progress, validation_context,
                                         &step_progress_validate_params)) {
    return false;
  }

  return true;
}

ActorHandler_UpdateActorTaskStepProgress_Params_Data::ActorHandler_UpdateActorTaskStepProgress_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ActorHandler_CreateActorTab_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ActorHandler_CreateActorTab_Params_Data* object =
      static_cast<const ActorHandler_CreateActorTab_Params_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->options, 2, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->options, validation_context))
    return false;

  return true;
}

ActorHandler_CreateActorTab_Params_Data::ActorHandler_CreateActorTab_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ActorHandler_CreateActorTab_ResponseParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ActorHandler_CreateActorTab_ResponseParams_Data* object =
      static_cast<const ActorHandler_CreateActorTab_ResponseParams_Data*>(data);

  if (!mojo::internal::ValidateStruct(object->tab_data, validation_context))
    return false;

  return true;
}

ActorHandler_CreateActorTab_ResponseParams_Data::ActorHandler_CreateActorTab_ResponseParams_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ActorHandler_LogBeginAsyncEvent_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 40, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ActorHandler_LogBeginAsyncEvent_Params_Data* object =
      static_cast<const ActorHandler_LogBeginAsyncEvent_Params_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->event, 3, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& event_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->event, validation_context,
                                         &event_validate_params)) {
    return false;
  }

  if (!mojo::internal::ValidatePointerNonNullable(
          object->details, 4, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& details_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->details, validation_context,
                                         &details_validate_params)) {
    return false;
  }

  return true;
}

ActorHandler_LogBeginAsyncEvent_Params_Data::ActorHandler_LogBeginAsyncEvent_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ActorHandler_LogEndAsyncEvent_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ActorHandler_LogEndAsyncEvent_Params_Data* object =
      static_cast<const ActorHandler_LogEndAsyncEvent_Params_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->details, 2, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& details_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->details, validation_context,
                                         &details_validate_params)) {
    return false;
  }

  return true;
}

ActorHandler_LogEndAsyncEvent_Params_Data::ActorHandler_LogEndAsyncEvent_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ActorHandler_LogInstantEvent_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 32, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ActorHandler_LogInstantEvent_Params_Data* object =
      static_cast<const ActorHandler_LogInstantEvent_Params_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->event, 2, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& event_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->event, validation_context,
                                         &event_validate_params)) {
    return false;
  }

  if (!mojo::internal::ValidatePointerNonNullable(
          object->details, 3, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& details_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->details, validation_context,
                                         &details_validate_params)) {
    return false;
  }

  return true;
}

ActorHandler_LogInstantEvent_Params_Data::ActorHandler_LogInstantEvent_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ActorHandler_JournalClear_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 8, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ActorHandler_JournalClear_Params_Data* object =
      static_cast<const ActorHandler_JournalClear_Params_Data*>(data);

  return true;
}

ActorHandler_JournalClear_Params_Data::ActorHandler_JournalClear_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ActorHandler_JournalSnapshot_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ActorHandler_JournalSnapshot_Params_Data* object =
      static_cast<const ActorHandler_JournalSnapshot_Params_Data*>(data);

  return true;
}

ActorHandler_JournalSnapshot_Params_Data::ActorHandler_JournalSnapshot_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ActorHandler_JournalSnapshot_ResponseParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ActorHandler_JournalSnapshot_ResponseParams_Data* object =
      static_cast<const ActorHandler_JournalSnapshot_ResponseParams_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->journal, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->journal, validation_context))
    return false;

  return true;
}

ActorHandler_JournalSnapshot_ResponseParams_Data::ActorHandler_JournalSnapshot_ResponseParams_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ActorHandler_JournalStart_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ActorHandler_JournalStart_Params_Data* object =
      static_cast<const ActorHandler_JournalStart_Params_Data*>(data);

  return true;
}

ActorHandler_JournalStart_Params_Data::ActorHandler_JournalStart_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ActorHandler_JournalStop_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 8, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ActorHandler_JournalStop_Params_Data* object =
      static_cast<const ActorHandler_JournalStop_Params_Data*>(data);

  return true;
}

ActorHandler_JournalStop_Params_Data::ActorHandler_JournalStop_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ActorHandler_JournalRecordFeedback_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ActorHandler_JournalRecordFeedback_Params_Data* object =
      static_cast<const ActorHandler_JournalRecordFeedback_Params_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->reason, 2, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& reason_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->reason, validation_context,
                                         &reason_validate_params)) {
    return false;
  }

  return true;
}

ActorHandler_JournalRecordFeedback_Params_Data::ActorHandler_JournalRecordFeedback_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool AnnotationHandler_ScrollTo_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const AnnotationHandler_ScrollTo_Params_Data* object =
      static_cast<const AnnotationHandler_ScrollTo_Params_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->params, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->params, validation_context))
    return false;

  return true;
}

AnnotationHandler_ScrollTo_Params_Data::AnnotationHandler_ScrollTo_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool AnnotationHandler_ScrollTo_ResponseParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const AnnotationHandler_ScrollTo_ResponseParams_Data* object =
      static_cast<const AnnotationHandler_ScrollTo_ResponseParams_Data*>(data);


  if (!::glic::mojom::internal::ScrollToErrorReason_Data
        ::Validate(object->error_reason_$value, validation_context))
    return false;

  return true;
}

AnnotationHandler_ScrollTo_ResponseParams_Data::AnnotationHandler_ScrollTo_ResponseParams_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool AnnotationHandler_DropScrollToHighlight_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 8, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const AnnotationHandler_DropScrollToHighlight_Params_Data* object =
      static_cast<const AnnotationHandler_DropScrollToHighlight_Params_Data*>(data);

  return true;
}

AnnotationHandler_DropScrollToHighlight_Params_Data::AnnotationHandler_DropScrollToHighlight_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool SkillsHandler_CreateSkill_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const SkillsHandler_CreateSkill_Params_Data* object =
      static_cast<const SkillsHandler_CreateSkill_Params_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->request, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->request, validation_context))
    return false;

  return true;
}

SkillsHandler_CreateSkill_Params_Data::SkillsHandler_CreateSkill_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool SkillsHandler_CreateSkill_ResponseParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const SkillsHandler_CreateSkill_ResponseParams_Data* object =
      static_cast<const SkillsHandler_CreateSkill_ResponseParams_Data*>(data);

  return true;
}

SkillsHandler_CreateSkill_ResponseParams_Data::SkillsHandler_CreateSkill_ResponseParams_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool SkillsHandler_UpdateSkill_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const SkillsHandler_UpdateSkill_Params_Data* object =
      static_cast<const SkillsHandler_UpdateSkill_Params_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->request, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->request, validation_context))
    return false;

  return true;
}

SkillsHandler_UpdateSkill_Params_Data::SkillsHandler_UpdateSkill_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool SkillsHandler_UpdateSkill_ResponseParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const SkillsHandler_UpdateSkill_ResponseParams_Data* object =
      static_cast<const SkillsHandler_UpdateSkill_ResponseParams_Data*>(data);

  return true;
}

SkillsHandler_UpdateSkill_ResponseParams_Data::SkillsHandler_UpdateSkill_ResponseParams_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool SkillsHandler_ShowManageSkillsUi_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 8, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const SkillsHandler_ShowManageSkillsUi_Params_Data* object =
      static_cast<const SkillsHandler_ShowManageSkillsUi_Params_Data*>(data);

  return true;
}

SkillsHandler_ShowManageSkillsUi_Params_Data::SkillsHandler_ShowManageSkillsUi_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool SkillsHandler_ShowBrowseSkillsUi_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 8, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const SkillsHandler_ShowBrowseSkillsUi_Params_Data* object =
      static_cast<const SkillsHandler_ShowBrowseSkillsUi_Params_Data*>(data);

  return true;
}

SkillsHandler_ShowBrowseSkillsUi_Params_Data::SkillsHandler_ShowBrowseSkillsUi_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool SkillsHandler_GetSkill_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const SkillsHandler_GetSkill_Params_Data* object =
      static_cast<const SkillsHandler_GetSkill_Params_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->id, 1, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& id_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->id, validation_context,
                                         &id_validate_params)) {
    return false;
  }

  return true;
}

SkillsHandler_GetSkill_Params_Data::SkillsHandler_GetSkill_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool SkillsHandler_GetSkill_ResponseParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const SkillsHandler_GetSkill_ResponseParams_Data* object =
      static_cast<const SkillsHandler_GetSkill_ResponseParams_Data*>(data);

  if (!mojo::internal::ValidateStruct(object->skill, validation_context))
    return false;

  return true;
}

SkillsHandler_GetSkill_ResponseParams_Data::SkillsHandler_GetSkill_ResponseParams_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool SkillsHandler_RecordSkillsWebClientEvent_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const SkillsHandler_RecordSkillsWebClientEvent_Params_Data* object =
      static_cast<const SkillsHandler_RecordSkillsWebClientEvent_Params_Data*>(data);


  if (!::glic::mojom::internal::SkillsWebClientEvent_Data
        ::Validate(object->event, validation_context))
    return false;

  return true;
}

SkillsHandler_RecordSkillsWebClientEvent_Params_Data::SkillsHandler_RecordSkillsWebClientEvent_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool SkillsClient_NotifySkillPreviewsChanged_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const SkillsClient_NotifySkillPreviewsChanged_Params_Data* object =
      static_cast<const SkillsClient_NotifySkillPreviewsChanged_Params_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->skill_previews, 1, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& skill_previews_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->skill_previews, validation_context,
                                         &skill_previews_validate_params)) {
    return false;
  }

  return true;
}

SkillsClient_NotifySkillPreviewsChanged_Params_Data::SkillsClient_NotifySkillPreviewsChanged_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool SkillsClient_NotifyContextualSkillPreviewsChanged_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const SkillsClient_NotifyContextualSkillPreviewsChanged_Params_Data* object =
      static_cast<const SkillsClient_NotifyContextualSkillPreviewsChanged_Params_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->skill_previews, 1, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& skill_previews_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->skill_previews, validation_context,
                                         &skill_previews_validate_params)) {
    return false;
  }

  return true;
}

SkillsClient_NotifyContextualSkillPreviewsChanged_Params_Data::SkillsClient_NotifyContextualSkillPreviewsChanged_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool SkillsClient_NotifySkillPreviewChanged_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const SkillsClient_NotifySkillPreviewChanged_Params_Data* object =
      static_cast<const SkillsClient_NotifySkillPreviewChanged_Params_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->skill_preview, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->skill_preview, validation_context))
    return false;

  return true;
}

SkillsClient_NotifySkillPreviewChanged_Params_Data::SkillsClient_NotifySkillPreviewChanged_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool SkillsClient_NotifySkillDeleted_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const SkillsClient_NotifySkillDeleted_Params_Data* object =
      static_cast<const SkillsClient_NotifySkillDeleted_Params_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->skill_id, 1, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& skill_id_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->skill_id, validation_context,
                                         &skill_id_validate_params)) {
    return false;
  }

  return true;
}

SkillsClient_NotifySkillDeleted_Params_Data::SkillsClient_NotifySkillDeleted_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool SkillsClient_NotifySkillsEnabledChanged_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const SkillsClient_NotifySkillsEnabledChanged_Params_Data* object =
      static_cast<const SkillsClient_NotifySkillsEnabledChanged_Params_Data*>(data);

  return true;
}

SkillsClient_NotifySkillsEnabledChanged_Params_Data::SkillsClient_NotifySkillsEnabledChanged_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_WebClientCreated_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_WebClientCreated_Params_Data* object =
      static_cast<const WebClientHandler_WebClientCreated_Params_Data*>(data);

  if (!mojo::internal::ValidateHandleOrInterfaceNonNullable(
          object->web_client, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateHandleOrInterface(object->web_client,
                                                 validation_context)) {
    return false;
  }

  return true;
}

WebClientHandler_WebClientCreated_Params_Data::WebClientHandler_WebClientCreated_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_WebClientCreated_ResponseParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_WebClientCreated_ResponseParams_Data* object =
      static_cast<const WebClientHandler_WebClientCreated_ResponseParams_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->initial_state, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->initial_state, validation_context))
    return false;

  return true;
}

WebClientHandler_WebClientCreated_ResponseParams_Data::WebClientHandler_WebClientCreated_ResponseParams_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_WebClientInitialized_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 8, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_WebClientInitialized_Params_Data* object =
      static_cast<const WebClientHandler_WebClientInitialized_Params_Data*>(data);

  return true;
}

WebClientHandler_WebClientInitialized_Params_Data::WebClientHandler_WebClientInitialized_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_WebClientInitializeFailed_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 8, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_WebClientInitializeFailed_Params_Data* object =
      static_cast<const WebClientHandler_WebClientInitializeFailed_Params_Data*>(data);

  return true;
}

WebClientHandler_WebClientInitializeFailed_Params_Data::WebClientHandler_WebClientInitializeFailed_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_CreateActorHandler_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_CreateActorHandler_Params_Data* object =
      static_cast<const WebClientHandler_CreateActorHandler_Params_Data*>(data);

  if (!mojo::internal::ValidateHandleOrInterfaceNonNullable(
          object->receiver, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateHandleOrInterface(object->receiver,
                                                 validation_context)) {
    return false;
  }

  if (!mojo::internal::ValidateHandleOrInterfaceNonNullable(
          object->client, 2, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateHandleOrInterface(object->client,
                                                 validation_context)) {
    return false;
  }

  return true;
}

WebClientHandler_CreateActorHandler_Params_Data::WebClientHandler_CreateActorHandler_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_CreateExperimentalTriggeringClient_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_CreateExperimentalTriggeringClient_Params_Data* object =
      static_cast<const WebClientHandler_CreateExperimentalTriggeringClient_Params_Data*>(data);

  if (!mojo::internal::ValidateHandleOrInterfaceNonNullable(
          object->client, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateHandleOrInterface(object->client,
                                                 validation_context)) {
    return false;
  }

  return true;
}

WebClientHandler_CreateExperimentalTriggeringClient_Params_Data::WebClientHandler_CreateExperimentalTriggeringClient_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_CreateAnnotationHandler_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_CreateAnnotationHandler_Params_Data* object =
      static_cast<const WebClientHandler_CreateAnnotationHandler_Params_Data*>(data);

  if (!mojo::internal::ValidateHandleOrInterfaceNonNullable(
          object->receiver, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateHandleOrInterface(object->receiver,
                                                 validation_context)) {
    return false;
  }

  return true;
}

WebClientHandler_CreateAnnotationHandler_Params_Data::WebClientHandler_CreateAnnotationHandler_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_CreateSkillsHandler_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_CreateSkillsHandler_Params_Data* object =
      static_cast<const WebClientHandler_CreateSkillsHandler_Params_Data*>(data);

  if (!mojo::internal::ValidateHandleOrInterfaceNonNullable(
          object->receiver, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateHandleOrInterface(object->receiver,
                                                 validation_context)) {
    return false;
  }

  if (!mojo::internal::ValidateHandleOrInterfaceNonNullable(
          object->client, 2, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateHandleOrInterface(object->client,
                                                 validation_context)) {
    return false;
  }

  return true;
}

WebClientHandler_CreateSkillsHandler_Params_Data::WebClientHandler_CreateSkillsHandler_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_CreateZeroStateSuggestionsHandler_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_CreateZeroStateSuggestionsHandler_Params_Data* object =
      static_cast<const WebClientHandler_CreateZeroStateSuggestionsHandler_Params_Data*>(data);

  if (!mojo::internal::ValidateHandleOrInterfaceNonNullable(
          object->receiver, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateHandleOrInterface(object->receiver,
                                                 validation_context)) {
    return false;
  }

  return true;
}

WebClientHandler_CreateZeroStateSuggestionsHandler_Params_Data::WebClientHandler_CreateZeroStateSuggestionsHandler_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_CreateTab_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_CreateTab_Params_Data* object =
      static_cast<const WebClientHandler_CreateTab_Params_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->url, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->url, validation_context))
    return false;

  if (!mojo::internal::ValidatePointerNonNullable(
          object->create_options, 2, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->create_options, validation_context))
    return false;

  return true;
}

WebClientHandler_CreateTab_Params_Data::WebClientHandler_CreateTab_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_CreateTab_ResponseParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_CreateTab_ResponseParams_Data* object =
      static_cast<const WebClientHandler_CreateTab_ResponseParams_Data*>(data);

  if (!mojo::internal::ValidateStruct(object->tab_data, validation_context))
    return false;

  return true;
}

WebClientHandler_CreateTab_ResponseParams_Data::WebClientHandler_CreateTab_ResponseParams_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_ActivateTabWithUrl_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_ActivateTabWithUrl_Params_Data* object =
      static_cast<const WebClientHandler_ActivateTabWithUrl_Params_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->exact_url, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->exact_url, validation_context))
    return false;

  if (!mojo::internal::ValidateStruct(object->options, validation_context))
    return false;

  return true;
}

WebClientHandler_ActivateTabWithUrl_Params_Data::WebClientHandler_ActivateTabWithUrl_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_ActivateTabWithUrl_ResponseParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_ActivateTabWithUrl_ResponseParams_Data* object =
      static_cast<const WebClientHandler_ActivateTabWithUrl_ResponseParams_Data*>(data);

  if (!mojo::internal::ValidateStruct(object->tab_data, validation_context))
    return false;

  return true;
}

WebClientHandler_ActivateTabWithUrl_ResponseParams_Data::WebClientHandler_ActivateTabWithUrl_ResponseParams_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_OpenLinkInPopup_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_OpenLinkInPopup_Params_Data* object =
      static_cast<const WebClientHandler_OpenLinkInPopup_Params_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->url, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->url, validation_context))
    return false;

  return true;
}

WebClientHandler_OpenLinkInPopup_Params_Data::WebClientHandler_OpenLinkInPopup_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_OpenGlicSettingsPage_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_OpenGlicSettingsPage_Params_Data* object =
      static_cast<const WebClientHandler_OpenGlicSettingsPage_Params_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->options, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->options, validation_context))
    return false;

  return true;
}

WebClientHandler_OpenGlicSettingsPage_Params_Data::WebClientHandler_OpenGlicSettingsPage_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_OpenPasswordManagerSettingsPage_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 8, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_OpenPasswordManagerSettingsPage_Params_Data* object =
      static_cast<const WebClientHandler_OpenPasswordManagerSettingsPage_Params_Data*>(data);

  return true;
}

WebClientHandler_OpenPasswordManagerSettingsPage_Params_Data::WebClientHandler_OpenPasswordManagerSettingsPage_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_EnableDragResize_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_EnableDragResize_Params_Data* object =
      static_cast<const WebClientHandler_EnableDragResize_Params_Data*>(data);

  return true;
}

WebClientHandler_EnableDragResize_Params_Data::WebClientHandler_EnableDragResize_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_ClosePanel_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 8, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_ClosePanel_Params_Data* object =
      static_cast<const WebClientHandler_ClosePanel_Params_Data*>(data);

  return true;
}

WebClientHandler_ClosePanel_Params_Data::WebClientHandler_ClosePanel_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_ClosePanelAndShutdown_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 8, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_ClosePanelAndShutdown_Params_Data* object =
      static_cast<const WebClientHandler_ClosePanelAndShutdown_Params_Data*>(data);

  return true;
}

WebClientHandler_ClosePanelAndShutdown_Params_Data::WebClientHandler_ClosePanelAndShutdown_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_AttachPanel_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 8, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_AttachPanel_Params_Data* object =
      static_cast<const WebClientHandler_AttachPanel_Params_Data*>(data);

  return true;
}

WebClientHandler_AttachPanel_Params_Data::WebClientHandler_AttachPanel_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_DetachPanel_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 8, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_DetachPanel_Params_Data* object =
      static_cast<const WebClientHandler_DetachPanel_Params_Data*>(data);

  return true;
}

WebClientHandler_DetachPanel_Params_Data::WebClientHandler_DetachPanel_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_OnModeChange_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_OnModeChange_Params_Data* object =
      static_cast<const WebClientHandler_OnModeChange_Params_Data*>(data);


  if (!::glic::mojom::internal::WebClientMode_Data
        ::Validate(object->new_mode, validation_context))
    return false;

  return true;
}

WebClientHandler_OnModeChange_Params_Data::WebClientHandler_OnModeChange_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_OnMicrophoneStatusChange_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_OnMicrophoneStatusChange_Params_Data* object =
      static_cast<const WebClientHandler_OnMicrophoneStatusChange_Params_Data*>(data);


  if (!::glic::mojom::internal::MicrophoneStatus_Data
        ::Validate(object->status, validation_context))
    return false;

  return true;
}

WebClientHandler_OnMicrophoneStatusChange_Params_Data::WebClientHandler_OnMicrophoneStatusChange_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_ShowProfilePicker_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 8, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_ShowProfilePicker_Params_Data* object =
      static_cast<const WebClientHandler_ShowProfilePicker_Params_Data*>(data);

  return true;
}

WebClientHandler_ShowProfilePicker_Params_Data::WebClientHandler_ShowProfilePicker_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_GetModelQualityClientId_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 8, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_GetModelQualityClientId_Params_Data* object =
      static_cast<const WebClientHandler_GetModelQualityClientId_Params_Data*>(data);

  return true;
}

WebClientHandler_GetModelQualityClientId_Params_Data::WebClientHandler_GetModelQualityClientId_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_GetModelQualityClientId_ResponseParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_GetModelQualityClientId_ResponseParams_Data* object =
      static_cast<const WebClientHandler_GetModelQualityClientId_ResponseParams_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->model_quality_client_id, 1, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& model_quality_client_id_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->model_quality_client_id, validation_context,
                                         &model_quality_client_id_validate_params)) {
    return false;
  }

  return true;
}

WebClientHandler_GetModelQualityClientId_ResponseParams_Data::WebClientHandler_GetModelQualityClientId_ResponseParams_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_GetContextFromFocusedTab_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_GetContextFromFocusedTab_Params_Data* object =
      static_cast<const WebClientHandler_GetContextFromFocusedTab_Params_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->options, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->options, validation_context))
    return false;

  return true;
}

WebClientHandler_GetContextFromFocusedTab_Params_Data::WebClientHandler_GetContextFromFocusedTab_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_GetContextFromFocusedTab_ResponseParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_GetContextFromFocusedTab_ResponseParams_Data* object =
      static_cast<const WebClientHandler_GetContextFromFocusedTab_ResponseParams_Data*>(data);

  if (!mojo::internal::ValidateInlinedUnionNonNullable(
          object->result, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateInlinedUnion(object->result, validation_context))
    return false;

  return true;
}

WebClientHandler_GetContextFromFocusedTab_ResponseParams_Data::WebClientHandler_GetContextFromFocusedTab_ResponseParams_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_GetContextFromTab_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_GetContextFromTab_Params_Data* object =
      static_cast<const WebClientHandler_GetContextFromTab_Params_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->options, 2, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->options, validation_context))
    return false;

  return true;
}

WebClientHandler_GetContextFromTab_Params_Data::WebClientHandler_GetContextFromTab_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_GetContextFromTab_ResponseParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_GetContextFromTab_ResponseParams_Data* object =
      static_cast<const WebClientHandler_GetContextFromTab_ResponseParams_Data*>(data);

  if (!mojo::internal::ValidateInlinedUnionNonNullable(
          object->result, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateInlinedUnion(object->result, validation_context))
    return false;

  return true;
}

WebClientHandler_GetContextFromTab_ResponseParams_Data::WebClientHandler_GetContextFromTab_ResponseParams_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_GetImageBytesFromTab_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_GetImageBytesFromTab_Params_Data* object =
      static_cast<const WebClientHandler_GetImageBytesFromTab_Params_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->document_id, 2, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& document_id_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->document_id, validation_context,
                                         &document_id_validate_params)) {
    return false;
  }

  return true;
}

WebClientHandler_GetImageBytesFromTab_Params_Data::WebClientHandler_GetImageBytesFromTab_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_GetImageBytesFromTab_ResponseParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_GetImageBytesFromTab_ResponseParams_Data* object =
      static_cast<const WebClientHandler_GetImageBytesFromTab_ResponseParams_Data*>(data);

  if (!mojo::internal::ValidateInlinedUnionNonNullable(
          object->result, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateInlinedUnion(object->result, validation_context))
    return false;

  return true;
}

WebClientHandler_GetImageBytesFromTab_ResponseParams_Data::WebClientHandler_GetImageBytesFromTab_ResponseParams_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_SetMaximumNumberOfPinnedTabs_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_SetMaximumNumberOfPinnedTabs_Params_Data* object =
      static_cast<const WebClientHandler_SetMaximumNumberOfPinnedTabs_Params_Data*>(data);

  return true;
}

WebClientHandler_SetMaximumNumberOfPinnedTabs_Params_Data::WebClientHandler_SetMaximumNumberOfPinnedTabs_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_SetMaximumNumberOfPinnedTabs_ResponseParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_SetMaximumNumberOfPinnedTabs_ResponseParams_Data* object =
      static_cast<const WebClientHandler_SetMaximumNumberOfPinnedTabs_ResponseParams_Data*>(data);

  return true;
}

WebClientHandler_SetMaximumNumberOfPinnedTabs_ResponseParams_Data::WebClientHandler_SetMaximumNumberOfPinnedTabs_ResponseParams_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_PinTabs_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_PinTabs_Params_Data* object =
      static_cast<const WebClientHandler_PinTabs_Params_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->tab_ids, 1, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& tab_ids_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->tab_ids, validation_context,
                                         &tab_ids_validate_params)) {
    return false;
  }

  if (!mojo::internal::ValidateStruct(object->options, validation_context))
    return false;

  return true;
}

WebClientHandler_PinTabs_Params_Data::WebClientHandler_PinTabs_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_PinTabs_ResponseParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_PinTabs_ResponseParams_Data* object =
      static_cast<const WebClientHandler_PinTabs_ResponseParams_Data*>(data);

  return true;
}

WebClientHandler_PinTabs_ResponseParams_Data::WebClientHandler_PinTabs_ResponseParams_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_UnpinTabs_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_UnpinTabs_Params_Data* object =
      static_cast<const WebClientHandler_UnpinTabs_Params_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->tab_ids, 1, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& tab_ids_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->tab_ids, validation_context,
                                         &tab_ids_validate_params)) {
    return false;
  }

  if (!mojo::internal::ValidateStruct(object->options, validation_context))
    return false;

  return true;
}

WebClientHandler_UnpinTabs_Params_Data::WebClientHandler_UnpinTabs_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_UnpinTabs_ResponseParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_UnpinTabs_ResponseParams_Data* object =
      static_cast<const WebClientHandler_UnpinTabs_ResponseParams_Data*>(data);

  return true;
}

WebClientHandler_UnpinTabs_ResponseParams_Data::WebClientHandler_UnpinTabs_ResponseParams_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_UnpinAllTabs_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_UnpinAllTabs_Params_Data* object =
      static_cast<const WebClientHandler_UnpinAllTabs_Params_Data*>(data);

  if (!mojo::internal::ValidateStruct(object->options, validation_context))
    return false;

  return true;
}

WebClientHandler_UnpinAllTabs_Params_Data::WebClientHandler_UnpinAllTabs_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_SubscribeToPinCandidates_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_SubscribeToPinCandidates_Params_Data* object =
      static_cast<const WebClientHandler_SubscribeToPinCandidates_Params_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->options, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->options, validation_context))
    return false;

  if (!mojo::internal::ValidateHandleOrInterfaceNonNullable(
          object->observer, 2, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateHandleOrInterface(object->observer,
                                                 validation_context)) {
    return false;
  }

  return true;
}

WebClientHandler_SubscribeToPinCandidates_Params_Data::WebClientHandler_SubscribeToPinCandidates_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_OpenPinnedTabPicker_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_OpenPinnedTabPicker_Params_Data* object =
      static_cast<const WebClientHandler_OpenPinnedTabPicker_Params_Data*>(data);

  if (!mojo::internal::ValidateStruct(object->options, validation_context))
    return false;

  return true;
}

WebClientHandler_OpenPinnedTabPicker_Params_Data::WebClientHandler_OpenPinnedTabPicker_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_OpenPinnedTabPicker_ResponseParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 8, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_OpenPinnedTabPicker_ResponseParams_Data* object =
      static_cast<const WebClientHandler_OpenPinnedTabPicker_ResponseParams_Data*>(data);

  return true;
}

WebClientHandler_OpenPinnedTabPicker_ResponseParams_Data::WebClientHandler_OpenPinnedTabPicker_ResponseParams_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_ActivateTab_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_ActivateTab_Params_Data* object =
      static_cast<const WebClientHandler_ActivateTab_Params_Data*>(data);

  return true;
}

WebClientHandler_ActivateTab_Params_Data::WebClientHandler_ActivateTab_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_ResizeWidget_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_ResizeWidget_Params_Data* object =
      static_cast<const WebClientHandler_ResizeWidget_Params_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->size, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->size, validation_context))
    return false;

  if (!mojo::internal::ValidatePointerNonNullable(
          object->duration, 2, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->duration, validation_context))
    return false;

  return true;
}

WebClientHandler_ResizeWidget_Params_Data::WebClientHandler_ResizeWidget_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_ResizeWidget_ResponseParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 8, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_ResizeWidget_ResponseParams_Data* object =
      static_cast<const WebClientHandler_ResizeWidget_ResponseParams_Data*>(data);

  return true;
}

WebClientHandler_ResizeWidget_ResponseParams_Data::WebClientHandler_ResizeWidget_ResponseParams_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_CaptureScreenshot_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 8, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_CaptureScreenshot_Params_Data* object =
      static_cast<const WebClientHandler_CaptureScreenshot_Params_Data*>(data);

  return true;
}

WebClientHandler_CaptureScreenshot_Params_Data::WebClientHandler_CaptureScreenshot_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_CaptureScreenshot_ResponseParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_CaptureScreenshot_ResponseParams_Data* object =
      static_cast<const WebClientHandler_CaptureScreenshot_ResponseParams_Data*>(data);

  if (!mojo::internal::ValidateInlinedUnionNonNullable(
          object->result, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateInlinedUnion(object->result, validation_context))
    return false;

  return true;
}

WebClientHandler_CaptureScreenshot_ResponseParams_Data::WebClientHandler_CaptureScreenshot_ResponseParams_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_CaptureRegion_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_CaptureRegion_Params_Data* object =
      static_cast<const WebClientHandler_CaptureRegion_Params_Data*>(data);

  if (!mojo::internal::ValidateHandleOrInterfaceNonNullable(
          object->observer, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateHandleOrInterface(object->observer,
                                                 validation_context)) {
    return false;
  }

  if (!mojo::internal::ValidateStruct(object->params, validation_context))
    return false;

  return true;
}

WebClientHandler_CaptureRegion_Params_Data::WebClientHandler_CaptureRegion_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_DeleteCapturedRegion_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_DeleteCapturedRegion_Params_Data* object =
      static_cast<const WebClientHandler_DeleteCapturedRegion_Params_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->id, 2, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->id, validation_context))
    return false;

  return true;
}

WebClientHandler_DeleteCapturedRegion_Params_Data::WebClientHandler_DeleteCapturedRegion_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_SetAudioDucking_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_SetAudioDucking_Params_Data* object =
      static_cast<const WebClientHandler_SetAudioDucking_Params_Data*>(data);

  return true;
}

WebClientHandler_SetAudioDucking_Params_Data::WebClientHandler_SetAudioDucking_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_SetAudioDucking_ResponseParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_SetAudioDucking_ResponseParams_Data* object =
      static_cast<const WebClientHandler_SetAudioDucking_ResponseParams_Data*>(data);

  return true;
}

WebClientHandler_SetAudioDucking_ResponseParams_Data::WebClientHandler_SetAudioDucking_ResponseParams_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_SetMinimumPanelSize_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_SetMinimumPanelSize_Params_Data* object =
      static_cast<const WebClientHandler_SetMinimumPanelSize_Params_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->size, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->size, validation_context))
    return false;

  return true;
}

WebClientHandler_SetMinimumPanelSize_Params_Data::WebClientHandler_SetMinimumPanelSize_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_SetMicrophonePermissionState_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_SetMicrophonePermissionState_Params_Data* object =
      static_cast<const WebClientHandler_SetMicrophonePermissionState_Params_Data*>(data);

  return true;
}

WebClientHandler_SetMicrophonePermissionState_Params_Data::WebClientHandler_SetMicrophonePermissionState_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_SetMicrophonePermissionState_ResponseParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 8, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_SetMicrophonePermissionState_ResponseParams_Data* object =
      static_cast<const WebClientHandler_SetMicrophonePermissionState_ResponseParams_Data*>(data);

  return true;
}

WebClientHandler_SetMicrophonePermissionState_ResponseParams_Data::WebClientHandler_SetMicrophonePermissionState_ResponseParams_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_SetLocationPermissionState_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_SetLocationPermissionState_Params_Data* object =
      static_cast<const WebClientHandler_SetLocationPermissionState_Params_Data*>(data);

  return true;
}

WebClientHandler_SetLocationPermissionState_Params_Data::WebClientHandler_SetLocationPermissionState_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_SetLocationPermissionState_ResponseParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 8, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_SetLocationPermissionState_ResponseParams_Data* object =
      static_cast<const WebClientHandler_SetLocationPermissionState_ResponseParams_Data*>(data);

  return true;
}

WebClientHandler_SetLocationPermissionState_ResponseParams_Data::WebClientHandler_SetLocationPermissionState_ResponseParams_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_SetTabContextPermissionState_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_SetTabContextPermissionState_Params_Data* object =
      static_cast<const WebClientHandler_SetTabContextPermissionState_Params_Data*>(data);

  return true;
}

WebClientHandler_SetTabContextPermissionState_Params_Data::WebClientHandler_SetTabContextPermissionState_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_SetTabContextPermissionState_ResponseParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 8, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_SetTabContextPermissionState_ResponseParams_Data* object =
      static_cast<const WebClientHandler_SetTabContextPermissionState_ResponseParams_Data*>(data);

  return true;
}

WebClientHandler_SetTabContextPermissionState_ResponseParams_Data::WebClientHandler_SetTabContextPermissionState_ResponseParams_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_SetClosedCaptioningSetting_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_SetClosedCaptioningSetting_Params_Data* object =
      static_cast<const WebClientHandler_SetClosedCaptioningSetting_Params_Data*>(data);

  return true;
}

WebClientHandler_SetClosedCaptioningSetting_Params_Data::WebClientHandler_SetClosedCaptioningSetting_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_SetClosedCaptioningSetting_ResponseParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 8, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_SetClosedCaptioningSetting_ResponseParams_Data* object =
      static_cast<const WebClientHandler_SetClosedCaptioningSetting_ResponseParams_Data*>(data);

  return true;
}

WebClientHandler_SetClosedCaptioningSetting_ResponseParams_Data::WebClientHandler_SetClosedCaptioningSetting_ResponseParams_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_SetActuationOnWebSetting_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_SetActuationOnWebSetting_Params_Data* object =
      static_cast<const WebClientHandler_SetActuationOnWebSetting_Params_Data*>(data);

  return true;
}

WebClientHandler_SetActuationOnWebSetting_Params_Data::WebClientHandler_SetActuationOnWebSetting_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_SetActuationOnWebSetting_ResponseParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 8, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_SetActuationOnWebSetting_ResponseParams_Data* object =
      static_cast<const WebClientHandler_SetActuationOnWebSetting_ResponseParams_Data*>(data);

  return true;
}

WebClientHandler_SetActuationOnWebSetting_ResponseParams_Data::WebClientHandler_SetActuationOnWebSetting_ResponseParams_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_ShouldAllowMediaPermissionRequest_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 8, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_ShouldAllowMediaPermissionRequest_Params_Data* object =
      static_cast<const WebClientHandler_ShouldAllowMediaPermissionRequest_Params_Data*>(data);

  return true;
}

WebClientHandler_ShouldAllowMediaPermissionRequest_Params_Data::WebClientHandler_ShouldAllowMediaPermissionRequest_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_ShouldAllowMediaPermissionRequest_ResponseParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_ShouldAllowMediaPermissionRequest_ResponseParams_Data* object =
      static_cast<const WebClientHandler_ShouldAllowMediaPermissionRequest_ResponseParams_Data*>(data);

  return true;
}

WebClientHandler_ShouldAllowMediaPermissionRequest_ResponseParams_Data::WebClientHandler_ShouldAllowMediaPermissionRequest_ResponseParams_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_ShouldAllowGeolocationPermissionRequest_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 8, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_ShouldAllowGeolocationPermissionRequest_Params_Data* object =
      static_cast<const WebClientHandler_ShouldAllowGeolocationPermissionRequest_Params_Data*>(data);

  return true;
}

WebClientHandler_ShouldAllowGeolocationPermissionRequest_Params_Data::WebClientHandler_ShouldAllowGeolocationPermissionRequest_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_ShouldAllowGeolocationPermissionRequest_ResponseParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_ShouldAllowGeolocationPermissionRequest_ResponseParams_Data* object =
      static_cast<const WebClientHandler_ShouldAllowGeolocationPermissionRequest_ResponseParams_Data*>(data);

  return true;
}

WebClientHandler_ShouldAllowGeolocationPermissionRequest_ResponseParams_Data::WebClientHandler_ShouldAllowGeolocationPermissionRequest_ResponseParams_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_SetContextAccessIndicator_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_SetContextAccessIndicator_Params_Data* object =
      static_cast<const WebClientHandler_SetContextAccessIndicator_Params_Data*>(data);

  return true;
}

WebClientHandler_SetContextAccessIndicator_Params_Data::WebClientHandler_SetContextAccessIndicator_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_GetUserProfileInfo_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 8, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_GetUserProfileInfo_Params_Data* object =
      static_cast<const WebClientHandler_GetUserProfileInfo_Params_Data*>(data);

  return true;
}

WebClientHandler_GetUserProfileInfo_Params_Data::WebClientHandler_GetUserProfileInfo_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_GetUserProfileInfo_ResponseParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_GetUserProfileInfo_ResponseParams_Data* object =
      static_cast<const WebClientHandler_GetUserProfileInfo_ResponseParams_Data*>(data);

  if (!mojo::internal::ValidateStruct(object->profile_info, validation_context))
    return false;

  return true;
}

WebClientHandler_GetUserProfileInfo_ResponseParams_Data::WebClientHandler_GetUserProfileInfo_ResponseParams_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_SyncCookies_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 8, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_SyncCookies_Params_Data* object =
      static_cast<const WebClientHandler_SyncCookies_Params_Data*>(data);

  return true;
}

WebClientHandler_SyncCookies_Params_Data::WebClientHandler_SyncCookies_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_SyncCookies_ResponseParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_SyncCookies_ResponseParams_Data* object =
      static_cast<const WebClientHandler_SyncCookies_ResponseParams_Data*>(data);

  return true;
}

WebClientHandler_SyncCookies_ResponseParams_Data::WebClientHandler_SyncCookies_ResponseParams_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_ClientErrorDialogStateChanged_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_ClientErrorDialogStateChanged_Params_Data* object =
      static_cast<const WebClientHandler_ClientErrorDialogStateChanged_Params_Data*>(data);


  if (!::glic::mojom::internal::ClientErrorDialogType_Data
        ::Validate(object->shown_dialog_type_$value, validation_context))
    return false;

  return true;
}

WebClientHandler_ClientErrorDialogStateChanged_Params_Data::WebClientHandler_ClientErrorDialogStateChanged_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_ReportClientTransientError_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_ReportClientTransientError_Params_Data* object =
      static_cast<const WebClientHandler_ReportClientTransientError_Params_Data*>(data);


  if (!::mojo_base::mojom::internal::AbslStatusCode_Data
        ::Validate(object->status_code, validation_context))
    return false;

  return true;
}

WebClientHandler_ReportClientTransientError_Params_Data::WebClientHandler_ReportClientTransientError_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_ProcessCounterAbuseVerdict_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_ProcessCounterAbuseVerdict_Params_Data* object =
      static_cast<const WebClientHandler_ProcessCounterAbuseVerdict_Params_Data*>(data);

  if (!mojo::internal::ValidateStruct(object->verdict, validation_context))
    return false;

  return true;
}

WebClientHandler_ProcessCounterAbuseVerdict_Params_Data::WebClientHandler_ProcessCounterAbuseVerdict_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_OnOptinImpression_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 8, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_OnOptinImpression_Params_Data* object =
      static_cast<const WebClientHandler_OnOptinImpression_Params_Data*>(data);

  return true;
}

WebClientHandler_OnOptinImpression_Params_Data::WebClientHandler_OnOptinImpression_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_OnUserInputSubmitted_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  static constexpr mojo::internal::StructVersionSize kVersionSizes[] = {
    { 0, 16 },
    { 1, 16 },
  };
  if (!ValidateStructHeaderAndVersionSizeAndClaimMemory(
          data, kVersionSizes, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_OnUserInputSubmitted_Params_Data* object =
      static_cast<const WebClientHandler_OnUserInputSubmitted_Params_Data*>(data);


  if (!::glic::mojom::internal::WebClientMode_Data
        ::Validate(object->mode, validation_context))
    return false;
  if (object->header_.version < 1)
    return true;


  if (!::glic::mojom::internal::PromptType_Data
        ::Validate(object->prompt_type, validation_context))
    return false;

  return true;
}

WebClientHandler_OnUserInputSubmitted_Params_Data::WebClientHandler_OnUserInputSubmitted_Params_Data()
    : header_({sizeof(*this), 1}) {}


// static
bool WebClientHandler_OnContextUploadStarted_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 8, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_OnContextUploadStarted_Params_Data* object =
      static_cast<const WebClientHandler_OnContextUploadStarted_Params_Data*>(data);

  return true;
}

WebClientHandler_OnContextUploadStarted_Params_Data::WebClientHandler_OnContextUploadStarted_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_OnContextUploadCompleted_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 8, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_OnContextUploadCompleted_Params_Data* object =
      static_cast<const WebClientHandler_OnContextUploadCompleted_Params_Data*>(data);

  return true;
}

WebClientHandler_OnContextUploadCompleted_Params_Data::WebClientHandler_OnContextUploadCompleted_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_OnReaction_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_OnReaction_Params_Data* object =
      static_cast<const WebClientHandler_OnReaction_Params_Data*>(data);


  if (!::glic::mojom::internal::MetricUserInputReactionType_Data
        ::Validate(object->reactionType, validation_context))
    return false;

  return true;
}

WebClientHandler_OnReaction_Params_Data::WebClientHandler_OnReaction_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_OnResponseStarted_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 8, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_OnResponseStarted_Params_Data* object =
      static_cast<const WebClientHandler_OnResponseStarted_Params_Data*>(data);

  return true;
}

WebClientHandler_OnResponseStarted_Params_Data::WebClientHandler_OnResponseStarted_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_OnResponseStopped_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_OnResponseStopped_Params_Data* object =
      static_cast<const WebClientHandler_OnResponseStopped_Params_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->details, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->details, validation_context))
    return false;

  return true;
}

WebClientHandler_OnResponseStopped_Params_Data::WebClientHandler_OnResponseStopped_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_OnSessionTerminated_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 8, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_OnSessionTerminated_Params_Data* object =
      static_cast<const WebClientHandler_OnSessionTerminated_Params_Data*>(data);

  return true;
}

WebClientHandler_OnSessionTerminated_Params_Data::WebClientHandler_OnSessionTerminated_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_OnTurnCompleted_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_OnTurnCompleted_Params_Data* object =
      static_cast<const WebClientHandler_OnTurnCompleted_Params_Data*>(data);


  if (!::glic::mojom::internal::WebClientModel_Data
        ::Validate(object->model, validation_context))
    return false;

  if (!mojo::internal::ValidatePointerNonNullable(
          object->duration, 2, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->duration, validation_context))
    return false;

  return true;
}

WebClientHandler_OnTurnCompleted_Params_Data::WebClientHandler_OnTurnCompleted_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_OnResponseRated_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_OnResponseRated_Params_Data* object =
      static_cast<const WebClientHandler_OnResponseRated_Params_Data*>(data);

  return true;
}

WebClientHandler_OnResponseRated_Params_Data::WebClientHandler_OnResponseRated_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_OnClosedCaptionsShown_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 8, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_OnClosedCaptionsShown_Params_Data* object =
      static_cast<const WebClientHandler_OnClosedCaptionsShown_Params_Data*>(data);

  return true;
}

WebClientHandler_OnClosedCaptionsShown_Params_Data::WebClientHandler_OnClosedCaptionsShown_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_OnActionSubmitted_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_OnActionSubmitted_Params_Data* object =
      static_cast<const WebClientHandler_OnActionSubmitted_Params_Data*>(data);

  return true;
}

WebClientHandler_OnActionSubmitted_Params_Data::WebClientHandler_OnActionSubmitted_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_SetSyntheticExperimentState_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_SetSyntheticExperimentState_Params_Data* object =
      static_cast<const WebClientHandler_SetSyntheticExperimentState_Params_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->trial_name, 1, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& trial_name_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->trial_name, validation_context,
                                         &trial_name_validate_params)) {
    return false;
  }

  if (!mojo::internal::ValidatePointerNonNullable(
          object->group_name, 2, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& group_name_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->group_name, validation_context,
                                         &group_name_validate_params)) {
    return false;
  }

  return true;
}

WebClientHandler_SetSyntheticExperimentState_Params_Data::WebClientHandler_SetSyntheticExperimentState_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_OpenOsPermissionSettingsMenu_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_OpenOsPermissionSettingsMenu_Params_Data* object =
      static_cast<const WebClientHandler_OpenOsPermissionSettingsMenu_Params_Data*>(data);


  if (!::content_settings::mojom::internal::ContentSettingsType_Data
        ::Validate(object->type, validation_context))
    return false;

  return true;
}

WebClientHandler_OpenOsPermissionSettingsMenu_Params_Data::WebClientHandler_OpenOsPermissionSettingsMenu_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_GetOsMicrophonePermissionStatus_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 8, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_GetOsMicrophonePermissionStatus_Params_Data* object =
      static_cast<const WebClientHandler_GetOsMicrophonePermissionStatus_Params_Data*>(data);

  return true;
}

WebClientHandler_GetOsMicrophonePermissionStatus_Params_Data::WebClientHandler_GetOsMicrophonePermissionStatus_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_GetOsMicrophonePermissionStatus_ResponseParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_GetOsMicrophonePermissionStatus_ResponseParams_Data* object =
      static_cast<const WebClientHandler_GetOsMicrophonePermissionStatus_ResponseParams_Data*>(data);

  return true;
}

WebClientHandler_GetOsMicrophonePermissionStatus_ResponseParams_Data::WebClientHandler_GetOsMicrophonePermissionStatus_ResponseParams_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_GetZeroStateSuggestionsForFocusedTab_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_GetZeroStateSuggestionsForFocusedTab_Params_Data* object =
      static_cast<const WebClientHandler_GetZeroStateSuggestionsForFocusedTab_Params_Data*>(data);

  return true;
}

WebClientHandler_GetZeroStateSuggestionsForFocusedTab_Params_Data::WebClientHandler_GetZeroStateSuggestionsForFocusedTab_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_GetZeroStateSuggestionsForFocusedTab_ResponseParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_GetZeroStateSuggestionsForFocusedTab_ResponseParams_Data* object =
      static_cast<const WebClientHandler_GetZeroStateSuggestionsForFocusedTab_ResponseParams_Data*>(data);

  if (!mojo::internal::ValidateStruct(object->suggestions, validation_context))
    return false;

  return true;
}

WebClientHandler_GetZeroStateSuggestionsForFocusedTab_ResponseParams_Data::WebClientHandler_GetZeroStateSuggestionsForFocusedTab_ResponseParams_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_MaybeRefreshUserStatus_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 8, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_MaybeRefreshUserStatus_Params_Data* object =
      static_cast<const WebClientHandler_MaybeRefreshUserStatus_Params_Data*>(data);

  return true;
}

WebClientHandler_MaybeRefreshUserStatus_Params_Data::WebClientHandler_MaybeRefreshUserStatus_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_IsDebuggerAttached_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 8, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_IsDebuggerAttached_Params_Data* object =
      static_cast<const WebClientHandler_IsDebuggerAttached_Params_Data*>(data);

  return true;
}

WebClientHandler_IsDebuggerAttached_Params_Data::WebClientHandler_IsDebuggerAttached_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_IsDebuggerAttached_ResponseParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_IsDebuggerAttached_ResponseParams_Data* object =
      static_cast<const WebClientHandler_IsDebuggerAttached_ResponseParams_Data*>(data);

  return true;
}

WebClientHandler_IsDebuggerAttached_ResponseParams_Data::WebClientHandler_IsDebuggerAttached_ResponseParams_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_SubscribeToPageMetadata_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_SubscribeToPageMetadata_Params_Data* object =
      static_cast<const WebClientHandler_SubscribeToPageMetadata_Params_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->names, 2, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& names_validate_params =
      mojo::internal::GetArrayValidator<0, false, &mojo::internal::GetArrayValidator<0, false, nullptr>()>();
  if (!mojo::internal::ValidateContainer(object->names, validation_context,
                                         &names_validate_params)) {
    return false;
  }

  return true;
}

WebClientHandler_SubscribeToPageMetadata_Params_Data::WebClientHandler_SubscribeToPageMetadata_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_SubscribeToPageMetadata_ResponseParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_SubscribeToPageMetadata_ResponseParams_Data* object =
      static_cast<const WebClientHandler_SubscribeToPageMetadata_ResponseParams_Data*>(data);

  return true;
}

WebClientHandler_SubscribeToPageMetadata_ResponseParams_Data::WebClientHandler_SubscribeToPageMetadata_ResponseParams_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_SwitchConversation_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_SwitchConversation_Params_Data* object =
      static_cast<const WebClientHandler_SwitchConversation_Params_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->info, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->info, validation_context))
    return false;

  return true;
}

WebClientHandler_SwitchConversation_Params_Data::WebClientHandler_SwitchConversation_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_SwitchConversation_ResponseParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_SwitchConversation_ResponseParams_Data* object =
      static_cast<const WebClientHandler_SwitchConversation_ResponseParams_Data*>(data);


  if (!::glic::mojom::internal::SwitchConversationErrorReason_Data
        ::Validate(object->error_reason_$value, validation_context))
    return false;

  return true;
}

WebClientHandler_SwitchConversation_ResponseParams_Data::WebClientHandler_SwitchConversation_ResponseParams_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_RegisterConversation_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_RegisterConversation_Params_Data* object =
      static_cast<const WebClientHandler_RegisterConversation_Params_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->info, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->info, validation_context))
    return false;

  return true;
}

WebClientHandler_RegisterConversation_Params_Data::WebClientHandler_RegisterConversation_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_RegisterConversation_ResponseParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_RegisterConversation_ResponseParams_Data* object =
      static_cast<const WebClientHandler_RegisterConversation_ResponseParams_Data*>(data);


  if (!::glic::mojom::internal::RegisterConversationErrorReason_Data
        ::Validate(object->error_reason_$value, validation_context))
    return false;

  return true;
}

WebClientHandler_RegisterConversation_ResponseParams_Data::WebClientHandler_RegisterConversation_ResponseParams_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_SetOnboardingCompleted_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 8, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_SetOnboardingCompleted_Params_Data* object =
      static_cast<const WebClientHandler_SetOnboardingCompleted_Params_Data*>(data);

  return true;
}

WebClientHandler_SetOnboardingCompleted_Params_Data::WebClientHandler_SetOnboardingCompleted_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_SubscribeToTabData_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_SubscribeToTabData_Params_Data* object =
      static_cast<const WebClientHandler_SubscribeToTabData_Params_Data*>(data);

  if (!mojo::internal::ValidateHandleOrInterfaceNonNullable(
          object->receiver, 2, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateHandleOrInterface(object->receiver,
                                                 validation_context)) {
    return false;
  }

  return true;
}

WebClientHandler_SubscribeToTabData_Params_Data::WebClientHandler_SubscribeToTabData_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClientHandler_SubscribeToTabFavicon_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClientHandler_SubscribeToTabFavicon_Params_Data* object =
      static_cast<const WebClientHandler_SubscribeToTabFavicon_Params_Data*>(data);

  if (!mojo::internal::ValidateHandleOrInterfaceNonNullable(
          object->receiver, 2, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateHandleOrInterface(object->receiver,
                                                 validation_context)) {
    return false;
  }

  return true;
}

WebClientHandler_SubscribeToTabFavicon_Params_Data::WebClientHandler_SubscribeToTabFavicon_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ZeroStateSuggestionsHandler_GetZeroStateSuggestionsAndSubscribe_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ZeroStateSuggestionsHandler_GetZeroStateSuggestionsAndSubscribe_Params_Data* object =
      static_cast<const ZeroStateSuggestionsHandler_GetZeroStateSuggestionsAndSubscribe_Params_Data*>(data);

  if (!mojo::internal::ValidateHandleOrInterface(object->client,
                                                 validation_context)) {
    return false;
  }

  if (!mojo::internal::ValidatePointerNonNullable(
          object->options, 2, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->options, validation_context))
    return false;

  return true;
}

ZeroStateSuggestionsHandler_GetZeroStateSuggestionsAndSubscribe_Params_Data::ZeroStateSuggestionsHandler_GetZeroStateSuggestionsAndSubscribe_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ZeroStateSuggestionsHandler_GetZeroStateSuggestionsAndSubscribe_ResponseParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ZeroStateSuggestionsHandler_GetZeroStateSuggestionsAndSubscribe_ResponseParams_Data* object =
      static_cast<const ZeroStateSuggestionsHandler_GetZeroStateSuggestionsAndSubscribe_ResponseParams_Data*>(data);

  if (!mojo::internal::ValidateStruct(object->zero_state_suggestions, validation_context))
    return false;

  return true;
}

ZeroStateSuggestionsHandler_GetZeroStateSuggestionsAndSubscribe_ResponseParams_Data::ZeroStateSuggestionsHandler_GetZeroStateSuggestionsAndSubscribe_ResponseParams_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ZeroStateSuggestionsClient_NotifyZeroStateSuggestionsChanged_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ZeroStateSuggestionsClient_NotifyZeroStateSuggestionsChanged_Params_Data* object =
      static_cast<const ZeroStateSuggestionsClient_NotifyZeroStateSuggestionsChanged_Params_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->suggestions, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->suggestions, validation_context))
    return false;

  if (!mojo::internal::ValidatePointerNonNullable(
          object->options, 2, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->options, validation_context))
    return false;

  return true;
}

ZeroStateSuggestionsClient_NotifyZeroStateSuggestionsChanged_Params_Data::ZeroStateSuggestionsClient_NotifyZeroStateSuggestionsChanged_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool TabDataHandler_OnTabDataChanged_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const TabDataHandler_OnTabDataChanged_Params_Data* object =
      static_cast<const TabDataHandler_OnTabDataChanged_Params_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->tab_data, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->tab_data, validation_context))
    return false;

  return true;
}

TabDataHandler_OnTabDataChanged_Params_Data::TabDataHandler_OnTabDataChanged_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool TabFaviconHandler_OnTabFaviconChanged_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const TabFaviconHandler_OnTabFaviconChanged_Params_Data* object =
      static_cast<const TabFaviconHandler_OnTabFaviconChanged_Params_Data*>(data);

  if (!mojo::internal::ValidateStruct(object->favicon, validation_context))
    return false;

  return true;
}

TabFaviconHandler_OnTabFaviconChanged_Params_Data::TabFaviconHandler_OnTabFaviconChanged_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ExperimentalTriggeringUpdatesHandler_OnUpdate_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ExperimentalTriggeringUpdatesHandler_OnUpdate_Params_Data* object =
      static_cast<const ExperimentalTriggeringUpdatesHandler_OnUpdate_Params_Data*>(data);

  if (!mojo::internal::ValidateStruct(object->update, validation_context))
    return false;


  if (!::glic::mojom::internal::SubscriberObservationType_Data
        ::Validate(object->observation, validation_context))
    return false;

  return true;
}

ExperimentalTriggeringUpdatesHandler_OnUpdate_Params_Data::ExperimentalTriggeringUpdatesHandler_OnUpdate_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ExperimentalTriggeringClient_UploadEncryptedScreenshot_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ExperimentalTriggeringClient_UploadEncryptedScreenshot_Params_Data* object =
      static_cast<const ExperimentalTriggeringClient_UploadEncryptedScreenshot_Params_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->screenshot, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->screenshot, validation_context))
    return false;

  return true;
}

ExperimentalTriggeringClient_UploadEncryptedScreenshot_Params_Data::ExperimentalTriggeringClient_UploadEncryptedScreenshot_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ExperimentalTriggeringClient_UploadEncryptedScreenshot_ResponseParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ExperimentalTriggeringClient_UploadEncryptedScreenshot_ResponseParams_Data* object =
      static_cast<const ExperimentalTriggeringClient_UploadEncryptedScreenshot_ResponseParams_Data*>(data);

  constexpr const mojo::internal::ContainerValidateParams& file_token_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->file_token, validation_context,
                                         &file_token_validate_params)) {
    return false;
  }

  return true;
}

ExperimentalTriggeringClient_UploadEncryptedScreenshot_ResponseParams_Data::ExperimentalTriggeringClient_UploadEncryptedScreenshot_ResponseParams_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ExperimentalTriggeringClient_GetExperimentalTriggeringUpdates_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ExperimentalTriggeringClient_GetExperimentalTriggeringUpdates_Params_Data* object =
      static_cast<const ExperimentalTriggeringClient_GetExperimentalTriggeringUpdates_Params_Data*>(data);

  if (!mojo::internal::ValidateHandleOrInterfaceNonNullable(
          object->handler, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateHandleOrInterface(object->handler,
                                                 validation_context)) {
    return false;
  }

  return true;
}

ExperimentalTriggeringClient_GetExperimentalTriggeringUpdates_Params_Data::ExperimentalTriggeringClient_GetExperimentalTriggeringUpdates_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool ExperimentalTriggeringClient_GetExperimentalTriggeringUpdates_ResponseParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const ExperimentalTriggeringClient_GetExperimentalTriggeringUpdates_ResponseParams_Data* object =
      static_cast<const ExperimentalTriggeringClient_GetExperimentalTriggeringUpdates_ResponseParams_Data*>(data);

  return true;
}

ExperimentalTriggeringClient_GetExperimentalTriggeringUpdates_ResponseParams_Data::ExperimentalTriggeringClient_GetExperimentalTriggeringUpdates_ResponseParams_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClient_CheckResponsive_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 8, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClient_CheckResponsive_Params_Data* object =
      static_cast<const WebClient_CheckResponsive_Params_Data*>(data);

  return true;
}

WebClient_CheckResponsive_Params_Data::WebClient_CheckResponsive_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClient_CheckResponsive_ResponseParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 8, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClient_CheckResponsive_ResponseParams_Data* object =
      static_cast<const WebClient_CheckResponsive_ResponseParams_Data*>(data);

  return true;
}

WebClient_CheckResponsive_ResponseParams_Data::WebClient_CheckResponsive_ResponseParams_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClient_NotifyPanelWillOpen_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClient_NotifyPanelWillOpen_Params_Data* object =
      static_cast<const WebClient_NotifyPanelWillOpen_Params_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->panel_opening_data, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->panel_opening_data, validation_context))
    return false;

  return true;
}

WebClient_NotifyPanelWillOpen_Params_Data::WebClient_NotifyPanelWillOpen_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClient_NotifyPanelWillOpen_ResponseParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClient_NotifyPanelWillOpen_ResponseParams_Data* object =
      static_cast<const WebClient_NotifyPanelWillOpen_ResponseParams_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->openPanelInfo, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->openPanelInfo, validation_context))
    return false;

  return true;
}

WebClient_NotifyPanelWillOpen_ResponseParams_Data::WebClient_NotifyPanelWillOpen_ResponseParams_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClient_NotifyPanelWasClosed_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 8, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClient_NotifyPanelWasClosed_Params_Data* object =
      static_cast<const WebClient_NotifyPanelWasClosed_Params_Data*>(data);

  return true;
}

WebClient_NotifyPanelWasClosed_Params_Data::WebClient_NotifyPanelWasClosed_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClient_NotifyPanelWasClosed_ResponseParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 8, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClient_NotifyPanelWasClosed_ResponseParams_Data* object =
      static_cast<const WebClient_NotifyPanelWasClosed_ResponseParams_Data*>(data);

  return true;
}

WebClient_NotifyPanelWasClosed_ResponseParams_Data::WebClient_NotifyPanelWasClosed_ResponseParams_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClient_NotifyPanelStateChange_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClient_NotifyPanelStateChange_Params_Data* object =
      static_cast<const WebClient_NotifyPanelStateChange_Params_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->panel_state, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->panel_state, validation_context))
    return false;

  return true;
}

WebClient_NotifyPanelStateChange_Params_Data::WebClient_NotifyPanelStateChange_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClient_NotifyPanelActiveChange_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClient_NotifyPanelActiveChange_Params_Data* object =
      static_cast<const WebClient_NotifyPanelActiveChange_Params_Data*>(data);

  return true;
}

WebClient_NotifyPanelActiveChange_Params_Data::WebClient_NotifyPanelActiveChange_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClient_NotifyPanelCanAttachChange_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClient_NotifyPanelCanAttachChange_Params_Data* object =
      static_cast<const WebClient_NotifyPanelCanAttachChange_Params_Data*>(data);

  return true;
}

WebClient_NotifyPanelCanAttachChange_Params_Data::WebClient_NotifyPanelCanAttachChange_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClient_NotifyMicrophonePermissionStateChanged_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClient_NotifyMicrophonePermissionStateChanged_Params_Data* object =
      static_cast<const WebClient_NotifyMicrophonePermissionStateChanged_Params_Data*>(data);

  return true;
}

WebClient_NotifyMicrophonePermissionStateChanged_Params_Data::WebClient_NotifyMicrophonePermissionStateChanged_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClient_NotifyFileUploadStateChanged_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClient_NotifyFileUploadStateChanged_Params_Data* object =
      static_cast<const WebClient_NotifyFileUploadStateChanged_Params_Data*>(data);


  if (!::glic::mojom::internal::FileUploadPolicyState_Data
        ::Validate(object->state, validation_context))
    return false;

  return true;
}

WebClient_NotifyFileUploadStateChanged_Params_Data::WebClient_NotifyFileUploadStateChanged_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClient_StopMicrophone_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 8, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClient_StopMicrophone_Params_Data* object =
      static_cast<const WebClient_StopMicrophone_Params_Data*>(data);

  return true;
}

WebClient_StopMicrophone_Params_Data::WebClient_StopMicrophone_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClient_StopMicrophone_ResponseParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 8, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClient_StopMicrophone_ResponseParams_Data* object =
      static_cast<const WebClient_StopMicrophone_ResponseParams_Data*>(data);

  return true;
}

WebClient_StopMicrophone_ResponseParams_Data::WebClient_StopMicrophone_ResponseParams_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClient_NotifyLocationPermissionStateChanged_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClient_NotifyLocationPermissionStateChanged_Params_Data* object =
      static_cast<const WebClient_NotifyLocationPermissionStateChanged_Params_Data*>(data);

  return true;
}

WebClient_NotifyLocationPermissionStateChanged_Params_Data::WebClient_NotifyLocationPermissionStateChanged_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClient_NotifyTabContextPermissionStateChanged_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClient_NotifyTabContextPermissionStateChanged_Params_Data* object =
      static_cast<const WebClient_NotifyTabContextPermissionStateChanged_Params_Data*>(data);

  return true;
}

WebClient_NotifyTabContextPermissionStateChanged_Params_Data::WebClient_NotifyTabContextPermissionStateChanged_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClient_NotifyOsLocationPermissionStateChanged_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClient_NotifyOsLocationPermissionStateChanged_Params_Data* object =
      static_cast<const WebClient_NotifyOsLocationPermissionStateChanged_Params_Data*>(data);

  return true;
}

WebClient_NotifyOsLocationPermissionStateChanged_Params_Data::WebClient_NotifyOsLocationPermissionStateChanged_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClient_NotifyFocusedTabChanged_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClient_NotifyFocusedTabChanged_Params_Data* object =
      static_cast<const WebClient_NotifyFocusedTabChanged_Params_Data*>(data);

  if (!mojo::internal::ValidateInlinedUnionNonNullable(
          object->focused_tab_data, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateInlinedUnion(object->focused_tab_data, validation_context))
    return false;

  return true;
}

WebClient_NotifyFocusedTabChanged_Params_Data::WebClient_NotifyFocusedTabChanged_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClient_NotifyManualResizeChanged_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClient_NotifyManualResizeChanged_Params_Data* object =
      static_cast<const WebClient_NotifyManualResizeChanged_Params_Data*>(data);

  return true;
}

WebClient_NotifyManualResizeChanged_Params_Data::WebClient_NotifyManualResizeChanged_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClient_NotifyOsHotkeyStateChanged_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClient_NotifyOsHotkeyStateChanged_Params_Data* object =
      static_cast<const WebClient_NotifyOsHotkeyStateChanged_Params_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->hotkey, 1, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& hotkey_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->hotkey, validation_context,
                                         &hotkey_validate_params)) {
    return false;
  }

  return true;
}

WebClient_NotifyOsHotkeyStateChanged_Params_Data::WebClient_NotifyOsHotkeyStateChanged_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClient_NotifyBrowserIsOpenChanged_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClient_NotifyBrowserIsOpenChanged_Params_Data* object =
      static_cast<const WebClient_NotifyBrowserIsOpenChanged_Params_Data*>(data);

  return true;
}

WebClient_NotifyBrowserIsOpenChanged_Params_Data::WebClient_NotifyBrowserIsOpenChanged_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClient_NotifyZoomLevelChanged_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClient_NotifyZoomLevelChanged_Params_Data* object =
      static_cast<const WebClient_NotifyZoomLevelChanged_Params_Data*>(data);

  return true;
}

WebClient_NotifyZoomLevelChanged_Params_Data::WebClient_NotifyZoomLevelChanged_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClient_NotifyInstanceActivationChanged_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClient_NotifyInstanceActivationChanged_Params_Data* object =
      static_cast<const WebClient_NotifyInstanceActivationChanged_Params_Data*>(data);

  return true;
}

WebClient_NotifyInstanceActivationChanged_Params_Data::WebClient_NotifyInstanceActivationChanged_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClient_NotifyClosedCaptioningSettingChanged_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClient_NotifyClosedCaptioningSettingChanged_Params_Data* object =
      static_cast<const WebClient_NotifyClosedCaptioningSettingChanged_Params_Data*>(data);

  return true;
}

WebClient_NotifyClosedCaptioningSettingChanged_Params_Data::WebClient_NotifyClosedCaptioningSettingChanged_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClient_NotifyPinnedTabsChanged_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClient_NotifyPinnedTabsChanged_Params_Data* object =
      static_cast<const WebClient_NotifyPinnedTabsChanged_Params_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->tab_data, 1, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& tab_data_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->tab_data, validation_context,
                                         &tab_data_validate_params)) {
    return false;
  }

  return true;
}

WebClient_NotifyPinnedTabsChanged_Params_Data::WebClient_NotifyPinnedTabsChanged_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClient_NotifyPinnedTabDataChanged_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClient_NotifyPinnedTabDataChanged_Params_Data* object =
      static_cast<const WebClient_NotifyPinnedTabDataChanged_Params_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->tab_data, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->tab_data, validation_context))
    return false;

  return true;
}

WebClient_NotifyPinnedTabDataChanged_Params_Data::WebClient_NotifyPinnedTabDataChanged_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClient_NotifyPageMetadataChanged_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClient_NotifyPageMetadataChanged_Params_Data* object =
      static_cast<const WebClient_NotifyPageMetadataChanged_Params_Data*>(data);

  if (!mojo::internal::ValidateStruct(object->metadata, validation_context))
    return false;

  return true;
}

WebClient_NotifyPageMetadataChanged_Params_Data::WebClient_NotifyPageMetadataChanged_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClient_NotifyDefaultTabContextPermissionStateChanged_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClient_NotifyDefaultTabContextPermissionStateChanged_Params_Data* object =
      static_cast<const WebClient_NotifyDefaultTabContextPermissionStateChanged_Params_Data*>(data);

  return true;
}

WebClient_NotifyDefaultTabContextPermissionStateChanged_Params_Data::WebClient_NotifyDefaultTabContextPermissionStateChanged_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClient_NotifyAdditionalContext_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClient_NotifyAdditionalContext_Params_Data* object =
      static_cast<const WebClient_NotifyAdditionalContext_Params_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->context, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->context, validation_context))
    return false;

  return true;
}

WebClient_NotifyAdditionalContext_Params_Data::WebClient_NotifyAdditionalContext_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClient_NotifyActuationOnWebSettingChanged_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClient_NotifyActuationOnWebSettingChanged_Params_Data* object =
      static_cast<const WebClient_NotifyActuationOnWebSettingChanged_Params_Data*>(data);

  return true;
}

WebClient_NotifyActuationOnWebSettingChanged_Params_Data::WebClient_NotifyActuationOnWebSettingChanged_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClient_NotifyActOnWebCapabilityChanged_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClient_NotifyActOnWebCapabilityChanged_Params_Data* object =
      static_cast<const WebClient_NotifyActOnWebCapabilityChanged_Params_Data*>(data);

  return true;
}

WebClient_NotifyActOnWebCapabilityChanged_Params_Data::WebClient_NotifyActOnWebCapabilityChanged_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClient_NotifyOnboardingCompletedChanged_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClient_NotifyOnboardingCompletedChanged_Params_Data* object =
      static_cast<const WebClient_NotifyOnboardingCompletedChanged_Params_Data*>(data);

  return true;
}

WebClient_NotifyOnboardingCompletedChanged_Params_Data::WebClient_NotifyOnboardingCompletedChanged_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClient_NotifyGeminiEnterpriseSettingsChanged_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClient_NotifyGeminiEnterpriseSettingsChanged_Params_Data* object =
      static_cast<const WebClient_NotifyGeminiEnterpriseSettingsChanged_Params_Data*>(data);

  if (!mojo::internal::ValidateStruct(object->settings, validation_context))
    return false;

  return true;
}

WebClient_NotifyGeminiEnterpriseSettingsChanged_Params_Data::WebClient_NotifyGeminiEnterpriseSettingsChanged_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClient_NotifyActorTaskListRowClicked_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClient_NotifyActorTaskListRowClicked_Params_Data* object =
      static_cast<const WebClient_NotifyActorTaskListRowClicked_Params_Data*>(data);

  return true;
}

WebClient_NotifyActorTaskListRowClicked_Params_Data::WebClient_NotifyActorTaskListRowClicked_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClient_Invoke_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClient_Invoke_Params_Data* object =
      static_cast<const WebClient_Invoke_Params_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->options, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->options, validation_context))
    return false;

  return true;
}

WebClient_Invoke_Params_Data::WebClient_Invoke_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool WebClient_Invoke_ResponseParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 8, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const WebClient_Invoke_ResponseParams_Data* object =
      static_cast<const WebClient_Invoke_ResponseParams_Data*>(data);

  return true;
}

WebClient_Invoke_ResponseParams_Data::WebClient_Invoke_ResponseParams_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool CaptureRegionObserver_OnUpdate_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const CaptureRegionObserver_OnUpdate_Params_Data* object =
      static_cast<const CaptureRegionObserver_OnUpdate_Params_Data*>(data);

  if (!mojo::internal::ValidateStruct(object->result, validation_context))
    return false;


  if (!::glic::mojom::internal::CaptureRegionErrorReason_Data
        ::Validate(object->reason_$value, validation_context))
    return false;

  return true;
}

CaptureRegionObserver_OnUpdate_Params_Data::CaptureRegionObserver_OnUpdate_Params_Data()
    : header_({sizeof(*this), 0}) {}

}  // namespace internal
}  // namespace mojom
}  // namespace glic

namespace perfetto {

// static
void TraceFormatTraits<::glic::mojom::GlicExperimentalTriggeringState>::WriteIntoTrace(
   perfetto::TracedValue context, ::glic::mojom::GlicExperimentalTriggeringState value) {
  return std::move(context).WriteString(::glic::mojom::GlicExperimentalTriggeringStateToString(value));
}

} // namespace perfetto

namespace perfetto {

// static
void TraceFormatTraits<::glic::mojom::FileUploadPolicyState>::WriteIntoTrace(
   perfetto::TracedValue context, ::glic::mojom::FileUploadPolicyState value) {
  return std::move(context).WriteString(::glic::mojom::FileUploadPolicyStateToString(value));
}

} // namespace perfetto

namespace perfetto {

// static
void TraceFormatTraits<::glic::mojom::ActuationEligibility>::WriteIntoTrace(
   perfetto::TracedValue context, ::glic::mojom::ActuationEligibility value) {
  return std::move(context).WriteString(::glic::mojom::ActuationEligibilityToString(value));
}

} // namespace perfetto

namespace perfetto {

// static
void TraceFormatTraits<::glic::mojom::MetricUserInputReactionType>::WriteIntoTrace(
   perfetto::TracedValue context, ::glic::mojom::MetricUserInputReactionType value) {
  return std::move(context).WriteString(::glic::mojom::MetricUserInputReactionTypeToString(value));
}

} // namespace perfetto

namespace perfetto {

// static
void TraceFormatTraits<::glic::mojom::PerformActionsErrorReason>::WriteIntoTrace(
   perfetto::TracedValue context, ::glic::mojom::PerformActionsErrorReason value) {
  return std::move(context).WriteString(::glic::mojom::PerformActionsErrorReasonToString(value));
}

} // namespace perfetto

namespace perfetto {

// static
void TraceFormatTraits<::glic::mojom::CreateTaskErrorReason>::WriteIntoTrace(
   perfetto::TracedValue context, ::glic::mojom::CreateTaskErrorReason value) {
  return std::move(context).WriteString(::glic::mojom::CreateTaskErrorReasonToString(value));
}

} // namespace perfetto

namespace perfetto {

// static
void TraceFormatTraits<::glic::mojom::ActorTaskState>::WriteIntoTrace(
   perfetto::TracedValue context, ::glic::mojom::ActorTaskState value) {
  return std::move(context).WriteString(::glic::mojom::ActorTaskStateToString(value));
}

} // namespace perfetto

namespace perfetto {

// static
void TraceFormatTraits<::glic::mojom::ActorTaskPauseReason>::WriteIntoTrace(
   perfetto::TracedValue context, ::glic::mojom::ActorTaskPauseReason value) {
  return std::move(context).WriteString(::glic::mojom::ActorTaskPauseReasonToString(value));
}

} // namespace perfetto

namespace perfetto {

// static
void TraceFormatTraits<::glic::mojom::ActorTaskStopReason>::WriteIntoTrace(
   perfetto::TracedValue context, ::glic::mojom::ActorTaskStopReason value) {
  return std::move(context).WriteString(::glic::mojom::ActorTaskStopReasonToString(value));
}

} // namespace perfetto

namespace perfetto {

// static
void TraceFormatTraits<::glic::mojom::ActorTaskInterruptReason>::WriteIntoTrace(
   perfetto::TracedValue context, ::glic::mojom::ActorTaskInterruptReason value) {
  return std::move(context).WriteString(::glic::mojom::ActorTaskInterruptReasonToString(value));
}

} // namespace perfetto

namespace perfetto {

// static
void TraceFormatTraits<::glic::mojom::CaptureScreenshotErrorReason>::WriteIntoTrace(
   perfetto::TracedValue context, ::glic::mojom::CaptureScreenshotErrorReason value) {
  return std::move(context).WriteString(::glic::mojom::CaptureScreenshotErrorReasonToString(value));
}

} // namespace perfetto

namespace perfetto {

// static
void TraceFormatTraits<::glic::mojom::SbThreatType>::WriteIntoTrace(
   perfetto::TracedValue context, ::glic::mojom::SbThreatType value) {
  return std::move(context).WriteString(::glic::mojom::SbThreatTypeToString(value));
}

} // namespace perfetto

namespace perfetto {

// static
void TraceFormatTraits<::glic::mojom::Platform>::WriteIntoTrace(
   perfetto::TracedValue context, ::glic::mojom::Platform value) {
  return std::move(context).WriteString(::glic::mojom::PlatformToString(value));
}

} // namespace perfetto

namespace perfetto {

// static
void TraceFormatTraits<::glic::mojom::FormFactor>::WriteIntoTrace(
   perfetto::TracedValue context, ::glic::mojom::FormFactor value) {
  return std::move(context).WriteString(::glic::mojom::FormFactorToString(value));
}

} // namespace perfetto

namespace perfetto {

// static
void TraceFormatTraits<::glic::mojom::ScreenshotImageFormat>::WriteIntoTrace(
   perfetto::TracedValue context, ::glic::mojom::ScreenshotImageFormat value) {
  return std::move(context).WriteString(::glic::mojom::ScreenshotImageFormatToString(value));
}

} // namespace perfetto

namespace perfetto {

// static
void TraceFormatTraits<::glic::mojom::ScreenshotCompressionQuality>::WriteIntoTrace(
   perfetto::TracedValue context, ::glic::mojom::ScreenshotCompressionQuality value) {
  return std::move(context).WriteString(::glic::mojom::ScreenshotCompressionQualityToString(value));
}

} // namespace perfetto

namespace perfetto {

// static
void TraceFormatTraits<::glic::mojom::ScrollToErrorReason>::WriteIntoTrace(
   perfetto::TracedValue context, ::glic::mojom::ScrollToErrorReason value) {
  return std::move(context).WriteString(::glic::mojom::ScrollToErrorReasonToString(value));
}

} // namespace perfetto

namespace perfetto {

// static
void TraceFormatTraits<::glic::mojom::SkillSource>::WriteIntoTrace(
   perfetto::TracedValue context, ::glic::mojom::SkillSource value) {
  return std::move(context).WriteString(::glic::mojom::SkillSourceToString(value));
}

} // namespace perfetto

namespace perfetto {

// static
void TraceFormatTraits<::glic::mojom::SkillsWebClientEvent>::WriteIntoTrace(
   perfetto::TracedValue context, ::glic::mojom::SkillsWebClientEvent value) {
  return std::move(context).WriteString(::glic::mojom::SkillsWebClientEventToString(value));
}

} // namespace perfetto

namespace perfetto {

// static
void TraceFormatTraits<::glic::mojom::PinTrigger>::WriteIntoTrace(
   perfetto::TracedValue context, ::glic::mojom::PinTrigger value) {
  return std::move(context).WriteString(::glic::mojom::PinTriggerToString(value));
}

} // namespace perfetto

namespace perfetto {

// static
void TraceFormatTraits<::glic::mojom::UnpinTrigger>::WriteIntoTrace(
   perfetto::TracedValue context, ::glic::mojom::UnpinTrigger value) {
  return std::move(context).WriteString(::glic::mojom::UnpinTriggerToString(value));
}

} // namespace perfetto

namespace perfetto {

// static
void TraceFormatTraits<::glic::mojom::CancelActionsResult>::WriteIntoTrace(
   perfetto::TracedValue context, ::glic::mojom::CancelActionsResult value) {
  return std::move(context).WriteString(::glic::mojom::CancelActionsResultToString(value));
}

} // namespace perfetto

namespace perfetto {

// static
void TraceFormatTraits<::glic::mojom::SwitchConversationErrorReason>::WriteIntoTrace(
   perfetto::TracedValue context, ::glic::mojom::SwitchConversationErrorReason value) {
  return std::move(context).WriteString(::glic::mojom::SwitchConversationErrorReasonToString(value));
}

} // namespace perfetto

namespace perfetto {

// static
void TraceFormatTraits<::glic::mojom::RegisterConversationErrorReason>::WriteIntoTrace(
   perfetto::TracedValue context, ::glic::mojom::RegisterConversationErrorReason value) {
  return std::move(context).WriteString(::glic::mojom::RegisterConversationErrorReasonToString(value));
}

} // namespace perfetto

namespace perfetto {

// static
void TraceFormatTraits<::glic::mojom::PanelStateKind>::WriteIntoTrace(
   perfetto::TracedValue context, ::glic::mojom::PanelStateKind value) {
  return std::move(context).WriteString(::glic::mojom::PanelStateKindToString(value));
}

} // namespace perfetto

namespace perfetto {

// static
void TraceFormatTraits<::glic::mojom::FreOverride>::WriteIntoTrace(
   perfetto::TracedValue context, ::glic::mojom::FreOverride value) {
  return std::move(context).WriteString(::glic::mojom::FreOverrideToString(value));
}

} // namespace perfetto

namespace perfetto {

// static
void TraceFormatTraits<::glic::mojom::InvocationSource>::WriteIntoTrace(
   perfetto::TracedValue context, ::glic::mojom::InvocationSource value) {
  return std::move(context).WriteString(::glic::mojom::InvocationSourceToString(value));
}

} // namespace perfetto

namespace perfetto {

// static
void TraceFormatTraits<::glic::mojom::ActuationTarget>::WriteIntoTrace(
   perfetto::TracedValue context, ::glic::mojom::ActuationTarget value) {
  return std::move(context).WriteString(::glic::mojom::ActuationTargetToString(value));
}

} // namespace perfetto

namespace perfetto {

// static
void TraceFormatTraits<::glic::mojom::WebClientMode>::WriteIntoTrace(
   perfetto::TracedValue context, ::glic::mojom::WebClientMode value) {
  return std::move(context).WriteString(::glic::mojom::WebClientModeToString(value));
}

} // namespace perfetto

namespace perfetto {

// static
void TraceFormatTraits<::glic::mojom::PromptType>::WriteIntoTrace(
   perfetto::TracedValue context, ::glic::mojom::PromptType value) {
  return std::move(context).WriteString(::glic::mojom::PromptTypeToString(value));
}

} // namespace perfetto

namespace perfetto {

// static
void TraceFormatTraits<::glic::mojom::MicrophoneStatus>::WriteIntoTrace(
   perfetto::TracedValue context, ::glic::mojom::MicrophoneStatus value) {
  return std::move(context).WriteString(::glic::mojom::MicrophoneStatusToString(value));
}

} // namespace perfetto

namespace perfetto {

// static
void TraceFormatTraits<::glic::mojom::WebClientModel>::WriteIntoTrace(
   perfetto::TracedValue context, ::glic::mojom::WebClientModel value) {
  return std::move(context).WriteString(::glic::mojom::WebClientModelToString(value));
}

} // namespace perfetto

namespace perfetto {

// static
void TraceFormatTraits<::glic::mojom::WebUseCounter>::WriteIntoTrace(
   perfetto::TracedValue context, ::glic::mojom::WebUseCounter value) {
  return std::move(context).WriteString(::glic::mojom::WebUseCounterToString(value));
}

} // namespace perfetto

namespace perfetto {

// static
void TraceFormatTraits<::glic::mojom::ClientErrorDialogType>::WriteIntoTrace(
   perfetto::TracedValue context, ::glic::mojom::ClientErrorDialogType value) {
  return std::move(context).WriteString(::glic::mojom::ClientErrorDialogTypeToString(value));
}

} // namespace perfetto

namespace perfetto {

// static
void TraceFormatTraits<::glic::mojom::ResponseStopCause>::WriteIntoTrace(
   perfetto::TracedValue context, ::glic::mojom::ResponseStopCause value) {
  return std::move(context).WriteString(::glic::mojom::ResponseStopCauseToString(value));
}

} // namespace perfetto

namespace perfetto {

// static
void TraceFormatTraits<::glic::mojom::AdditionalContextSource>::WriteIntoTrace(
   perfetto::TracedValue context, ::glic::mojom::AdditionalContextSource value) {
  return std::move(context).WriteString(::glic::mojom::AdditionalContextSourceToString(value));
}

} // namespace perfetto

namespace perfetto {

// static
void TraceFormatTraits<::glic::mojom::ExperimentalTriggeringUpdateType>::WriteIntoTrace(
   perfetto::TracedValue context, ::glic::mojom::ExperimentalTriggeringUpdateType value) {
  return std::move(context).WriteString(::glic::mojom::ExperimentalTriggeringUpdateTypeToString(value));
}

} // namespace perfetto

namespace perfetto {

// static
void TraceFormatTraits<::glic::mojom::SubscriberObservationType>::WriteIntoTrace(
   perfetto::TracedValue context, ::glic::mojom::SubscriberObservationType value) {
  return std::move(context).WriteString(::glic::mojom::SubscriberObservationTypeToString(value));
}

} // namespace perfetto

namespace perfetto {

// static
void TraceFormatTraits<::glic::mojom::LightweightPageFeature>::WriteIntoTrace(
   perfetto::TracedValue context, ::glic::mojom::LightweightPageFeature value) {
  return std::move(context).WriteString(::glic::mojom::LightweightPageFeatureToString(value));
}

} // namespace perfetto

namespace perfetto {

// static
void TraceFormatTraits<::glic::mojom::CaptureRegionErrorReason>::WriteIntoTrace(
   perfetto::TracedValue context, ::glic::mojom::CaptureRegionErrorReason value) {
  return std::move(context).WriteString(::glic::mojom::CaptureRegionErrorReasonToString(value));
}

} // namespace perfetto

namespace perfetto {

// static
void TraceFormatTraits<::glic::mojom::ScreenshotEncryptionScheme>::WriteIntoTrace(
   perfetto::TracedValue context, ::glic::mojom::ScreenshotEncryptionScheme value) {
  return std::move(context).WriteString(::glic::mojom::ScreenshotEncryptionSchemeToString(value));
}

} // namespace perfetto

namespace perfetto {

// static
void TraceFormatTraits<::glic::mojom::SettingsPageField>::WriteIntoTrace(
   perfetto::TracedValue context, ::glic::mojom::SettingsPageField value) {
  return std::move(context).WriteString(::glic::mojom::SettingsPageFieldToString(value));
}

} // namespace perfetto

namespace perfetto {

// static
void TraceFormatTraits<::glic::mojom::HostCapability>::WriteIntoTrace(
   perfetto::TracedValue context, ::glic::mojom::HostCapability value) {
  return std::move(context).WriteString(::glic::mojom::HostCapabilityToString(value));
}

} // namespace perfetto

namespace perfetto {

// static
void TraceFormatTraits<::glic::mojom::ClientCapabilities>::WriteIntoTrace(
   perfetto::TracedValue context, ::glic::mojom::ClientCapabilities value) {
  return std::move(context).WriteString(::glic::mojom::ClientCapabilitiesToString(value));
}

} // namespace perfetto