// chrome/browser/glic/host/glic.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_BROWSER_GLIC_HOST_GLIC_MOJOM_SHARED_INTERNAL_H_
#define CHROME_BROWSER_GLIC_HOST_GLIC_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/browser/glic/host/glic_features.mojom-shared-internal.h"
#include "chrome/common/actor_webui.mojom-shared-internal.h"
#include "chrome/common/glic_enums.mojom-shared-internal.h"
#include "components/content_settings/core/common/content_settings_types.mojom-shared-internal.h"
#include "mojo/public/mojom/base/absl_status.mojom-shared-internal.h"
#include "mojo/public/mojom/base/big_buffer.mojom-shared-internal.h"
#include "mojo/public/mojom/base/byte_string.mojom-shared-internal.h"
#include "mojo/public/mojom/base/proto_wrapper.mojom-shared-internal.h"
#include "mojo/public/mojom/base/string16.mojom-shared-internal.h"
#include "mojo/public/mojom/base/time.mojom-shared-internal.h"
#include "mojo/public/mojom/base/unguessable_token.mojom-shared-internal.h"
#include "mojo/public/mojom/base/values.mojom-shared-internal.h"
#include "mojo/public/mojom/base/version.mojom-shared-internal.h"
#include "skia/public/mojom/bitmap.mojom-shared-internal.h"
#include "third_party/blink/public/mojom/content_extraction/ai_page_content_metadata.mojom-shared-internal.h"
#include "ui/gfx/geometry/mojom/geometry.mojom-shared-internal.h"
#include "url/mojom/origin.mojom-shared-internal.h"
#include "url/mojom/url.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 glic::mojom {
namespace internal {
class GeminiEnterpriseSettings_Data;
class ProfileEnablement_Data;
class ConfigInfo_Data;
class DefaultConversation_Data;
class NewConversation_Data;
class DefaultSurfaceMojo_Data;
class NewTabMojo_Data;
class ZssConfig_Data;
class GetContextResultWithActionResultCode_Data;
class UserProfileInfo_Data;
class SafeBrowsingVerdict_Data;
class CounterAbuseVerdict_Data;
class WebClientInitialState_Data;
class ScreenshotCollectionOptions_Data;
class TabContextOptions_Data;
class GetPinCandidatesOptions_Data;
class ScrollToParams_Data;
class ScrollToTextSelector_Data;
class ScrollToTextFragmentSelector_Data;
class ScrollToNodeSelector_Data;
class SuggestionContent_Data;
class SkillPreview_Data;
class Skill_Data;
class CreateSkillRequest_Data;
class UpdateSkillRequest_Data;
class ZeroStateSuggestions_Data;
class ZeroStateSuggestionsV2_Data;
class ZeroStateSuggestionsOptions_Data;
class PinCandidate_Data;
class PinTabsOptions_Data;
class UnpinTabsOptions_Data;
class OpenPinnedTabPickerOptions_Data;
class CreateActorTabOptions_Data;
class CaptureRegionParams_Data;
class ActivateTabOptions_Data;
class CreateTabOptions_Data;
class ConversationInfo_Data;
class PanelOpeningData_Data;
class PanelState_Data;
class SkillsPayload_Data;
class UniversalCartPayload_Data;
class InvokeOptions_Data;
class OnResponseStoppedDetails_Data;
class OpenPanelInfo_Data;
class ContextData_Data;
class ParentConversationMetadata_Data;
class AdditionalContext_Data;
class ExperimentalTriggeringUpdate_Data;
class TabContextResult_Data;
class WebPageData_Data;
class DocumentData_Data;
class PdfDocumentData_Data;
class TabData_Data;
class NoFocusedTabData_Data;
class AnnotatedPageData_Data;
class ImageOriginAnnotations_Data;
class Journal_Data;
class PendingCapturedRegion_Data;
class CaptureRegionResult_Data;
class Screenshot_Data;
class ImageInfo_Data;
class ImageBytesResult_Data;
class OpenSettingsOptions_Data;
class InvokeConversationSelection_Data;
class InvokeTargetSurface_Data;
class GetContextResult_Data;
class CaptureScreenshotResult_Data;
class ScrollToSelector_Data;
class InvocationPayload_Data;
class AdditionalContextPart_Data;
class FocusedTabData_Data;
class CapturedRegion_Data;
class GetImageBytesResult_Data;
class ActorHandler_CreateTask_ResponseParam_Result_Data;
class ActorHandler_PerformActions_ResponseParam_Result_Data;

struct GlicExperimentalTriggeringState_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 FileUploadPolicyState_Data {
 public:
  static bool constexpr kIsExtensible = false;

  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 ActuationEligibility_Data {
 public:
  static bool constexpr kIsExtensible = false;

  static bool IsKnownValue(int32_t value) {
    switch (value) {
      case 0:
      case 1:
      case 2:
      case 3:
      case 4:
      case 5:
        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 MetricUserInputReactionType_Data {
 public:
  static bool constexpr kIsExtensible = true;

  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 PerformActionsErrorReason_Data {
 public:
  static bool constexpr kIsExtensible = true;

  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 CreateTaskErrorReason_Data {
 public:
  static bool constexpr kIsExtensible = true;

  static bool IsKnownValue(int32_t value) {
    switch (value) {
      case 0:
      case 1:
      case 2:
      case 3:
      case 4:
        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 ActorTaskState_Data {
 public:
  static bool constexpr kIsExtensible = true;

  static bool IsKnownValue(int32_t value) {
    switch (value) {
      case 0:
      case 1:
      case 2:
      case 3:
      case 4:
        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 ActorTaskPauseReason_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 ActorTaskStopReason_Data {
 public:
  static bool constexpr kIsExtensible = true;

  static bool IsKnownValue(int32_t value) {
    switch (value) {
      case 0:
      case 1:
      case 2:
      case 3:
      case 4:
        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 ActorTaskInterruptReason_Data {
 public:
  static bool constexpr kIsExtensible = true;

  static bool IsKnownValue(int32_t value) {
    switch (value) {
      case 0:
      case 1:
      case 2:
      case 3:
      case 4:
      case 5:
      case 6:
      case 7:
      case 8:
        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 CaptureScreenshotErrorReason_Data {
 public:
  static bool constexpr kIsExtensible = true;

  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 SbThreatType_Data {
 public:
  static bool constexpr kIsExtensible = true;

  static bool IsKnownValue(int32_t value) {
    switch (value) {
      case 0:
      case 1:
      case 2:
      case 3:
        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 Platform_Data {
 public:
  static bool constexpr kIsExtensible = false;

  static bool IsKnownValue(int32_t value) {
    switch (value) {
      case 0:
      case 1:
      case 2:
      case 3:
      case 4:
      case 5:
        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 FormFactor_Data {
 public:
  static bool constexpr kIsExtensible = false;

  static bool IsKnownValue(int32_t value) {
    switch (value) {
      case 0:
      case 1:
      case 2:
      case 3:
        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 ScreenshotImageFormat_Data {
 public:
  static bool constexpr kIsExtensible = true;

  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 ScreenshotCompressionQuality_Data {
 public:
  static bool constexpr kIsExtensible = true;

  static bool IsKnownValue(int32_t value) {
    switch (value) {
      case 0:
      case 1:
      case 2:
      case 3:
        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 ScrollToErrorReason_Data {
 public:
  static bool constexpr kIsExtensible = true;

  static bool IsKnownValue(int32_t value) {
    switch (value) {
      case 0:
      case 1:
      case 2:
      case 3:
      case 4:
      case 5:
      case 6:
      case 7:
      case 8:
        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 SkillSource_Data {
 public:
  static bool constexpr kIsExtensible = true;

  static bool IsKnownValue(int32_t value) {
    switch (value) {
      case 0:
      case 1:
      case 2:
      case 3:
      case 4:
      case 5:
        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 SkillsWebClientEvent_Data {
 public:
  static bool constexpr kIsExtensible = true;

  static bool IsKnownValue(int32_t value) {
    switch (value) {
      case 0:
      case 1:
      case 2:
      case 3:
      case 4:
      case 5:
      case 6:
      case 7:
      case 8:
      case 9:
      case 10:
      case 11:
      case 12:
      case 13:
      case 14:
      case 15:
      case 16:
      case 17:
      case 20:
      case 21:
      case 22:
        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 PinTrigger_Data {
 public:
  static bool constexpr kIsExtensible = true;

  static bool IsKnownValue(int32_t value) {
    switch (value) {
      case 0:
      case 1:
      case 2:
      case 3:
        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 UnpinTrigger_Data {
 public:
  static bool constexpr kIsExtensible = true;

  static bool IsKnownValue(int32_t value) {
    switch (value) {
      case 0:
      case 1:
      case 2:
      case 3:
        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 CancelActionsResult_Data {
 public:
  static bool constexpr kIsExtensible = true;

  static bool IsKnownValue(int32_t value) {
    switch (value) {
      case 0:
      case 1:
      case 2:
      case 3:
        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 SwitchConversationErrorReason_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 RegisterConversationErrorReason_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 PanelStateKind_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 FreOverride_Data {
 public:
  static bool constexpr kIsExtensible = true;

  static bool IsKnownValue(int32_t value) {
    switch (value) {
      case 0:
      case 1:
      case 2:
      case 3:
        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 InvocationSource_Data {
 public:
  static bool constexpr kIsExtensible = true;

  static bool IsKnownValue(int32_t value) {
    switch (value) {
      case 0:
      case 1:
      case 2:
      case 3:
      case 4:
      case 5:
      case 6:
      case 7:
      case 8:
      case 9:
      case 10:
      case 11:
      case 12:
      case 13:
      case 14:
      case 15:
      case 16:
      case 17:
      case 18:
      case 19:
      case 20:
      case 21:
      case 22:
      case 23:
      case 24:
      case 25:
      case 26:
      case 27:
      case 28:
      case 29:
      case 30:
      case 31:
      case 32:
      case 33:
      case 34:
      case 35:
      case 36:
      case 37:
      case 38:
      case 39:
      case 40:
      case 41:
      case 42:
        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 ActuationTarget_Data {
 public:
  static bool constexpr kIsExtensible = true;

  static bool IsKnownValue(int32_t value) {
    switch (value) {
      case 0:
      case 1:
      case 2:
      case 3:
      case 4:
        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 WebClientMode_Data {
 public:
  static bool constexpr kIsExtensible = true;

  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 PromptType_Data {
 public:
  static bool constexpr kIsExtensible = true;

  static bool IsKnownValue(int32_t value) {
    switch (value) {
      case 0:
      case 1:
      case 2:
      case 3:
      case 4:
        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 MicrophoneStatus_Data {
 public:
  static bool constexpr kIsExtensible = true;

  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 WebClientModel_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 WebUseCounter_Data {
 public:
  static bool constexpr kIsExtensible = true;

  static bool IsKnownValue(int32_t value) {
    switch (value) {
      case 0:
      case 1:
      case 2:
      case 3:
      case 4:
      case 5:
      case 6:
        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 ClientErrorDialogType_Data {
 public:
  static bool constexpr kIsExtensible = true;

  static bool IsKnownValue(int32_t value) {
    switch (value) {
      case 0:
      case 1:
      case 2:
      case 3:
      case 4:
      case 5:
        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 ResponseStopCause_Data {
 public:
  static bool constexpr kIsExtensible = true;

  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 AdditionalContextSource_Data {
 public:
  static bool constexpr kIsExtensible = true;

  static bool IsKnownValue(int32_t value) {
    switch (value) {
      case 0:
      case 1:
      case 2:
      case 3:
      case 4:
      case 5:
        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 ExperimentalTriggeringUpdateType_Data {
 public:
  static bool constexpr kIsExtensible = true;

  static bool IsKnownValue(int32_t value) {
    switch (value) {
      case 0:
      case 1:
      case 2:
      case 3:
      case 4:
      case 5:
      case 6:
      case 7:
        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 SubscriberObservationType_Data {
 public:
  static bool constexpr kIsExtensible = true;

  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 LightweightPageFeature_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 CaptureRegionErrorReason_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 ScreenshotEncryptionScheme_Data {
 public:
  static bool constexpr kIsExtensible = true;

  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 SettingsPageField_Data {
 public:
  static bool constexpr kIsExtensible = true;

  static bool IsKnownValue(int32_t value) {
    switch (value) {
      case 0:
      case 1:
      case 2:
      case 3:
        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 HostCapability_Data {
 public:
  static bool constexpr kIsExtensible = false;

  static bool IsKnownValue(int32_t value) {
    switch (value) {
      case 0:
      case 1:
      case 2:
      case 3:
      case 4:
      case 5:
      case 6:
      case 7:
      case 8:
      case 9:
      case 10:
      case 11:
      case 12:
      case 13:
      case 14:
      case 15:
        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 ClientCapabilities_Data {
 public:
  static bool constexpr kIsExtensible = false;

  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  InvokeConversationSelection_Data {
 public:
  // Used to identify Mojom Union Data Classes.
  typedef void MojomUnionDataType;

  InvokeConversationSelection_Data() = default;
  // Do nothing in the destructor since it won't be called when it is a
  // non-inlined union.
  ~InvokeConversationSelection_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<InvokeConversationSelection_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 InvokeConversationSelection_Tag : uint32_t {

    
    kDefaultConversation,
    
    kNewConversation,
    
    kConversationId,
  };

  // 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::DefaultConversation_Data> f_default_conversation;
    mojo::internal::Pointer<internal::NewConversation_Data> f_new_conversation;
    mojo::internal::Pointer<mojo::internal::String_Data> f_conversation_id;
    uint64_t unknown;
  };

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


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

  InvokeTargetSurface_Data() = default;
  // Do nothing in the destructor since it won't be called when it is a
  // non-inlined union.
  ~InvokeTargetSurface_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<InvokeTargetSurface_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 InvokeTargetSurface_Tag : uint32_t {

    
    kDefaultSurface,
    
    kNewTab,
  };

  // 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::DefaultSurfaceMojo_Data> f_default_surface;
    mojo::internal::Pointer<internal::NewTabMojo_Data> f_new_tab;
    uint64_t unknown;
  };

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


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

  GetContextResult_Data() = default;
  // Do nothing in the destructor since it won't be called when it is a
  // non-inlined union.
  ~GetContextResult_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<GetContextResult_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 GetContextResult_Tag : uint32_t {

    
    kErrorReason,
    
    kTabContext,
  };

  // 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<mojo::internal::String_Data> f_error_reason;
    mojo::internal::Pointer<internal::TabContextResult_Data> f_tab_context;
    uint64_t unknown;
  };

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


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

  CaptureScreenshotResult_Data() = default;
  // Do nothing in the destructor since it won't be called when it is a
  // non-inlined union.
  ~CaptureScreenshotResult_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<CaptureScreenshotResult_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 CaptureScreenshotResult_Tag : uint32_t {

    
    kErrorReason,
    
    kScreenshot,
  };

  // 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<internal::Screenshot_Data> f_screenshot;
    uint64_t unknown;
  };

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


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

  ScrollToSelector_Data() = default;
  // Do nothing in the destructor since it won't be called when it is a
  // non-inlined union.
  ~ScrollToSelector_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<ScrollToSelector_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 ScrollToSelector_Tag : uint32_t {

    
    kExactText,
    
    kTextFragment,
    
    kNode,
  };

  // 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::ScrollToTextSelector_Data> f_exact_text;
    mojo::internal::Pointer<internal::ScrollToTextFragmentSelector_Data> f_text_fragment;
    mojo::internal::Pointer<internal::ScrollToNodeSelector_Data> f_node;
    uint64_t unknown;
  };

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


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

  InvocationPayload_Data() = default;
  // Do nothing in the destructor since it won't be called when it is a
  // non-inlined union.
  ~InvocationPayload_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<InvocationPayload_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 InvocationPayload_Tag : uint32_t {

    
    kUniversalCart,
    
    kSkillsPayload,
  };

  // 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::UniversalCartPayload_Data> f_universal_cart;
    mojo::internal::Pointer<internal::SkillsPayload_Data> f_skills_payload;
    uint64_t unknown;
  };

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


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

  AdditionalContextPart_Data() = default;
  // Do nothing in the destructor since it won't be called when it is a
  // non-inlined union.
  ~AdditionalContextPart_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<AdditionalContextPart_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 AdditionalContextPart_Tag : uint32_t {

    
    kData,
    
    kScreenshot,
    
    kWebPageData,
    
    kAnnotatedPageData,
    
    kPdfDocumentData,
    
    kTabContext,
    
    kRegion,
    
    kPendingRegion,
    
    kParentConversationMetadata,
  };

  // 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::ContextData_Data> f_data;
    mojo::internal::Pointer<internal::Screenshot_Data> f_screenshot;
    mojo::internal::Pointer<internal::WebPageData_Data> f_web_page_data;
    mojo::internal::Pointer<internal::AnnotatedPageData_Data> f_annotated_page_data;
    mojo::internal::Pointer<internal::PdfDocumentData_Data> f_pdf_document_data;
    mojo::internal::Pointer<internal::TabContextResult_Data> f_tab_context;
    mojo::internal::Pointer<internal::CapturedRegion_Data> f_region;
    mojo::internal::Pointer<internal::PendingCapturedRegion_Data> f_pending_region;
    mojo::internal::Pointer<internal::ParentConversationMetadata_Data> f_parent_conversation_metadata;
    uint64_t unknown;
  };

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


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

  FocusedTabData_Data() = default;
  // Do nothing in the destructor since it won't be called when it is a
  // non-inlined union.
  ~FocusedTabData_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<FocusedTabData_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 FocusedTabData_Tag : uint32_t {

    
    kFocusedTab,
    
    kNoFocusedTabData,
  };

  // 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::TabData_Data> f_focused_tab;
    mojo::internal::Pointer<internal::NoFocusedTabData_Data> f_no_focused_tab_data;
    uint64_t unknown;
  };

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


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

  CapturedRegion_Data() = default;
  // Do nothing in the destructor since it won't be called when it is a
  // non-inlined union.
  ~CapturedRegion_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<CapturedRegion_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 CapturedRegion_Tag : uint32_t {

    
    kRect,
    
    kPolyline,
  };

  // 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<::gfx::mojom::internal::Rect_Data> f_rect;
    mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<::gfx::mojom::internal::Point_Data>>> f_polyline;
    uint64_t unknown;
  };

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


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

  GetImageBytesResult_Data() = default;
  // Do nothing in the destructor since it won't be called when it is a
  // non-inlined union.
  ~GetImageBytesResult_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<GetImageBytesResult_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 GetImageBytesResult_Tag : uint32_t {

    
    kImageBytes,
    
    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::ImageBytesResult_Data> f_image_bytes;
    mojo::internal::Pointer<mojo::internal::String_Data> f_error_reason;
    uint64_t unknown;
  };

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


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

  ActorHandler_CreateTask_ResponseParam_Result_Data() = default;
  // Do nothing in the destructor since it won't be called when it is a
  // non-inlined union.
  ~ActorHandler_CreateTask_ResponseParam_Result_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<ActorHandler_CreateTask_ResponseParam_Result_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 ActorHandler_CreateTask_ResponseParam_Result_Tag : uint32_t {

    
    kSuccess,
    
    kFailure,
  };

  // 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_success;
    int32_t f_failure;
    uint64_t unknown;
  };

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


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

  ActorHandler_PerformActions_ResponseParam_Result_Data() = default;
  // Do nothing in the destructor since it won't be called when it is a
  // non-inlined union.
  ~ActorHandler_PerformActions_ResponseParam_Result_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<ActorHandler_PerformActions_ResponseParam_Result_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 ActorHandler_PerformActions_ResponseParam_Result_Tag : uint32_t {

    
    kSuccess,
    
    kFailure,
  };

  // 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<::mojo_base::mojom::internal::ProtoWrapper_Data> f_success;
    int32_t f_failure;
    uint64_t unknown;
  };

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::String_Data> project_id;
  mojo::internal::Pointer<mojo::internal::String_Data> app_id;
  mojo::internal::Pointer<mojo::internal::String_Data> location;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  uint8_t feature_enabled : 1;
  uint8_t is_regular_profile : 1;
  uint8_t is_rolled_out : 1;
  uint8_t primary_account_is_capable : 1;
  uint8_t primary_account_is_fully_signed_in : 1;
  uint8_t allowed_by_chrome_policy : 1;
  uint8_t allowed_by_remote_admin : 1;
  uint8_t allowed_by_remote_other : 1;
  uint8_t fre_is_consented : 1;
  uint8_t allowed_by_country_filter : 1;
  uint8_t allowed_by_locale_filter : 1;
  uint8_t actuation_is_consented : 1;
  uint8_t live_allowed : 1;
  uint8_t share_image_allowed : 1;
  uint8_t pad13_[2];
  int32_t actuation_eligibility;
  mojo::internal::Pointer<internal::GeminiEnterpriseSettings_Data> gemini_enterprise_settings;
  int32_t glic_api_actuation_eligibility;
  int32_t glic_experimental_triggering_state;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<::url::mojom::internal::Url_Data> guest_url;
  mojo::internal::Pointer<::url::mojom::internal::Url_Data> autopush_guest_url;
  mojo::internal::Pointer<::url::mojom::internal::Url_Data> staging_guest_url;
  mojo::internal::Pointer<::url::mojom::internal::Url_Data> preprod_guest_url;
  mojo::internal::Pointer<::url::mojom::internal::Url_Data> prod_guest_url;
  mojo::internal::Pointer<::url::mojom::internal::Url_Data> web_continuity_originating_host_url;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;

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

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

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

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

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

  UserType user_data_;
};

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

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

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

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

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

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

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

  UserType user_data_;
};

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

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

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  internal::GetContextResult_Data get_context_result;
  uint8_t action_result_$flag : 1;
  uint8_t pad1_[3];
  int32_t action_result_$value;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<::skia::mojom::internal::BitmapN32_Data> avatar_icon;
  mojo::internal::Pointer<mojo::internal::String_Data> display_name;
  mojo::internal::Pointer<mojo::internal::String_Data> given_name;
  mojo::internal::Pointer<mojo::internal::String_Data> local_profile_name;
  mojo::internal::Pointer<mojo::internal::String_Data> email;
  uint8_t is_managed : 1;
  uint8_t padfinal_[7];

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::String_Data> url;
  int32_t threat_type;
  uint8_t show_interstitial : 1;
  uint8_t padfinal_[3];

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<internal::SafeBrowsingVerdict_Data> sb_verdict_result;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<internal::PanelState_Data> panel_state;
  internal::FocusedTabData_Data focused_tab_data;
  uint8_t microphone_permission_enabled : 1;
  uint8_t location_permission_enabled : 1;
  uint8_t tab_context_permission_enabled : 1;
  uint8_t os_location_permission_enabled : 1;
  uint8_t can_attach : 1;
  uint8_t panel_is_active : 1;
  uint8_t browser_is_open : 1;
  uint8_t instance_is_active : 1;
  uint8_t enable_zero_state_suggestions : 1;
  uint8_t enable_cached_get_user_profile_info : 1;
  uint8_t enable_act_in_focused_tab : 1;
  uint8_t enable_scroll_to : 1;
  uint8_t enable_default_tab_context_setting_feature : 1;
  uint8_t default_tab_context_setting_enabled : 1;
  uint8_t closed_captioning_setting_enabled : 1;
  uint8_t enable_maybe_refresh_user_status : 1;
  uint8_t enable_multi_tab : 1;
  uint8_t enable_get_context_actor : 1;
  uint8_t enable_get_page_metadata : 1;
  uint8_t enable_capture_region : 1;
  uint8_t enable_web_actuation_setting_feature : 1;
  uint8_t actuation_on_web_setting_enabled : 1;
  uint8_t can_act_on_web : 1;
  uint8_t enable_activate_tab : 1;
  uint8_t enable_get_tab_by_id : 1;
  uint8_t enable_open_password_manager_settings_page : 1;
  uint8_t enable_trust_first_onboarding : 1;
  uint8_t onboarding_completed : 1;
  uint8_t enable_skills : 1;
  uint8_t enable_get_tab_favicon_by_id : 1;
  uint8_t enable_process_counter_abuse_verdict : 1;
  uint8_t enable_gmail_otp_opt_in : 1;
  int32_t platform;
  double zoom_factor;
  mojo::internal::Pointer<mojo::internal::String_Data> hotkey;
  mojo::internal::Pointer<::mojo_base::mojom::internal::Version_Data> chrome_version;
  int32_t form_factor;
  uint8_t enable_gmail_otp_confirmation : 1;
  uint8_t pad39_[3];
  mojo::internal::Pointer<mojo::internal::Array_Data<int32_t>> host_capabilities;
  mojo::internal::Pointer<internal::GeminiEnterpriseSettings_Data> gemini_enterprise_settings;
  int32_t file_upload_policy_state;
  uint8_t padfinal_[4];

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  uint32_t max_width;
  uint32_t max_height;
  int32_t screenshot_image_format;
  int32_t screenshot_compression_quality;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  uint8_t inner_text : 1;
  uint8_t viewport_screenshot : 1;
  uint8_t annotated_page_content : 1;
  uint8_t pdf_data : 1;
  uint8_t pad3_[3];
  uint32_t inner_text_bytes_limit;
  uint32_t max_meta_tags;
  uint32_t pdf_size_limit;
  uint32_t annotated_page_content_mode;
  uint8_t pad7_[4];
  mojo::internal::Pointer<internal::ScreenshotCollectionOptions_Data> screenshot_collection_options;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  uint32_t max_candidates;
  uint8_t pad0_[4];
  mojo::internal::Pointer<mojo::internal::String_Data> query;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  internal::ScrollToSelector_Data selector;
  uint8_t highlight : 1;
  uint8_t pad1_[7];
  mojo::internal::Pointer<::mojo_base::mojom::internal::UnguessableToken_Data> document_id;
  mojo::internal::Pointer<::url::mojom::internal::Url_Data> url;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::String_Data> text;
  uint8_t search_range_start_node_id_$flag : 1;
  uint8_t pad1_[3];
  int32_t search_range_start_node_id_$value;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::String_Data> text_start;
  mojo::internal::Pointer<mojo::internal::String_Data> text_end;
  uint8_t search_range_start_node_id_$flag : 1;
  uint8_t pad2_[3];
  int32_t search_range_start_node_id_$value;

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

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

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

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

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

  UserType user_data_;
};

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

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

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

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

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

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

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

  UserType user_data_;
};

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

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

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

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

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

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

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

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    SuggestionContent_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  SkillPreview_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> name;
  mojo::internal::Pointer<mojo::internal::String_Data> icon;
  int32_t source;
  uint8_t pad3_[4];
  mojo::internal::Pointer<mojo::internal::String_Data> description;
  mojo::internal::Pointer<mojo::internal::String_Data> curated_by;
  mojo::internal::Pointer<::url::mojom::internal::Url_Data> image_url;
  mojo::internal::Pointer<mojo::internal::String_Data> category;
  mojo::internal::Pointer<::mojo_base::mojom::internal::Time_Data> creation_time;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<internal::SkillPreview_Data> preview;
  mojo::internal::Pointer<mojo::internal::String_Data> prompt;
  mojo::internal::Pointer<mojo::internal::String_Data> source_skill_id;

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

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

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

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

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

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    Skill_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  CreateSkillRequest_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> name;
  mojo::internal::Pointer<mojo::internal::String_Data> icon;
  int32_t source;
  uint8_t pad3_[4];
  mojo::internal::Pointer<mojo::internal::String_Data> prompt;
  mojo::internal::Pointer<mojo::internal::String_Data> description;

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

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

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

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

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

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    CreateSkillRequest_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  UpdateSkillRequest_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;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<internal::SuggestionContent_Data>>> suggestions;
  int32_t tab_id;
  uint8_t pad1_[4];
  mojo::internal::Pointer<::url::mojom::internal::Url_Data> url;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<internal::SuggestionContent_Data>>> suggestions;
  uint8_t is_pending : 1;
  uint8_t pad1_[3];
  int32_t invocation_source;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  uint8_t is_first_run : 1;
  uint8_t pad0_[7];
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<mojo::internal::String_Data>>> supported_tools;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<internal::TabData_Data> tab_data;

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

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

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

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

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

  UserType user_data_;
};

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

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

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

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

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

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

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

  UserType user_data_;
};

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

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

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  uint8_t initiator_tab_id_$flag : 1;
  uint8_t initiator_window_id_$flag : 1;
  uint8_t open_in_background : 1;
  uint8_t pad2_[3];
  int32_t initiator_tab_id_$value;
  int32_t initiator_window_id_$value;
  uint8_t padfinal_[4];

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  int32_t tab_id;
  uint8_t pad0_[4];
  mojo::internal::Pointer<internal::TabContextOptions_Data> options;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::String_Data> pattern;
  uint8_t fallback_window_id_$flag : 1;
  uint8_t pad1_[3];
  int32_t fallback_window_id_$value;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  uint8_t open_in_background : 1;
  uint8_t window_id_$flag : 1;
  uint8_t pad1_[3];
  int32_t window_id_$value;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::String_Data> conversation_id;
  mojo::internal::Pointer<mojo::internal::String_Data> conversation_title;
  mojo::internal::Pointer<::mojo_base::mojom::internal::ByteString_Data> client_data;
  mojo::internal::Pointer<mojo::internal::String_Data> turn_id;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<internal::PanelState_Data> panel_state;
  int32_t invocation_source;
  uint8_t auto_send : 1;
  uint8_t pad2_[3];
  mojo::internal::Pointer<mojo::internal::String_Data> prompt_suggestion;
  mojo::internal::Pointer<internal::Skill_Data> skill_to_invoke;
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<internal::ConversationInfo_Data>>> recently_active_conversations;
  mojo::internal::Pointer<internal::ConversationInfo_Data> conversation_info;
  int32_t fre_override;
  uint8_t padfinal_[4];

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  int32_t kind;
  uint8_t window_id_$flag : 1;
  uint8_t pad1_[3];
  int32_t window_id_$value;
  uint8_t padfinal_[4];

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::String_Data> skill_id;
  mojo::internal::Pointer<mojo::internal::String_Data> skill_name;
  mojo::internal::Pointer<mojo::internal::String_Data> skill_icon;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::Array_Data<uint8_t>> serialized_metadata;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  int32_t invocation_source;
  uint8_t auto_submit : 1;
  uint8_t disable_zero_state_suggestions : 1;
  uint8_t actuation_tab_id_$flag : 1;
  uint8_t pad3_[3];
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<mojo::internal::String_Data>>> prompts;
  mojo::internal::Pointer<internal::AdditionalContext_Data> context;
  int32_t feature_mode;
  int32_t actuation_target;
  mojo::internal::Pointer<mojo::internal::String_Data> skill_id;
  mojo::internal::Pointer<internal::ZssConfig_Data> zss_config;
  internal::InvocationPayload_Data payload;
  int32_t actuation_tab_id_$value;
  uint8_t padfinal_[4];

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

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

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

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

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

  UserType user_data_;
};

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

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

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  int32_t web_client_mode;
  uint8_t can_user_resize : 1;
  uint8_t pad1_[3];
  mojo::internal::Pointer<::gfx::mojom::internal::Size_Data> panelSize;
  mojo::internal::Pointer<::mojo_base::mojom::internal::TimeDelta_Data> resizeDuration;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::String_Data> mime_type;
  ::mojo_base::mojom::internal::BigBuffer_Data data;
  mojo::internal::Pointer<mojo::internal::String_Data> filename;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::String_Data> conversation_id;
  mojo::internal::Pointer<mojo::internal::String_Data> conversation_title;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  int32_t source;
  uint8_t tab_id_$flag : 1;
  uint8_t pad1_[3];
  mojo::internal::Pointer<mojo::internal::String_Data> name;
  int32_t tab_id_$value;
  uint8_t pad3_[4];
  mojo::internal::Pointer<::url::mojom::internal::Origin_Data> origin;
  mojo::internal::Pointer<::url::mojom::internal::Url_Data> frameUrl;
  mojo::internal::Pointer<mojo::internal::Array_Data<internal::AdditionalContextPart_Data>> parts;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  int32_t type;
  uint8_t pad0_[4];
  mojo::internal::Pointer<mojo::internal::String_Data> data;
  mojo::internal::Pointer<mojo::internal::Map_Data<mojo::internal::Pointer<mojo::internal::String_Data>, mojo::internal::Pointer<mojo::internal::String_Data>>> metadata;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<internal::TabData_Data> tab_data;
  mojo::internal::Pointer<internal::WebPageData_Data> web_page_data;
  mojo::internal::Pointer<internal::Screenshot_Data> viewport_screenshot;
  mojo::internal::Pointer<::mojo_base::mojom::internal::ProtoWrapper_Data> screenshot_info;
  mojo::internal::Pointer<internal::PdfDocumentData_Data> pdf_document_data;
  mojo::internal::Pointer<internal::AnnotatedPageData_Data> annotated_page_data;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<internal::DocumentData_Data> main_document;

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

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

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

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

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

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    WebPageData_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  DocumentData_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> origin;
  mojo::internal::Pointer<mojo::internal::String_Data> inner_text;
  uint8_t inner_text_truncated : 1;
  uint8_t padfinal_[7];

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

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

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

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

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

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    DocumentData_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  PdfDocumentData_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> origin;
  mojo::internal::Pointer<mojo::internal::Array_Data<uint8_t>> pdf_data;
  uint8_t pdf_size_limit_exceeded : 1;
  uint8_t padfinal_[7];

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  int32_t tab_id;
  int32_t window_id;
  mojo::internal::Pointer<::url::mojom::internal::Url_Data> url;
  mojo::internal::Pointer<mojo::internal::String_Data> title;
  mojo::internal::Pointer<::skia::mojom::internal::BitmapN32_Data> favicon;
  mojo::internal::Pointer<::url::mojom::internal::Url_Data> favicon_url;
  mojo::internal::Pointer<mojo::internal::String_Data> document_mime_type;
  uint8_t is_observable_$flag : 1;
  uint8_t is_observable_$value : 1;
  uint8_t is_media_active_$flag : 1;
  uint8_t is_media_active_$value : 1;
  uint8_t is_tab_content_captured_$flag : 1;
  uint8_t is_tab_content_captured_$value : 1;
  uint8_t is_active_in_window_$flag : 1;
  uint8_t is_active_in_window_$value : 1;
  uint8_t is_window_active_$flag : 1;
  uint8_t is_window_active_$value : 1;
  uint8_t pad16_[6];
  mojo::internal::Pointer<mojo::internal::Array_Data<int32_t>> lightweight_page_features;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<internal::TabData_Data> active_tab_data;
  mojo::internal::Pointer<mojo::internal::String_Data> no_focus_reason;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<::mojo_base::mojom::internal::ProtoWrapper_Data> annotated_page_content;
  mojo::internal::Pointer<::blink::mojom::internal::PageMetadata_Data> metadata;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::Array_Data<uint8_t>> data;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<::mojo_base::mojom::internal::UnguessableToken_Data> id;
  internal::CapturedRegion_Data region;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  int32_t tab_id;
  uint8_t pad0_[4];
  internal::CapturedRegion_Data region;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  uint32_t width_pixels;
  uint32_t height_pixels;
  mojo::internal::Pointer<mojo::internal::Array_Data<uint8_t>> data;
  mojo::internal::Pointer<mojo::internal::String_Data> mime_type;
  mojo::internal::Pointer<internal::ImageOriginAnnotations_Data> origin_annotations;
  int32_t encryption_scheme;
  uint8_t padfinal_[4];

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::String_Data> caption;
  mojo::internal::Pointer<::url::mojom::internal::Origin_Data> source_origin;
  mojo::internal::Pointer<::url::mojom::internal::Url_Data> url;
  mojo::internal::Pointer<mojo::internal::String_Data> mime_type;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  ::mojo_base::mojom::internal::BigBuffer_Data bytes;
  mojo::internal::Pointer<internal::ImageInfo_Data> image_info;

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

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

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

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

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

  UserType user_data_;
};

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

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

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

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

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

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

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

  UserType user_data_;
};

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

#pragma pack(pop)

}  // namespace internal

}  // glic::mojom

#endif  // CHROME_BROWSER_GLIC_HOST_GLIC_MOJOM_SHARED_INTERNAL_H_