// chrome/browser/ui/webui/context_hub/context_hub.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/ui/webui/context_hub/context_hub.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/ui/webui/context_hub/context_hub.mojom-params-data.h"
#include "chrome/browser/ui/webui/context_hub/context_hub.mojom-features.h"
namespace browser {
namespace context_hub {
namespace mojom {

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

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

std::ostream& operator<<(std::ostream& os, AutoTodoStatus value) {
  return os << AutoTodoStatusToString(value);
}

NOINLINE static const char* AutoTodoGroupToStringHelper(AutoTodoGroup value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case AutoTodoGroup::kNoMatch:
      return "kNoMatch";
    case AutoTodoGroup::kNudgeToClose:
      return "kNudgeToClose";
    case AutoTodoGroup::kReadingList:
      return "kReadingList";
    case AutoTodoGroup::kUnfinishedAction:
      return "kUnfinishedAction";
    default:
      return nullptr;
  }
}

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

std::ostream& operator<<(std::ostream& os, AutoTodoGroup value) {
  return os << AutoTodoGroupToString(value);
}

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

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

std::ostream& operator<<(std::ostream& os, EntryType value) {
  return os << EntryTypeToString(value);
}

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

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

std::ostream& operator<<(std::ostream& os, ChatRole value) {
  return os << ChatRoleToString(value);
}

namespace internal {
// static
bool SourceReference_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 SourceReference_Data* object = static_cast<const SourceReference_Data*>(data);

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

  switch (object->tag) {

    case SourceReference_Tag::kGmail: {

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

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

      ReportValidationError(
          validation_context,
          mojo::internal::VALIDATION_ERROR_UNKNOWN_UNION_TAG,
          "unknown tag in SourceReference");
      return false;
    }
  }
}
// static
bool AutoTodoData_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 AutoTodoData_Data* object = static_cast<const AutoTodoData_Data*>(data);

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

  switch (object->tag) {

    case AutoTodoData_Tag::kFirstParty: {

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

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

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


// static
bool GmailReference_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 GmailReference_Data* object =
      static_cast<const GmailReference_Data*>(data);

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

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

  return true;
}

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


// static
bool PhotosReference_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 PhotosReference_Data* object =
      static_cast<const PhotosReference_Data*>(data);

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

  return true;
}

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


// static
bool FirstPartyData_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 FirstPartyData_Data* object =
      static_cast<const FirstPartyData_Data*>(data);

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

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

  return true;
}

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


// static
bool ThirdPartyData_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 ThirdPartyData_Data* object =
      static_cast<const ThirdPartyData_Data*>(data);

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


  if (!::browser::context_hub::mojom::internal::AutoTodoGroup_Data
        ::Validate(object->group_type, validation_context))
    return false;

  return true;
}

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


// static
bool AutoTodoItem_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 AutoTodoItem_Data* object =
      static_cast<const AutoTodoItem_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->title, 2, 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::ValidatePointerNonNullable(
          object->description, 3, 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;
  }


  if (!::browser::context_hub::mojom::internal::AutoTodoStatus_Data
        ::Validate(object->status, validation_context))
    return false;

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

  return true;
}

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


// static
bool MemoryBankEntry_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 MemoryBankEntry_Data* object =
      static_cast<const MemoryBankEntry_Data*>(data);


  if (!::browser::context_hub::mojom::internal::EntryType_Data
        ::Validate(object->type, validation_context))
    return false;

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

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

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

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

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

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

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

  return true;
}

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


// static
bool TabInfo_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 TabInfo_Data* object =
      static_cast<const TabInfo_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->title, 2, 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::ValidatePointerNonNullable(
          object->url, 3, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->url, validation_context))
    return false;

  return true;
}

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


// static
bool TabGroup_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 TabGroup_Data* object =
      static_cast<const TabGroup_Data*>(data);

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

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

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

  return true;
}

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


// static
bool ChatMessage_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 ChatMessage_Data* object =
      static_cast<const ChatMessage_Data*>(data);


  if (!::browser::context_hub::mojom::internal::ChatRole_Data
        ::Validate(object->role, validation_context))
    return false;

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

  return true;
}

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


// static
bool SaveToMemoryBankContext_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 SaveToMemoryBankContext_Data* object =
      static_cast<const SaveToMemoryBankContext_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->tab_title, 2, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& tab_title_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->tab_title, validation_context,
                                         &tab_title_validate_params)) {
    return false;
  }

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

  return true;
}

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


// static
bool MemoryBankEntryAnnotations_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 MemoryBankEntryAnnotations_Data* object =
      static_cast<const MemoryBankEntryAnnotations_Data*>(data);

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

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

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

  return true;
}

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


// static
bool AutoTodoItemFeedback_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 AutoTodoItemFeedback_Data* object =
      static_cast<const AutoTodoItemFeedback_Data*>(data);

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

  return true;
}

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


// static
bool Page_OnAutoTodosChanged_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 Page_OnAutoTodosChanged_Params_Data* object =
      static_cast<const Page_OnAutoTodosChanged_Params_Data*>(data);

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

  return true;
}

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


// static
bool Page_OnFirstPartyAutoTodosGenerationStateChanged_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 Page_OnFirstPartyAutoTodosGenerationStateChanged_Params_Data* object =
      static_cast<const Page_OnFirstPartyAutoTodosGenerationStateChanged_Params_Data*>(data);

  return true;
}

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


// static
bool Page_OnThirdPartyAutoTodosGenerationStateChanged_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 Page_OnThirdPartyAutoTodosGenerationStateChanged_Params_Data* object =
      static_cast<const Page_OnThirdPartyAutoTodosGenerationStateChanged_Params_Data*>(data);

  return true;
}

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


// static
bool PageHandlerFactory_CreatePageHandler_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 PageHandlerFactory_CreatePageHandler_Params_Data* object =
      static_cast<const PageHandlerFactory_CreatePageHandler_Params_Data*>(data);

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

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

  return true;
}

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


// static
bool PageHandler_GenerateFirstPartyAutoTodos_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 PageHandler_GenerateFirstPartyAutoTodos_Params_Data* object =
      static_cast<const PageHandler_GenerateFirstPartyAutoTodos_Params_Data*>(data);

  return true;
}

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


// static
bool PageHandler_GenerateFirstPartyAutoTodos_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 PageHandler_GenerateFirstPartyAutoTodos_ResponseParams_Data* object =
      static_cast<const PageHandler_GenerateFirstPartyAutoTodos_ResponseParams_Data*>(data);

  return true;
}

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


// static
bool PageHandler_GetAutoTodos_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 PageHandler_GetAutoTodos_Params_Data* object =
      static_cast<const PageHandler_GetAutoTodos_Params_Data*>(data);

  return true;
}

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


// static
bool PageHandler_GetAutoTodos_ResponseParams_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 PageHandler_GetAutoTodos_ResponseParams_Data* object =
      static_cast<const PageHandler_GetAutoTodos_ResponseParams_Data*>(data);

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

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

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

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

  return true;
}

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


// static
bool PageHandler_UpdateAutoTodo_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 PageHandler_UpdateAutoTodo_Params_Data* object =
      static_cast<const PageHandler_UpdateAutoTodo_Params_Data*>(data);

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

  return true;
}

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


// static
bool PageHandler_UpdateAutoTodo_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 PageHandler_UpdateAutoTodo_ResponseParams_Data* object =
      static_cast<const PageHandler_UpdateAutoTodo_ResponseParams_Data*>(data);

  return true;
}

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


// static
bool PageHandler_GenerateTabBasedTodos_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 PageHandler_GenerateTabBasedTodos_Params_Data* object =
      static_cast<const PageHandler_GenerateTabBasedTodos_Params_Data*>(data);

  return true;
}

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


// static
bool PageHandler_GenerateTabBasedTodos_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 PageHandler_GenerateTabBasedTodos_ResponseParams_Data* object =
      static_cast<const PageHandler_GenerateTabBasedTodos_ResponseParams_Data*>(data);

  return true;
}

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


// static
bool PageHandler_SetTodoFeedback_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 PageHandler_SetTodoFeedback_Params_Data* object =
      static_cast<const PageHandler_SetTodoFeedback_Params_Data*>(data);

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

  return true;
}

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


// static
bool PageHandler_SetTodoFeedback_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 PageHandler_SetTodoFeedback_ResponseParams_Data* object =
      static_cast<const PageHandler_SetTodoFeedback_ResponseParams_Data*>(data);

  return true;
}

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


// static
bool PageHandler_DeleteTodoFeedback_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 PageHandler_DeleteTodoFeedback_Params_Data* object =
      static_cast<const PageHandler_DeleteTodoFeedback_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;
}

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


// static
bool PageHandler_DeleteTodoFeedback_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 PageHandler_DeleteTodoFeedback_ResponseParams_Data* object =
      static_cast<const PageHandler_DeleteTodoFeedback_ResponseParams_Data*>(data);

  return true;
}

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


// static
bool PageHandler_ClearTodoFeedbacks_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 PageHandler_ClearTodoFeedbacks_Params_Data* object =
      static_cast<const PageHandler_ClearTodoFeedbacks_Params_Data*>(data);

  return true;
}

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


// static
bool PageHandler_ClearTodoFeedbacks_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 PageHandler_ClearTodoFeedbacks_ResponseParams_Data* object =
      static_cast<const PageHandler_ClearTodoFeedbacks_ResponseParams_Data*>(data);

  return true;
}

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


// static
bool PageHandler_GetTodoFeedbacks_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 PageHandler_GetTodoFeedbacks_Params_Data* object =
      static_cast<const PageHandler_GetTodoFeedbacks_Params_Data*>(data);

  return true;
}

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


// static
bool PageHandler_GetTodoFeedbacks_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 PageHandler_GetTodoFeedbacks_ResponseParams_Data* object =
      static_cast<const PageHandler_GetTodoFeedbacks_ResponseParams_Data*>(data);

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

  return true;
}

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


// static
bool PageHandler_GetSaveToMemoryBankContext_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 PageHandler_GetSaveToMemoryBankContext_Params_Data* object =
      static_cast<const PageHandler_GetSaveToMemoryBankContext_Params_Data*>(data);

  return true;
}

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


// static
bool PageHandler_GetSaveToMemoryBankContext_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 PageHandler_GetSaveToMemoryBankContext_ResponseParams_Data* object =
      static_cast<const PageHandler_GetSaveToMemoryBankContext_ResponseParams_Data*>(data);

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

  return true;
}

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


// static
bool PageHandler_GetAllMemoryBankEntries_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 PageHandler_GetAllMemoryBankEntries_Params_Data* object =
      static_cast<const PageHandler_GetAllMemoryBankEntries_Params_Data*>(data);

  return true;
}

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


// static
bool PageHandler_GetAllMemoryBankEntries_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 PageHandler_GetAllMemoryBankEntries_ResponseParams_Data* object =
      static_cast<const PageHandler_GetAllMemoryBankEntries_ResponseParams_Data*>(data);

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

  return true;
}

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


// static
bool PageHandler_DeleteMemoryBankEntries_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 PageHandler_DeleteMemoryBankEntries_Params_Data* object =
      static_cast<const PageHandler_DeleteMemoryBankEntries_Params_Data*>(data);

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

  return true;
}

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


// static
bool PageHandler_DeleteMemoryBankEntries_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 PageHandler_DeleteMemoryBankEntries_ResponseParams_Data* object =
      static_cast<const PageHandler_DeleteMemoryBankEntries_ResponseParams_Data*>(data);

  return true;
}

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


// static
bool PageHandler_SaveMemoryBankEntry_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 PageHandler_SaveMemoryBankEntry_Params_Data* object =
      static_cast<const PageHandler_SaveMemoryBankEntry_Params_Data*>(data);

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

  return true;
}

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


// static
bool PageHandler_SaveMemoryBankEntry_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 PageHandler_SaveMemoryBankEntry_ResponseParams_Data* object =
      static_cast<const PageHandler_SaveMemoryBankEntry_ResponseParams_Data*>(data);

  return true;
}

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


// static
bool PageHandler_GetAllMemoryBankTags_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 PageHandler_GetAllMemoryBankTags_Params_Data* object =
      static_cast<const PageHandler_GetAllMemoryBankTags_Params_Data*>(data);

  return true;
}

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


// static
bool PageHandler_GetAllMemoryBankTags_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 PageHandler_GetAllMemoryBankTags_ResponseParams_Data* object =
      static_cast<const PageHandler_GetAllMemoryBankTags_ResponseParams_Data*>(data);

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

  return true;
}

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


// static
bool PageHandler_GetAllMemoryBankCollections_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 PageHandler_GetAllMemoryBankCollections_Params_Data* object =
      static_cast<const PageHandler_GetAllMemoryBankCollections_Params_Data*>(data);

  return true;
}

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


// static
bool PageHandler_GetAllMemoryBankCollections_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 PageHandler_GetAllMemoryBankCollections_ResponseParams_Data* object =
      static_cast<const PageHandler_GetAllMemoryBankCollections_ResponseParams_Data*>(data);

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

  return true;
}

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


// static
bool PageHandler_GetTabs_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 PageHandler_GetTabs_Params_Data* object =
      static_cast<const PageHandler_GetTabs_Params_Data*>(data);

  return true;
}

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


// static
bool PageHandler_GetTabs_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 PageHandler_GetTabs_ResponseParams_Data* object =
      static_cast<const PageHandler_GetTabs_ResponseParams_Data*>(data);

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

  return true;
}

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


// static
bool PageHandler_RetrieveAndGroupTabs_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 PageHandler_RetrieveAndGroupTabs_Params_Data* object =
      static_cast<const PageHandler_RetrieveAndGroupTabs_Params_Data*>(data);

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

  return true;
}

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


// static
bool PageHandler_RetrieveAndGroupTabs_ResponseParams_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 PageHandler_RetrieveAndGroupTabs_ResponseParams_Data* object =
      static_cast<const PageHandler_RetrieveAndGroupTabs_ResponseParams_Data*>(data);

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

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

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

  return true;
}

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


// static
bool PageHandler_GetExistingTabGroupsAndChats_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 PageHandler_GetExistingTabGroupsAndChats_Params_Data* object =
      static_cast<const PageHandler_GetExistingTabGroupsAndChats_Params_Data*>(data);

  return true;
}

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


// static
bool PageHandler_GetExistingTabGroupsAndChats_ResponseParams_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 PageHandler_GetExistingTabGroupsAndChats_ResponseParams_Data* object =
      static_cast<const PageHandler_GetExistingTabGroupsAndChats_ResponseParams_Data*>(data);

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

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

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

  return true;
}

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


// static
bool PageHandler_SwitchToTab_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 PageHandler_SwitchToTab_Params_Data* object =
      static_cast<const PageHandler_SwitchToTab_Params_Data*>(data);

  return true;
}

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


// static
bool PageHandler_CloseTab_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 PageHandler_CloseTab_Params_Data* object =
      static_cast<const PageHandler_CloseTab_Params_Data*>(data);

  return true;
}

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


// static
bool PageHandler_ClearTabGroups_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 PageHandler_ClearTabGroups_Params_Data* object =
      static_cast<const PageHandler_ClearTabGroups_Params_Data*>(data);

  return true;
}

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


// static
bool PageHandler_ClearTabGroups_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 PageHandler_ClearTabGroups_ResponseParams_Data* object =
      static_cast<const PageHandler_ClearTabGroups_ResponseParams_Data*>(data);

  return true;
}

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


// static
bool PageHandler_ClearTabGroupChatHistory_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 PageHandler_ClearTabGroupChatHistory_Params_Data* object =
      static_cast<const PageHandler_ClearTabGroupChatHistory_Params_Data*>(data);

  return true;
}

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


// static
bool PageHandler_ClearTabGroupChatHistory_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 PageHandler_ClearTabGroupChatHistory_ResponseParams_Data* object =
      static_cast<const PageHandler_ClearTabGroupChatHistory_ResponseParams_Data*>(data);

  return true;
}

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


// static
bool PageHandler_AskGeminiWithContext_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 PageHandler_AskGeminiWithContext_Params_Data* object =
      static_cast<const PageHandler_AskGeminiWithContext_Params_Data*>(data);

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

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

  return true;
}

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


// static
bool PageHandler_AskGeminiWithContext_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 PageHandler_AskGeminiWithContext_ResponseParams_Data* object =
      static_cast<const PageHandler_AskGeminiWithContext_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;
}

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


// static
bool PageHandler_ConfirmAllTabGroups_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 PageHandler_ConfirmAllTabGroups_Params_Data* object =
      static_cast<const PageHandler_ConfirmAllTabGroups_Params_Data*>(data);

  return true;
}

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


// static
bool PageHandler_ConfirmAllTabGroups_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 PageHandler_ConfirmAllTabGroups_ResponseParams_Data* object =
      static_cast<const PageHandler_ConfirmAllTabGroups_ResponseParams_Data*>(data);

  return true;
}

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


// static
bool PageHandler_GetConfirmedTabGroups_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 PageHandler_GetConfirmedTabGroups_Params_Data* object =
      static_cast<const PageHandler_GetConfirmedTabGroups_Params_Data*>(data);

  return true;
}

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


// static
bool PageHandler_GetConfirmedTabGroups_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 PageHandler_GetConfirmedTabGroups_ResponseParams_Data* object =
      static_cast<const PageHandler_GetConfirmedTabGroups_ResponseParams_Data*>(data);

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

  return true;
}

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


// static
bool PageHandler_RemoveConfirmedTabGroup_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 PageHandler_RemoveConfirmedTabGroup_Params_Data* object =
      static_cast<const PageHandler_RemoveConfirmedTabGroup_Params_Data*>(data);

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

  return true;
}

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


// static
bool PageHandler_RemoveConfirmedTabGroup_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 PageHandler_RemoveConfirmedTabGroup_ResponseParams_Data* object =
      static_cast<const PageHandler_RemoveConfirmedTabGroup_ResponseParams_Data*>(data);

  return true;
}

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


// static
bool PageHandler_CloseConfirmedTabGroup_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 PageHandler_CloseConfirmedTabGroup_Params_Data* object =
      static_cast<const PageHandler_CloseConfirmedTabGroup_Params_Data*>(data);

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

  return true;
}

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


// static
bool PageHandler_CloseConfirmedTabGroup_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 PageHandler_CloseConfirmedTabGroup_ResponseParams_Data* object =
      static_cast<const PageHandler_CloseConfirmedTabGroup_ResponseParams_Data*>(data);

  return true;
}

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


// static
bool PageHandler_RemoveAllConfirmedTabGroups_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 PageHandler_RemoveAllConfirmedTabGroups_Params_Data* object =
      static_cast<const PageHandler_RemoveAllConfirmedTabGroups_Params_Data*>(data);

  return true;
}

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


// static
bool PageHandler_RemoveAllConfirmedTabGroups_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 PageHandler_RemoveAllConfirmedTabGroups_ResponseParams_Data* object =
      static_cast<const PageHandler_RemoveAllConfirmedTabGroups_ResponseParams_Data*>(data);

  return true;
}

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

}  // namespace internal
BASE_FEATURE(kAutoTabGroups,
             "AutoTabGroups",
             base::FEATURE_DISABLED_BY_DEFAULT
             );
BASE_FEATURE(kAutoTodos,
             "AutoTodos",
             base::FEATURE_DISABLED_BY_DEFAULT
             );
}  // namespace mojom
}  // namespace context_hub
}  // namespace browser

namespace perfetto {

// static
void TraceFormatTraits<::browser::context_hub::mojom::AutoTodoStatus>::WriteIntoTrace(
   perfetto::TracedValue context, ::browser::context_hub::mojom::AutoTodoStatus value) {
  return std::move(context).WriteString(::browser::context_hub::mojom::AutoTodoStatusToString(value));
}

} // namespace perfetto

namespace perfetto {

// static
void TraceFormatTraits<::browser::context_hub::mojom::AutoTodoGroup>::WriteIntoTrace(
   perfetto::TracedValue context, ::browser::context_hub::mojom::AutoTodoGroup value) {
  return std::move(context).WriteString(::browser::context_hub::mojom::AutoTodoGroupToString(value));
}

} // namespace perfetto

namespace perfetto {

// static
void TraceFormatTraits<::browser::context_hub::mojom::EntryType>::WriteIntoTrace(
   perfetto::TracedValue context, ::browser::context_hub::mojom::EntryType value) {
  return std::move(context).WriteString(::browser::context_hub::mojom::EntryTypeToString(value));
}

} // namespace perfetto

namespace perfetto {

// static
void TraceFormatTraits<::browser::context_hub::mojom::ChatRole>::WriteIntoTrace(
   perfetto::TracedValue context, ::browser::context_hub::mojom::ChatRole value) {
  return std::move(context).WriteString(::browser::context_hub::mojom::ChatRoleToString(value));
}

} // namespace perfetto