// chrome/common/actor_webui.mojom-shared-internal.h 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.

#ifndef CHROME_COMMON_ACTOR_WEBUI_MOJOM_SHARED_INTERNAL_H_
#define CHROME_COMMON_ACTOR_WEBUI_MOJOM_SHARED_INTERNAL_H_
#include "mojo/public/cpp/bindings/lib/array_internal.h"
#include "mojo/public/cpp/bindings/lib/bindings_internal.h"
#include "mojo/public/cpp/bindings/lib/map_data_internal.h"
#include "mojo/public/cpp/bindings/lib/validation_errors.h"
#include "mojo/public/cpp/bindings/lib/message_fragment.h"
#include "mojo/public/c/system/macros.h"
#include "chrome/common/glic_enums.mojom-shared-internal.h"
#include "skia/public/mojom/bitmap.mojom-shared-internal.h"
#include "url/mojom/origin.mojom-shared-internal.h"
#include "mojo/public/cpp/bindings/lib/native_enum_data.h"
#include "mojo/public/interfaces/bindings/native_struct.mojom-shared-internal.h"



namespace mojo {
namespace internal {
class ValidationContext;
}
}


namespace actor::webui::mojom {
namespace internal {
class TaskOptions_Data;
class Credential_Data;
class SelectCredentialDialogRequest_Data;
class SelectCredentialDialogResponse_Data;
class AutofillSuggestion_Data;
class FormFillingRequest_Data;
class SelectAutofillSuggestionsDialogRequest_Data;
class FormFillingResponse_Data;
class AutofillSuggestionDialogOnFormPresentedParams_Data;
class AutofillSuggestionDialogOnFormPreviewChangedParams_Data;
class AutofillSuggestionDialogOnFormConfirmedParams_Data;
class SelectAutofillSuggestionsDialogResponse_Data;
class UserConfirmationDialogPayload_Data;
class UserConfirmationDialogRequest_Data;
class UserConfirmationDialogResponse_Data;
class NavigationConfirmationRequest_Data;
class NavigationConfirmationResponse_Data;
class GmailOtpOptInRequest_Data;
class GmailOtpOptInResponse_Data;
class GmailOtpConfirmationRequest_Data;
class GmailOtpConfirmationResponse_Data;
class SelectAutofillSuggestionsDialogResult_Data;
class UserConfirmationDialogResult_Data;
class ConfirmationRequestResult_Data;
class GmailOtpOptInResult_Data;
class GmailOtpConfirmationResult_Data;

struct TaskDuration_Data {
 public:
  static bool constexpr kIsExtensible = true;

  static bool IsKnownValue(int32_t value) {
    switch (value) {
      case 1:
      case 2:
        return true;
    }
    return false;
  }

  static bool Validate(int32_t value,
                       mojo::internal::ValidationContext* validation_context) {
    if (kIsExtensible || IsKnownValue(value))
      return true;

    ReportValidationError(validation_context,
                          mojo::internal::VALIDATION_ERROR_UNKNOWN_ENUM_VALUE);
    return false;
  }
};

struct UserGrantedPermissionDuration_Data {
 public:
  static bool constexpr kIsExtensible = true;

  static bool IsKnownValue(int32_t value) {
    switch (value) {
      case 0:
      case 1:
        return true;
    }
    return false;
  }

  static bool Validate(int32_t value,
                       mojo::internal::ValidationContext* validation_context) {
    if (kIsExtensible || IsKnownValue(value))
      return true;

    ReportValidationError(validation_context,
                          mojo::internal::VALIDATION_ERROR_UNKNOWN_ENUM_VALUE);
    return false;
  }
};

struct CredentialType_Data {
 public:
  static bool constexpr kIsExtensible = true;

  static bool IsKnownValue(int32_t value) {
    switch (value) {
      case 0:
      case 1:
        return true;
    }
    return false;
  }

  static bool Validate(int32_t value,
                       mojo::internal::ValidationContext* validation_context) {
    if (kIsExtensible || IsKnownValue(value))
      return true;

    ReportValidationError(validation_context,
                          mojo::internal::VALIDATION_ERROR_UNKNOWN_ENUM_VALUE);
    return false;
  }
};

struct SelectCredentialDialogErrorReason_Data {
 public:
  static bool constexpr kIsExtensible = true;

  static bool IsKnownValue(int32_t value) {
    switch (value) {
      case 0:
        return true;
    }
    return false;
  }

  static bool Validate(int32_t value,
                       mojo::internal::ValidationContext* validation_context) {
    if (kIsExtensible || IsKnownValue(value))
      return true;

    ReportValidationError(validation_context,
                          mojo::internal::VALIDATION_ERROR_UNKNOWN_ENUM_VALUE);
    return false;
  }
};

struct SelectAutofillSuggestionsDialogErrorReason_Data {
 public:
  static bool constexpr kIsExtensible = false;

  static bool IsKnownValue(int32_t value) {
    switch (value) {
      case 0:
      case 1:
      case 2:
        return true;
    }
    return false;
  }

  static bool Validate(int32_t value,
                       mojo::internal::ValidationContext* validation_context) {
    if (kIsExtensible || IsKnownValue(value))
      return true;

    ReportValidationError(validation_context,
                          mojo::internal::VALIDATION_ERROR_UNKNOWN_ENUM_VALUE);
    return false;
  }
};

struct ConfirmationRequestErrorReason_Data {
 public:
  static bool constexpr kIsExtensible = true;

  static bool IsKnownValue(int32_t value) {
    switch (value) {
      case 0:
      case 1:
        return true;
    }
    return false;
  }

  static bool Validate(int32_t value,
                       mojo::internal::ValidationContext* validation_context) {
    if (kIsExtensible || IsKnownValue(value))
      return true;

    ReportValidationError(validation_context,
                          mojo::internal::VALIDATION_ERROR_UNKNOWN_ENUM_VALUE);
    return false;
  }
};

struct GmailOtpErrorReason_Data {
 public:
  static bool constexpr kIsExtensible = true;

  static bool IsKnownValue(int32_t value) {
    switch (value) {
      case 0:
        return true;
    }
    return false;
  }

  static bool Validate(int32_t value,
                       mojo::internal::ValidationContext* validation_context) {
    if (kIsExtensible || IsKnownValue(value))
      return true;

    ReportValidationError(validation_context,
                          mojo::internal::VALIDATION_ERROR_UNKNOWN_ENUM_VALUE);
    return false;
  }
};

#pragma pack(push, 1)


class  SelectAutofillSuggestionsDialogResult_Data {
 public:
  // Used to identify Mojom Union Data Classes.
  typedef void MojomUnionDataType;

  SelectAutofillSuggestionsDialogResult_Data() = default;
  // Do nothing in the destructor since it won't be called when it is a
  // non-inlined union.
  ~SelectAutofillSuggestionsDialogResult_Data() = default;

  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context,
                       bool inlined);

  bool is_null() const { return size == 0; }

  void set_null() {
    size = 0U;
    tag = static_cast<SelectAutofillSuggestionsDialogResult_Tag>(0);
    data.unknown = 0U;
  }

  // TODO(crbug.com/40731316): SHOUTY_CASE values are being deprecated per C++ code style
  // guidelines (https://google.github.io/styleguide/cppguide.html#Enumerator_Names),
  // please use kCamelCase values instead.  Cleanup NULL_VALUE, BOOL_VALUE, INT_VALUE, etc.
  // generation once codebase is transitioned to kNullValue, kBoolValue, kIntValue, etc.
  enum class SelectAutofillSuggestionsDialogResult_Tag : uint32_t {

    
    kErrorReason,
    
    kSelectedSuggestions,
  };

  // A note on layout:
  // "Each non-static data member is allocated as if it were the sole member of
  // a struct." - Section 9.5.2 ISO/IEC 14882:2011 (The C++ Spec)
  union MOJO_ALIGNAS(8) Union_ {
    Union_() : unknown(0) {}
    int32_t f_error_reason;
    mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<internal::FormFillingResponse_Data>>> f_selected_suggestions;
    uint64_t unknown;
  };

  uint32_t size;
  SelectAutofillSuggestionsDialogResult_Tag tag;
  Union_ data;
};
static_assert(sizeof(SelectAutofillSuggestionsDialogResult_Data) == mojo::internal::kUnionDataSize,
              "Bad sizeof(SelectAutofillSuggestionsDialogResult_Data)");


class  UserConfirmationDialogResult_Data {
 public:
  // Used to identify Mojom Union Data Classes.
  typedef void MojomUnionDataType;

  UserConfirmationDialogResult_Data() = default;
  // Do nothing in the destructor since it won't be called when it is a
  // non-inlined union.
  ~UserConfirmationDialogResult_Data() = default;

  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context,
                       bool inlined);

  bool is_null() const { return size == 0; }

  void set_null() {
    size = 0U;
    tag = static_cast<UserConfirmationDialogResult_Tag>(0);
    data.unknown = 0U;
  }

  // TODO(crbug.com/40731316): SHOUTY_CASE values are being deprecated per C++ code style
  // guidelines (https://google.github.io/styleguide/cppguide.html#Enumerator_Names),
  // please use kCamelCase values instead.  Cleanup NULL_VALUE, BOOL_VALUE, INT_VALUE, etc.
  // generation once codebase is transitioned to kNullValue, kBoolValue, kIntValue, etc.
  enum class UserConfirmationDialogResult_Tag : uint32_t {

    
    kPermissionGranted,
    
    kErrorReason,
  };

  // A note on layout:
  // "Each non-static data member is allocated as if it were the sole member of
  // a struct." - Section 9.5.2 ISO/IEC 14882:2011 (The C++ Spec)
  union MOJO_ALIGNAS(8) Union_ {
    Union_() : unknown(0) {}
    uint8_t f_permission_granted : 1;
    int32_t f_error_reason;
    uint64_t unknown;
  };

  uint32_t size;
  UserConfirmationDialogResult_Tag tag;
  Union_ data;
};
static_assert(sizeof(UserConfirmationDialogResult_Data) == mojo::internal::kUnionDataSize,
              "Bad sizeof(UserConfirmationDialogResult_Data)");


class  ConfirmationRequestResult_Data {
 public:
  // Used to identify Mojom Union Data Classes.
  typedef void MojomUnionDataType;

  ConfirmationRequestResult_Data() = default;
  // Do nothing in the destructor since it won't be called when it is a
  // non-inlined union.
  ~ConfirmationRequestResult_Data() = default;

  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context,
                       bool inlined);

  bool is_null() const { return size == 0; }

  void set_null() {
    size = 0U;
    tag = static_cast<ConfirmationRequestResult_Tag>(0);
    data.unknown = 0U;
  }

  // TODO(crbug.com/40731316): SHOUTY_CASE values are being deprecated per C++ code style
  // guidelines (https://google.github.io/styleguide/cppguide.html#Enumerator_Names),
  // please use kCamelCase values instead.  Cleanup NULL_VALUE, BOOL_VALUE, INT_VALUE, etc.
  // generation once codebase is transitioned to kNullValue, kBoolValue, kIntValue, etc.
  enum class ConfirmationRequestResult_Tag : uint32_t {

    
    kPermissionGranted,
    
    kErrorReason,
  };

  // A note on layout:
  // "Each non-static data member is allocated as if it were the sole member of
  // a struct." - Section 9.5.2 ISO/IEC 14882:2011 (The C++ Spec)
  union MOJO_ALIGNAS(8) Union_ {
    Union_() : unknown(0) {}
    uint8_t f_permission_granted : 1;
    int32_t f_error_reason;
    uint64_t unknown;
  };

  uint32_t size;
  ConfirmationRequestResult_Tag tag;
  Union_ data;
};
static_assert(sizeof(ConfirmationRequestResult_Data) == mojo::internal::kUnionDataSize,
              "Bad sizeof(ConfirmationRequestResult_Data)");


class  GmailOtpOptInResult_Data {
 public:
  // Used to identify Mojom Union Data Classes.
  typedef void MojomUnionDataType;

  GmailOtpOptInResult_Data() = default;
  // Do nothing in the destructor since it won't be called when it is a
  // non-inlined union.
  ~GmailOtpOptInResult_Data() = default;

  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context,
                       bool inlined);

  bool is_null() const { return size == 0; }

  void set_null() {
    size = 0U;
    tag = static_cast<GmailOtpOptInResult_Tag>(0);
    data.unknown = 0U;
  }

  // TODO(crbug.com/40731316): SHOUTY_CASE values are being deprecated per C++ code style
  // guidelines (https://google.github.io/styleguide/cppguide.html#Enumerator_Names),
  // please use kCamelCase values instead.  Cleanup NULL_VALUE, BOOL_VALUE, INT_VALUE, etc.
  // generation once codebase is transitioned to kNullValue, kBoolValue, kIntValue, etc.
  enum class GmailOtpOptInResult_Tag : uint32_t {

    
    kResponse,
    
    kErrorReason,
  };

  // A note on layout:
  // "Each non-static data member is allocated as if it were the sole member of
  // a struct." - Section 9.5.2 ISO/IEC 14882:2011 (The C++ Spec)
  union MOJO_ALIGNAS(8) Union_ {
    Union_() : unknown(0) {}
    mojo::internal::Pointer<internal::GmailOtpOptInResponse_Data> f_response;
    int32_t f_error_reason;
    uint64_t unknown;
  };

  uint32_t size;
  GmailOtpOptInResult_Tag tag;
  Union_ data;
};
static_assert(sizeof(GmailOtpOptInResult_Data) == mojo::internal::kUnionDataSize,
              "Bad sizeof(GmailOtpOptInResult_Data)");


class  GmailOtpConfirmationResult_Data {
 public:
  // Used to identify Mojom Union Data Classes.
  typedef void MojomUnionDataType;

  GmailOtpConfirmationResult_Data() = default;
  // Do nothing in the destructor since it won't be called when it is a
  // non-inlined union.
  ~GmailOtpConfirmationResult_Data() = default;

  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context,
                       bool inlined);

  bool is_null() const { return size == 0; }

  void set_null() {
    size = 0U;
    tag = static_cast<GmailOtpConfirmationResult_Tag>(0);
    data.unknown = 0U;
  }

  // TODO(crbug.com/40731316): SHOUTY_CASE values are being deprecated per C++ code style
  // guidelines (https://google.github.io/styleguide/cppguide.html#Enumerator_Names),
  // please use kCamelCase values instead.  Cleanup NULL_VALUE, BOOL_VALUE, INT_VALUE, etc.
  // generation once codebase is transitioned to kNullValue, kBoolValue, kIntValue, etc.
  enum class GmailOtpConfirmationResult_Tag : uint32_t {

    
    kResponse,
    
    kErrorReason,
  };

  // A note on layout:
  // "Each non-static data member is allocated as if it were the sole member of
  // a struct." - Section 9.5.2 ISO/IEC 14882:2011 (The C++ Spec)
  union MOJO_ALIGNAS(8) Union_ {
    Union_() : unknown(0) {}
    mojo::internal::Pointer<internal::GmailOtpConfirmationResponse_Data> f_response;
    int32_t f_error_reason;
    uint64_t unknown;
  };

  uint32_t size;
  GmailOtpConfirmationResult_Tag tag;
  Union_ data;
};
static_assert(sizeof(GmailOtpConfirmationResult_Data) == mojo::internal::kUnionDataSize,
              "Bad sizeof(GmailOtpConfirmationResult_Data)");
class  TaskOptions_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::String_Data> title;
  uint8_t duration_$flag : 1;
  uint8_t feature_mode_$flag : 1;
  uint8_t actuation_tab_id_$flag : 1;
  uint8_t pad3_[3];
  int32_t duration_$value;
  int32_t feature_mode_$value;
  int32_t actuation_tab_id_$value;

 private:
  friend class mojo::internal::MessageFragment<TaskOptions_Data>;

  TaskOptions_Data();
  ~TaskOptions_Data() = delete;
};
static_assert(sizeof(TaskOptions_Data) == 32,
              "Bad sizeof(TaskOptions_Data)");
// Used by TaskOptions::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct TaskOptions_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  TaskOptions_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~TaskOptions_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<TaskOptions_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    TaskOptions_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  Credential_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  int32_t id;
  int32_t type;
  mojo::internal::Pointer<mojo::internal::String_Data> username;
  mojo::internal::Pointer<mojo::internal::String_Data> source_site_or_app;
  mojo::internal::Pointer<::url::mojom::internal::Origin_Data> request_origin;
  mojo::internal::Pointer<mojo::internal::String_Data> display_origin;
  mojo::internal::Pointer<::skia::mojom::internal::BitmapN32_Data> account_picture;

 private:
  friend class mojo::internal::MessageFragment<Credential_Data>;

  Credential_Data();
  ~Credential_Data() = delete;
};
static_assert(sizeof(Credential_Data) == 56,
              "Bad sizeof(Credential_Data)");
// Used by Credential::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct Credential_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  Credential_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~Credential_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<Credential_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    Credential_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  SelectCredentialDialogRequest_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  int32_t task_id;
  uint8_t show_dialog : 1;
  uint8_t pad1_[3];
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<internal::Credential_Data>>> credentials;
  mojo::internal::Pointer<mojo::internal::Map_Data<mojo::internal::Pointer<mojo::internal::String_Data>, mojo::internal::Pointer<::skia::mojom::internal::BitmapN32_Data>>> icons;

 private:
  friend class mojo::internal::MessageFragment<SelectCredentialDialogRequest_Data>;

  SelectCredentialDialogRequest_Data();
  ~SelectCredentialDialogRequest_Data() = delete;
};
static_assert(sizeof(SelectCredentialDialogRequest_Data) == 32,
              "Bad sizeof(SelectCredentialDialogRequest_Data)");
// Used by SelectCredentialDialogRequest::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct SelectCredentialDialogRequest_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  SelectCredentialDialogRequest_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~SelectCredentialDialogRequest_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<SelectCredentialDialogRequest_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    SelectCredentialDialogRequest_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  SelectCredentialDialogResponse_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  int32_t task_id;
  uint8_t error_reason_$flag : 1;
  uint8_t permission_duration_$flag : 1;
  uint8_t selected_credential_id_$flag : 1;
  uint8_t pad3_[3];
  int32_t error_reason_$value;
  int32_t permission_duration_$value;
  int32_t selected_credential_id_$value;
  uint8_t padfinal_[4];

 private:
  friend class mojo::internal::MessageFragment<SelectCredentialDialogResponse_Data>;

  SelectCredentialDialogResponse_Data();
  ~SelectCredentialDialogResponse_Data() = delete;
};
static_assert(sizeof(SelectCredentialDialogResponse_Data) == 32,
              "Bad sizeof(SelectCredentialDialogResponse_Data)");
// Used by SelectCredentialDialogResponse::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct SelectCredentialDialogResponse_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  SelectCredentialDialogResponse_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~SelectCredentialDialogResponse_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<SelectCredentialDialogResponse_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    SelectCredentialDialogResponse_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  AutofillSuggestion_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::String_Data> id;
  mojo::internal::Pointer<mojo::internal::String_Data> title;
  mojo::internal::Pointer<mojo::internal::String_Data> details;
  mojo::internal::Pointer<::skia::mojom::internal::BitmapN32_Data> icon;

 private:
  friend class mojo::internal::MessageFragment<AutofillSuggestion_Data>;

  AutofillSuggestion_Data();
  ~AutofillSuggestion_Data() = delete;
};
static_assert(sizeof(AutofillSuggestion_Data) == 40,
              "Bad sizeof(AutofillSuggestion_Data)");
// Used by AutofillSuggestion::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct AutofillSuggestion_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  AutofillSuggestion_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~AutofillSuggestion_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<AutofillSuggestion_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    AutofillSuggestion_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  FormFillingRequest_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  int64_t requested_data;
  mojo::internal::Pointer<mojo::internal::String_Data> formatted_request_origin;
  mojo::internal::Pointer<mojo::internal::String_Data> section_label;
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<internal::AutofillSuggestion_Data>>> suggestions;

 private:
  friend class mojo::internal::MessageFragment<FormFillingRequest_Data>;

  FormFillingRequest_Data();
  ~FormFillingRequest_Data() = delete;
};
static_assert(sizeof(FormFillingRequest_Data) == 40,
              "Bad sizeof(FormFillingRequest_Data)");
// Used by FormFillingRequest::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct FormFillingRequest_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  FormFillingRequest_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~FormFillingRequest_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<FormFillingRequest_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    FormFillingRequest_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  SelectAutofillSuggestionsDialogRequest_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  int32_t task_id;
  uint8_t pad0_[4];
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<internal::FormFillingRequest_Data>>> form_filling_requests;

 private:
  friend class mojo::internal::MessageFragment<SelectAutofillSuggestionsDialogRequest_Data>;

  SelectAutofillSuggestionsDialogRequest_Data();
  ~SelectAutofillSuggestionsDialogRequest_Data() = delete;
};
static_assert(sizeof(SelectAutofillSuggestionsDialogRequest_Data) == 24,
              "Bad sizeof(SelectAutofillSuggestionsDialogRequest_Data)");
// Used by SelectAutofillSuggestionsDialogRequest::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct SelectAutofillSuggestionsDialogRequest_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  SelectAutofillSuggestionsDialogRequest_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~SelectAutofillSuggestionsDialogRequest_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<SelectAutofillSuggestionsDialogRequest_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    SelectAutofillSuggestionsDialogRequest_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  FormFillingResponse_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::String_Data> selected_suggestion_id;

 private:
  friend class mojo::internal::MessageFragment<FormFillingResponse_Data>;

  FormFillingResponse_Data();
  ~FormFillingResponse_Data() = delete;
};
static_assert(sizeof(FormFillingResponse_Data) == 16,
              "Bad sizeof(FormFillingResponse_Data)");
// Used by FormFillingResponse::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct FormFillingResponse_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  FormFillingResponse_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~FormFillingResponse_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<FormFillingResponse_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    FormFillingResponse_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  AutofillSuggestionDialogOnFormPresentedParams_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  int32_t form_filling_request_index;
  uint8_t padfinal_[4];

 private:
  friend class mojo::internal::MessageFragment<AutofillSuggestionDialogOnFormPresentedParams_Data>;

  AutofillSuggestionDialogOnFormPresentedParams_Data();
  ~AutofillSuggestionDialogOnFormPresentedParams_Data() = delete;
};
static_assert(sizeof(AutofillSuggestionDialogOnFormPresentedParams_Data) == 16,
              "Bad sizeof(AutofillSuggestionDialogOnFormPresentedParams_Data)");
// Used by AutofillSuggestionDialogOnFormPresentedParams::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct AutofillSuggestionDialogOnFormPresentedParams_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  AutofillSuggestionDialogOnFormPresentedParams_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~AutofillSuggestionDialogOnFormPresentedParams_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<AutofillSuggestionDialogOnFormPresentedParams_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    AutofillSuggestionDialogOnFormPresentedParams_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  AutofillSuggestionDialogOnFormPreviewChangedParams_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  int32_t form_filling_request_index;
  uint8_t pad0_[4];
  mojo::internal::Pointer<internal::FormFillingResponse_Data> response;

 private:
  friend class mojo::internal::MessageFragment<AutofillSuggestionDialogOnFormPreviewChangedParams_Data>;

  AutofillSuggestionDialogOnFormPreviewChangedParams_Data();
  ~AutofillSuggestionDialogOnFormPreviewChangedParams_Data() = delete;
};
static_assert(sizeof(AutofillSuggestionDialogOnFormPreviewChangedParams_Data) == 24,
              "Bad sizeof(AutofillSuggestionDialogOnFormPreviewChangedParams_Data)");
// Used by AutofillSuggestionDialogOnFormPreviewChangedParams::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct AutofillSuggestionDialogOnFormPreviewChangedParams_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  AutofillSuggestionDialogOnFormPreviewChangedParams_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~AutofillSuggestionDialogOnFormPreviewChangedParams_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<AutofillSuggestionDialogOnFormPreviewChangedParams_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    AutofillSuggestionDialogOnFormPreviewChangedParams_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  AutofillSuggestionDialogOnFormConfirmedParams_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  int32_t form_filling_request_index;
  uint8_t pad0_[4];
  mojo::internal::Pointer<internal::FormFillingResponse_Data> response;

 private:
  friend class mojo::internal::MessageFragment<AutofillSuggestionDialogOnFormConfirmedParams_Data>;

  AutofillSuggestionDialogOnFormConfirmedParams_Data();
  ~AutofillSuggestionDialogOnFormConfirmedParams_Data() = delete;
};
static_assert(sizeof(AutofillSuggestionDialogOnFormConfirmedParams_Data) == 24,
              "Bad sizeof(AutofillSuggestionDialogOnFormConfirmedParams_Data)");
// Used by AutofillSuggestionDialogOnFormConfirmedParams::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct AutofillSuggestionDialogOnFormConfirmedParams_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  AutofillSuggestionDialogOnFormConfirmedParams_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~AutofillSuggestionDialogOnFormConfirmedParams_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<AutofillSuggestionDialogOnFormConfirmedParams_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    AutofillSuggestionDialogOnFormConfirmedParams_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  SelectAutofillSuggestionsDialogResponse_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  int32_t task_id;
  uint8_t pad0_[4];
  internal::SelectAutofillSuggestionsDialogResult_Data result;

 private:
  friend class mojo::internal::MessageFragment<SelectAutofillSuggestionsDialogResponse_Data>;

  SelectAutofillSuggestionsDialogResponse_Data();
  ~SelectAutofillSuggestionsDialogResponse_Data() = delete;
};
static_assert(sizeof(SelectAutofillSuggestionsDialogResponse_Data) == 32,
              "Bad sizeof(SelectAutofillSuggestionsDialogResponse_Data)");
// Used by SelectAutofillSuggestionsDialogResponse::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct SelectAutofillSuggestionsDialogResponse_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  SelectAutofillSuggestionsDialogResponse_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~SelectAutofillSuggestionsDialogResponse_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<SelectAutofillSuggestionsDialogResponse_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    SelectAutofillSuggestionsDialogResponse_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  UserConfirmationDialogPayload_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<::url::mojom::internal::Origin_Data> navigation_origin;
  uint8_t for_blocklisted_origin : 1;
  uint8_t padfinal_[7];

 private:
  friend class mojo::internal::MessageFragment<UserConfirmationDialogPayload_Data>;

  UserConfirmationDialogPayload_Data();
  ~UserConfirmationDialogPayload_Data() = delete;
};
static_assert(sizeof(UserConfirmationDialogPayload_Data) == 24,
              "Bad sizeof(UserConfirmationDialogPayload_Data)");
// Used by UserConfirmationDialogPayload::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct UserConfirmationDialogPayload_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  UserConfirmationDialogPayload_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~UserConfirmationDialogPayload_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<UserConfirmationDialogPayload_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    UserConfirmationDialogPayload_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  UserConfirmationDialogRequest_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<internal::UserConfirmationDialogPayload_Data> payload;

 private:
  friend class mojo::internal::MessageFragment<UserConfirmationDialogRequest_Data>;

  UserConfirmationDialogRequest_Data();
  ~UserConfirmationDialogRequest_Data() = delete;
};
static_assert(sizeof(UserConfirmationDialogRequest_Data) == 16,
              "Bad sizeof(UserConfirmationDialogRequest_Data)");
// Used by UserConfirmationDialogRequest::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct UserConfirmationDialogRequest_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  UserConfirmationDialogRequest_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~UserConfirmationDialogRequest_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<UserConfirmationDialogRequest_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    UserConfirmationDialogRequest_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  UserConfirmationDialogResponse_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  internal::ConfirmationRequestResult_Data result;

 private:
  friend class mojo::internal::MessageFragment<UserConfirmationDialogResponse_Data>;

  UserConfirmationDialogResponse_Data();
  ~UserConfirmationDialogResponse_Data() = delete;
};
static_assert(sizeof(UserConfirmationDialogResponse_Data) == 24,
              "Bad sizeof(UserConfirmationDialogResponse_Data)");
// Used by UserConfirmationDialogResponse::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct UserConfirmationDialogResponse_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  UserConfirmationDialogResponse_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~UserConfirmationDialogResponse_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<UserConfirmationDialogResponse_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    UserConfirmationDialogResponse_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  NavigationConfirmationRequest_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  int32_t task_id;
  uint8_t pad0_[4];
  mojo::internal::Pointer<::url::mojom::internal::Origin_Data> navigation_origin;

 private:
  friend class mojo::internal::MessageFragment<NavigationConfirmationRequest_Data>;

  NavigationConfirmationRequest_Data();
  ~NavigationConfirmationRequest_Data() = delete;
};
static_assert(sizeof(NavigationConfirmationRequest_Data) == 24,
              "Bad sizeof(NavigationConfirmationRequest_Data)");
// Used by NavigationConfirmationRequest::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct NavigationConfirmationRequest_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  NavigationConfirmationRequest_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~NavigationConfirmationRequest_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<NavigationConfirmationRequest_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    NavigationConfirmationRequest_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  NavigationConfirmationResponse_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  internal::ConfirmationRequestResult_Data result;

 private:
  friend class mojo::internal::MessageFragment<NavigationConfirmationResponse_Data>;

  NavigationConfirmationResponse_Data();
  ~NavigationConfirmationResponse_Data() = delete;
};
static_assert(sizeof(NavigationConfirmationResponse_Data) == 24,
              "Bad sizeof(NavigationConfirmationResponse_Data)");
// Used by NavigationConfirmationResponse::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct NavigationConfirmationResponse_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  NavigationConfirmationResponse_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~NavigationConfirmationResponse_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<NavigationConfirmationResponse_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    NavigationConfirmationResponse_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  GmailOtpOptInRequest_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  int32_t task_id;
  uint8_t padfinal_[4];

 private:
  friend class mojo::internal::MessageFragment<GmailOtpOptInRequest_Data>;

  GmailOtpOptInRequest_Data();
  ~GmailOtpOptInRequest_Data() = delete;
};
static_assert(sizeof(GmailOtpOptInRequest_Data) == 16,
              "Bad sizeof(GmailOtpOptInRequest_Data)");
// Used by GmailOtpOptInRequest::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct GmailOtpOptInRequest_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  GmailOtpOptInRequest_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~GmailOtpOptInRequest_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<GmailOtpOptInRequest_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    GmailOtpOptInRequest_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  GmailOtpOptInResponse_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  uint8_t permission_granted : 1;
  uint8_t padfinal_[7];

 private:
  friend class mojo::internal::MessageFragment<GmailOtpOptInResponse_Data>;

  GmailOtpOptInResponse_Data();
  ~GmailOtpOptInResponse_Data() = delete;
};
static_assert(sizeof(GmailOtpOptInResponse_Data) == 16,
              "Bad sizeof(GmailOtpOptInResponse_Data)");
// Used by GmailOtpOptInResponse::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct GmailOtpOptInResponse_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  GmailOtpOptInResponse_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~GmailOtpOptInResponse_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<GmailOtpOptInResponse_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    GmailOtpOptInResponse_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  GmailOtpConfirmationRequest_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  int32_t task_id;
  uint8_t pad0_[4];
  mojo::internal::Pointer<mojo::internal::String_Data> verification_code;

 private:
  friend class mojo::internal::MessageFragment<GmailOtpConfirmationRequest_Data>;

  GmailOtpConfirmationRequest_Data();
  ~GmailOtpConfirmationRequest_Data() = delete;
};
static_assert(sizeof(GmailOtpConfirmationRequest_Data) == 24,
              "Bad sizeof(GmailOtpConfirmationRequest_Data)");
// Used by GmailOtpConfirmationRequest::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct GmailOtpConfirmationRequest_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  GmailOtpConfirmationRequest_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~GmailOtpConfirmationRequest_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<GmailOtpConfirmationRequest_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    GmailOtpConfirmationRequest_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  GmailOtpConfirmationResponse_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  uint8_t permission_granted : 1;
  uint8_t padfinal_[7];

 private:
  friend class mojo::internal::MessageFragment<GmailOtpConfirmationResponse_Data>;

  GmailOtpConfirmationResponse_Data();
  ~GmailOtpConfirmationResponse_Data() = delete;
};
static_assert(sizeof(GmailOtpConfirmationResponse_Data) == 16,
              "Bad sizeof(GmailOtpConfirmationResponse_Data)");
// Used by GmailOtpConfirmationResponse::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct GmailOtpConfirmationResponse_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  GmailOtpConfirmationResponse_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~GmailOtpConfirmationResponse_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<GmailOtpConfirmationResponse_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    GmailOtpConfirmationResponse_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};

#pragma pack(pop)

}  // namespace internal

}  // actor::webui::mojom

#endif  // CHROME_COMMON_ACTOR_WEBUI_MOJOM_SHARED_INTERNAL_H_