// Generated by the proto_extras plugin. DO NOT EDIT!
// source: components/optimization_guide/proto/model_quality_metadata.proto

#include "components/optimization_guide/proto/model_quality_metadata.to_value.h"



#include "base/base64.h"
#include "base/strings/string_number_conversions.h"
#include "base/values.h"
#include "components/optimization_guide/proto/model_execution.pb.h"
#include "components/optimization_guide/proto/model_execution.to_value.h"
#include "components/optimization_guide/proto/model_quality_metadata.pb.h"
#include "components/optimization_guide/proto/on_device_base_model_metadata.pb.h"
#include "components/optimization_guide/proto/on_device_base_model_metadata.to_value.h"
#include "components/proto_extras/proto_extras_lib.h"
#include "third_party/metrics_proto/system_profile.pb.h"
#include "third_party/metrics_proto/system_profile.to_value.h"


namespace optimization_guide {
namespace proto {
void MaybeToValue(const std::optional<LoggingMetadata>& opt_message,
                    std::string_view name,
                    base::DictValue& output_dictionary) {
  if (!opt_message.has_value()) {
    return;
  }
  output_dictionary.Set(name, ToValue(*opt_message));
}
base::Value ToValue(const LoggingMetadata& message) {
  base::DictValue dict;
  ::proto_extras::SerializeUnknownFields(message, dict);
  if (message.has_system_profile()) {
    dict.Set("system_profile", ::metrics::ToValue(message.system_profile()));
  }
  if (message.has_on_device_system_profile()) {
    dict.Set("on_device_system_profile", ::optimization_guide::proto::ToValue(message.on_device_system_profile()));
  }
  dict.Set("client_id", ::proto_extras::ToNumericTypeForValue(message.client_id()));
  dict.Set("is_likely_dogfood_client", static_cast<bool>(message.is_likely_dogfood_client()));
  return base::Value(std::move(dict));
}
void MaybeToValue(const std::optional<OnDeviceSystemProfile>& opt_message,
                    std::string_view name,
                    base::DictValue& output_dictionary) {
  if (!opt_message.has_value()) {
    return;
  }
  output_dictionary.Set(name, ToValue(*opt_message));
}
base::Value ToValue(const OnDeviceSystemProfile& message) {
  base::DictValue dict;
  ::proto_extras::SerializeUnknownFields(message, dict);
  dict.Set("performance_class", ::optimization_guide::proto::PerformanceClass_Name(message.performance_class()));
  return base::Value(std::move(dict));
}
void MaybeToValue(const std::optional<ModelExecutionInfo>& opt_message,
                    std::string_view name,
                    base::DictValue& output_dictionary) {
  if (!opt_message.has_value()) {
    return;
  }
  output_dictionary.Set(name, ToValue(*opt_message));
}
base::Value ToValue(const ModelExecutionInfo& message) {
  base::DictValue dict;
  ::proto_extras::SerializeUnknownFields(message, dict);
  if (message.has_on_device_model_execution_info()) {
    dict.Set("on_device_model_execution_info", ::optimization_guide::proto::ToValue(message.on_device_model_execution_info()));
  }
  if (message.has_error_response()) {
    dict.Set("error_response", ::optimization_guide::proto::ToValue(message.error_response()));
  }
  dict.Set("model_execution_error_enum", ::proto_extras::ToNumericTypeForValue(message.model_execution_error_enum()));
  if (!message.execution_id().empty()) {
    dict.Set("execution_id", (message.execution_id()));
  }
  return base::Value(std::move(dict));
}
void MaybeToValue(const std::optional<OnDeviceModelExecutionInfo>& opt_message,
                    std::string_view name,
                    base::DictValue& output_dictionary) {
  if (!opt_message.has_value()) {
    return;
  }
  output_dictionary.Set(name, ToValue(*opt_message));
}
base::Value ToValue(const OnDeviceModelExecutionInfo& message) {
  base::DictValue dict;
  ::proto_extras::SerializeUnknownFields(message, dict);
  if (!message.execution_infos().empty()) {
    base::ListValue list;
    for (const auto& value : message.execution_infos()) {
      list.Append(::optimization_guide::proto::ToValue(value));
    }
    dict.Set("execution_infos", std::move(list));
  }
  if (message.has_model_versions()) {
    dict.Set("model_versions", ::optimization_guide::proto::ToValue(message.model_versions()));
  }
  return base::Value(std::move(dict));
}
void MaybeToValue(const std::optional<OnDeviceModelVersions>& opt_message,
                    std::string_view name,
                    base::DictValue& output_dictionary) {
  if (!opt_message.has_value()) {
    return;
  }
  output_dictionary.Set(name, ToValue(*opt_message));
}
base::Value ToValue(const OnDeviceModelVersions& message) {
  base::DictValue dict;
  ::proto_extras::SerializeUnknownFields(message, dict);
  if (message.has_on_device_model_service_version()) {
    dict.Set("on_device_model_service_version", ::optimization_guide::proto::ToValue(message.on_device_model_service_version()));
  }
  dict.Set("text_safety_model_version", ::proto_extras::ToNumericTypeForValue(message.text_safety_model_version()));
  return base::Value(std::move(dict));
}
void MaybeToValue(const std::optional<OnDeviceModelServiceVersion>& opt_message,
                    std::string_view name,
                    base::DictValue& output_dictionary) {
  if (!opt_message.has_value()) {
    return;
  }
  output_dictionary.Set(name, ToValue(*opt_message));
}
base::Value ToValue(const OnDeviceModelServiceVersion& message) {
  base::DictValue dict;
  ::proto_extras::SerializeUnknownFields(message, dict);
  if (!message.component_version().empty()) {
    dict.Set("component_version", (message.component_version()));
  }
  if (message.has_on_device_base_model_metadata()) {
    dict.Set("on_device_base_model_metadata", ::optimization_guide::proto::ToValue(message.on_device_base_model_metadata()));
  }
  dict.Set("model_adaptation_version", ::proto_extras::ToNumericTypeForValue(message.model_adaptation_version()));
  return base::Value(std::move(dict));
}
void MaybeToValue(const std::optional<InternalOnDeviceModelExecutionInfo>& opt_message,
                    std::string_view name,
                    base::DictValue& output_dictionary) {
  if (!opt_message.has_value()) {
    return;
  }
  output_dictionary.Set(name, ToValue(*opt_message));
}
base::Value ToValue(const InternalOnDeviceModelExecutionInfo& message) {
  base::DictValue dict;
  ::proto_extras::SerializeUnknownFields(message, dict);
  if (message.has_request()) {
    dict.Set("request", ::optimization_guide::proto::ToValue(message.request()));
  }
  if (message.has_response()) {
    dict.Set("response", ::optimization_guide::proto::ToValue(message.response()));
  }
  return base::Value(std::move(dict));
}
void MaybeToValue(const std::optional<InternalOnDeviceRequest>& opt_message,
                    std::string_view name,
                    base::DictValue& output_dictionary) {
  if (!opt_message.has_value()) {
    return;
  }
  output_dictionary.Set(name, ToValue(*opt_message));
}
base::Value ToValue(const InternalOnDeviceRequest& message) {
  base::DictValue dict;
  ::proto_extras::SerializeUnknownFields(message, dict);
  if (message.has_on_device_model_service_request()) {
    dict.Set("on_device_model_service_request", ::optimization_guide::proto::ToValue(message.on_device_model_service_request()));
  }
  if (message.has_text_safety_model_request()) {
    dict.Set("text_safety_model_request", ::optimization_guide::proto::ToValue(message.text_safety_model_request()));
  }
  return base::Value(std::move(dict));
}
void MaybeToValue(const std::optional<InternalOnDeviceResponse>& opt_message,
                    std::string_view name,
                    base::DictValue& output_dictionary) {
  if (!opt_message.has_value()) {
    return;
  }
  output_dictionary.Set(name, ToValue(*opt_message));
}
base::Value ToValue(const InternalOnDeviceResponse& message) {
  base::DictValue dict;
  ::proto_extras::SerializeUnknownFields(message, dict);
  if (message.has_on_device_model_service_response()) {
    dict.Set("on_device_model_service_response", ::optimization_guide::proto::ToValue(message.on_device_model_service_response()));
  }
  if (message.has_text_safety_model_response()) {
    dict.Set("text_safety_model_response", ::optimization_guide::proto::ToValue(message.text_safety_model_response()));
  }
  return base::Value(std::move(dict));
}
void MaybeToValue(const std::optional<OnDeviceModelServiceRequest>& opt_message,
                    std::string_view name,
                    base::DictValue& output_dictionary) {
  if (!opt_message.has_value()) {
    return;
  }
  output_dictionary.Set(name, ToValue(*opt_message));
}
base::Value ToValue(const OnDeviceModelServiceRequest& message) {
  base::DictValue dict;
  ::proto_extras::SerializeUnknownFields(message, dict);
  if (!message.input_context_string().empty()) {
    dict.Set("input_context_string", (message.input_context_string()));
  }
  dict.Set("input_context_num_tokens_processed", ::proto_extras::ToNumericTypeForValue(message.input_context_num_tokens_processed()));
  if (!message.execution_string().empty()) {
    dict.Set("execution_string", (message.execution_string()));
  }
  dict.Set("execution_num_tokens_processed", ::proto_extras::ToNumericTypeForValue(message.execution_num_tokens_processed()));
  dict.Set("time_from_input_context_processed_to_request_initiated_millis", ::proto_extras::ToNumericTypeForValue(message.time_from_input_context_processed_to_request_initiated_millis()));
  return base::Value(std::move(dict));
}
void MaybeToValue(const std::optional<OnDeviceModelServiceResponse>& opt_message,
                    std::string_view name,
                    base::DictValue& output_dictionary) {
  if (!opt_message.has_value()) {
    return;
  }
  output_dictionary.Set(name, ToValue(*opt_message));
}
base::Value ToValue(const OnDeviceModelServiceResponse& message) {
  base::DictValue dict;
  ::proto_extras::SerializeUnknownFields(message, dict);
  if (!message.output_string().empty()) {
    dict.Set("output_string", (message.output_string()));
  }
  dict.Set("time_to_first_response_millis", ::proto_extras::ToNumericTypeForValue(message.time_to_first_response_millis()));
  dict.Set("time_to_completion_millis", ::proto_extras::ToNumericTypeForValue(message.time_to_completion_millis()));
  dict.Set("status", ::optimization_guide::proto::OnDeviceModelServiceResponseStatus_Name(message.status()));
  dict.Set("has_repeats", static_cast<bool>(message.has_repeats()));
  return base::Value(std::move(dict));
}
void MaybeToValue(const std::optional<TextSafetyModelRequest>& opt_message,
                    std::string_view name,
                    base::DictValue& output_dictionary) {
  if (!opt_message.has_value()) {
    return;
  }
  output_dictionary.Set(name, ToValue(*opt_message));
}
base::Value ToValue(const TextSafetyModelRequest& message) {
  base::DictValue dict;
  ::proto_extras::SerializeUnknownFields(message, dict);
  if (!message.text().empty()) {
    dict.Set("text", (message.text()));
  }
  if (!message.url().empty()) {
    dict.Set("url", (message.url()));
  }
  return base::Value(std::move(dict));
}
void MaybeToValue(const std::optional<TextSafetyModelResponse>& opt_message,
                    std::string_view name,
                    base::DictValue& output_dictionary) {
  if (!opt_message.has_value()) {
    return;
  }
  output_dictionary.Set(name, ToValue(*opt_message));
}
base::Value ToValue(const TextSafetyModelResponse& message) {
  base::DictValue dict;
  ::proto_extras::SerializeUnknownFields(message, dict);
  if (!message.scores().empty()) {
    base::ListValue list;
    for (const auto& value : message.scores()) {
      list.Append(static_cast<double>(value));
    }
    dict.Set("scores", std::move(list));
  }
  dict.Set("is_unsafe", static_cast<bool>(message.is_unsafe()));
  if (!message.server_execution_id().empty()) {
    dict.Set("server_execution_id", (message.server_execution_id()));
  }
  if (!message.language_code().empty()) {
    dict.Set("language_code", (message.language_code()));
  }
  dict.Set("language_confidence", static_cast<double>(message.language_confidence()));
  return base::Value(std::move(dict));
}
}  // namespace proto
}  // namespace optimization_guide