// components/omnibox/composebox/composebox_query.mojom-shared.cc is auto generated by mojom_bindings_generator.py, do not edit

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

#include "components/omnibox/composebox/composebox_query.mojom-shared.h"
#include <ostream>
#include <utility>
#include "base/strings/stringprintf.h"
#include "mojo/public/cpp/bindings/lib/validate_params.h"
#include "mojo/public/cpp/bindings/lib/validation_errors.h"
#include "mojo/public/cpp/bindings/lib/validation_util.h"
#include "third_party/perfetto/include/perfetto/tracing/traced_value.h"

#include "components/omnibox/composebox/composebox_query.mojom-params-data.h"
namespace composebox_query {
namespace mojom {

NOINLINE static const char* ContextUploadStatusToStringHelper(ContextUploadStatus value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case ContextUploadStatus::kNotUploaded:
      return "kNotUploaded";
    case ContextUploadStatus::kProcessing:
      return "kProcessing";
    case ContextUploadStatus::kValidationFailed:
      return "kValidationFailed";
    case ContextUploadStatus::kUploadStarted:
      return "kUploadStarted";
    case ContextUploadStatus::kUploadSuccessful:
      return "kUploadSuccessful";
    case ContextUploadStatus::kUploadFailed:
      return "kUploadFailed";
    case ContextUploadStatus::kUploadExpired:
      return "kUploadExpired";
    case ContextUploadStatus::kProcessingSuggestSignalsReady:
      return "kProcessingSuggestSignalsReady";
    case ContextUploadStatus::kUploadReplaced:
      return "kUploadReplaced";
    default:
      return nullptr;
  }
}

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

std::ostream& operator<<(std::ostream& os, ContextUploadStatus value) {
  return os << ContextUploadStatusToString(value);
}

NOINLINE static const char* ContextUploadErrorTypeToStringHelper(ContextUploadErrorType value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case ContextUploadErrorType::kUnknown:
      return "kUnknown";
    case ContextUploadErrorType::kBrowserProcessingError:
      return "kBrowserProcessingError";
    case ContextUploadErrorType::kNetworkError:
      return "kNetworkError";
    case ContextUploadErrorType::kServerError:
      return "kServerError";
    case ContextUploadErrorType::kServerSizeLimitExceeded:
      return "kServerSizeLimitExceeded";
    case ContextUploadErrorType::kAborted:
      return "kAborted";
    case ContextUploadErrorType::kImageProcessingError:
      return "kImageProcessingError";
    case ContextUploadErrorType::kBrowserProcessingFileTooLargeError:
      return "kBrowserProcessingFileTooLargeError";
    case ContextUploadErrorType::kBrowserProcessingFileEmptyError:
      return "kBrowserProcessingFileEmptyError";
    case ContextUploadErrorType::kBrowserProcessingMaxFilesExceededError:
      return "kBrowserProcessingMaxFilesExceededError";
    case ContextUploadErrorType::kBrowserProcessingUnsupportedFileTypeError:
      return "kBrowserProcessingUnsupportedFileTypeError";
    case ContextUploadErrorType::kBrowserProcessingFileUploadNotAllowedError:
      return "kBrowserProcessingFileUploadNotAllowedError";
    case ContextUploadErrorType::kBrowserProcessingMaxImagesExceededError:
      return "kBrowserProcessingMaxImagesExceededError";
    case ContextUploadErrorType::kBrowserProcessingMaxPdfsExceededError:
      return "kBrowserProcessingMaxPdfsExceededError";
    default:
      return nullptr;
  }
}

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

std::ostream& operator<<(std::ostream& os, ContextUploadErrorType value) {
  return os << ContextUploadErrorTypeToString(value);
}

NOINLINE static const char* ModelModeToStringHelper(ModelMode value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case ModelMode::kUnspecified:
      return "kUnspecified";
    case ModelMode::kGeminiRegular:
      return "kGeminiRegular";
    case ModelMode::kGeminiPro:
      return "kGeminiPro";
    case ModelMode::kGeminiProAutoroute:
      return "kGeminiProAutoroute";
    case ModelMode::kGeminiProNoGenUi:
      return "kGeminiProNoGenUi";
    case ModelMode::kGeminiFlashLatest:
      return "kGeminiFlashLatest";
    case ModelMode::kGeminiProLatest:
      return "kGeminiProLatest";
    case ModelMode::kGeminiPreview:
      return "kGeminiPreview";
    default:
      return nullptr;
  }
}

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

std::ostream& operator<<(std::ostream& os, ModelMode value) {
  return os << ModelModeToString(value);
}

NOINLINE static const char* ToolModeToStringHelper(ToolMode value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case ToolMode::kUnspecified:
      return "kUnspecified";
    case ToolMode::kDeepSearch:
      return "kDeepSearch";
    case ToolMode::kCanvas:
      return "kCanvas";
    case ToolMode::kGeminiPro:
      return "kGeminiPro";
    case ToolMode::kImageGen:
      return "kImageGen";
    case ToolMode::kDeepBrowse:
      return "kDeepBrowse";
    case ToolMode::kImageGenSelfie:
      return "kImageGenSelfie";
    case ToolMode::kImageGenUpload:
      return "kImageGenUpload";
    case ToolMode::kDisableSuggest:
      return "kDisableSuggest";
    case ToolMode::kAim:
      return "kAim";
    case ToolMode::kAimGenPrompt:
      return "kAimGenPrompt";
    case ToolMode::kAgentTask:
      return "kAgentTask";
    default:
      return nullptr;
  }
}

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

std::ostream& operator<<(std::ostream& os, ToolMode value) {
  return os << ToolModeToString(value);
}

NOINLINE static const char* InputTypeToStringHelper(InputType value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case InputType::kUnspecified:
      return "kUnspecified";
    case InputType::kLensImage:
      return "kLensImage";
    case InputType::kLensFile:
      return "kLensFile";
    case InputType::kBrowserTab:
      return "kBrowserTab";
    case InputType::kDrive:
      return "kDrive";
    default:
      return nullptr;
  }
}

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

std::ostream& operator<<(std::ostream& os, InputType value) {
  return os << InputTypeToString(value);
}

namespace internal {


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

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

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

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

  return true;
}

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


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

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


  if (!::composebox_query::mojom::internal::InputType_Data
        ::Validate(object->input_type, validation_context))
    return false;

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

  return true;
}

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


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

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


  if (!::composebox_query::mojom::internal::ToolMode_Data
        ::Validate(object->tool, validation_context))
    return false;

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

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

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

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

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

  return true;
}

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


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

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


  if (!::composebox_query::mojom::internal::ModelMode_Data
        ::Validate(object->model, validation_context))
    return false;

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

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

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

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

  return true;
}

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


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

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

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

  return true;
}

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


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

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

  if (!mojo::internal::ValidatePointerNonNullable(
          object->allowed_models, 1, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& allowed_models_validate_params =
      mojo::internal::GetArrayOfEnumsValidator<0, false, ::composebox_query::mojom::internal::ModelMode_Data::Validate>();
  if (!mojo::internal::ValidateContainer(object->allowed_models, validation_context,
                                         &allowed_models_validate_params)) {
    return false;
  }

  if (!mojo::internal::ValidatePointerNonNullable(
          object->allowed_tools, 2, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& allowed_tools_validate_params =
      mojo::internal::GetArrayOfEnumsValidator<0, false, ::composebox_query::mojom::internal::ToolMode_Data::Validate>();
  if (!mojo::internal::ValidateContainer(object->allowed_tools, validation_context,
                                         &allowed_tools_validate_params)) {
    return false;
  }

  if (!mojo::internal::ValidatePointerNonNullable(
          object->allowed_input_types, 3, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& allowed_input_types_validate_params =
      mojo::internal::GetArrayOfEnumsValidator<0, false, ::composebox_query::mojom::internal::InputType_Data::Validate>();
  if (!mojo::internal::ValidateContainer(object->allowed_input_types, validation_context,
                                         &allowed_input_types_validate_params)) {
    return false;
  }


  if (!::composebox_query::mojom::internal::ModelMode_Data
        ::Validate(object->active_model, validation_context))
    return false;


  if (!::composebox_query::mojom::internal::ToolMode_Data
        ::Validate(object->active_tool, validation_context))
    return false;

  if (!mojo::internal::ValidatePointerNonNullable(
          object->disabled_models, 6, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& disabled_models_validate_params =
      mojo::internal::GetArrayOfEnumsValidator<0, false, ::composebox_query::mojom::internal::ModelMode_Data::Validate>();
  if (!mojo::internal::ValidateContainer(object->disabled_models, validation_context,
                                         &disabled_models_validate_params)) {
    return false;
  }

  if (!mojo::internal::ValidatePointerNonNullable(
          object->disabled_tools, 7, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& disabled_tools_validate_params =
      mojo::internal::GetArrayOfEnumsValidator<0, false, ::composebox_query::mojom::internal::ToolMode_Data::Validate>();
  if (!mojo::internal::ValidateContainer(object->disabled_tools, validation_context,
                                         &disabled_tools_validate_params)) {
    return false;
  }

  if (!mojo::internal::ValidatePointerNonNullable(
          object->disabled_input_types, 8, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& disabled_input_types_validate_params =
      mojo::internal::GetArrayOfEnumsValidator<0, false, ::composebox_query::mojom::internal::InputType_Data::Validate>();
  if (!mojo::internal::ValidateContainer(object->disabled_input_types, validation_context,
                                         &disabled_input_types_validate_params)) {
    return false;
  }

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

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

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

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

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

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

  if (!mojo::internal::ValidatePointerNonNullable(
          object->max_inputs_by_type, 15, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& max_inputs_by_type_validate_params =
      mojo::internal::GetMapValidator<*&mojo::internal::GetArrayOfEnumsValidator<0, false, ::composebox_query::mojom::internal::InputType_Data::Validate>(), *&mojo::internal::GetArrayValidator<0, false, nullptr>()>();
  if (!mojo::internal::ValidateContainer(object->max_inputs_by_type, validation_context,
                                         &max_inputs_by_type_validate_params)) {
    return false;
  }

  return true;
}

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

}  // namespace internal
}  // namespace mojom
}  // namespace composebox_query

namespace perfetto {

// static
void TraceFormatTraits<::composebox_query::mojom::ContextUploadStatus>::WriteIntoTrace(
   perfetto::TracedValue context, ::composebox_query::mojom::ContextUploadStatus value) {
  return std::move(context).WriteString(::composebox_query::mojom::ContextUploadStatusToString(value));
}

} // namespace perfetto

namespace perfetto {

// static
void TraceFormatTraits<::composebox_query::mojom::ContextUploadErrorType>::WriteIntoTrace(
   perfetto::TracedValue context, ::composebox_query::mojom::ContextUploadErrorType value) {
  return std::move(context).WriteString(::composebox_query::mojom::ContextUploadErrorTypeToString(value));
}

} // namespace perfetto

namespace perfetto {

// static
void TraceFormatTraits<::composebox_query::mojom::ModelMode>::WriteIntoTrace(
   perfetto::TracedValue context, ::composebox_query::mojom::ModelMode value) {
  return std::move(context).WriteString(::composebox_query::mojom::ModelModeToString(value));
}

} // namespace perfetto

namespace perfetto {

// static
void TraceFormatTraits<::composebox_query::mojom::ToolMode>::WriteIntoTrace(
   perfetto::TracedValue context, ::composebox_query::mojom::ToolMode value) {
  return std::move(context).WriteString(::composebox_query::mojom::ToolModeToString(value));
}

} // namespace perfetto

namespace perfetto {

// static
void TraceFormatTraits<::composebox_query::mojom::InputType>::WriteIntoTrace(
   perfetto::TracedValue context, ::composebox_query::mojom::InputType value) {
  return std::move(context).WriteString(::composebox_query::mojom::InputTypeToString(value));
}

} // namespace perfetto