// Generated by the proto_extras plugin. DO NOT EDIT!
// source: components/enterprise/common/proto/connectors.proto

#include "components/enterprise/common/proto/connectors.to_value.h"



#include "base/base64.h"
#include "base/strings/string_number_conversions.h"
#include "base/values.h"
#include "components/enterprise/common/proto/connectors.pb.h"
#include "components/proto_extras/proto_extras_lib.h"
#include "components/safe_browsing/core/common/proto/csd.pb.h"
#include "components/safe_browsing/core/common/proto/csd.to_value.h"


namespace enterprise_connectors {
void MaybeToValue(const std::optional<ContentMetaData>& 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 ContentMetaData& message) {
  base::DictValue dict;
  ::proto_extras::SerializeUnknownFields(message, dict);
  if (message.has_url()) {
    dict.Set("url", (message.url()));
  }
  if (message.has_filename()) {
    dict.Set("filename", (message.filename()));
  }
  if (message.has_digest()) {
    dict.Set("digest", (message.digest()));
  }
  if (message.has_csd()) {
    dict.Set("csd", ::safe_browsing::ToValue(message.csd()));
  }
  if (message.has_email()) {
    dict.Set("email", (message.email()));
  }
  if (message.has_content_type()) {
    dict.Set("content_type", (message.content_type()));
  }
  if (message.has_source()) {
    dict.Set("source", (message.source()));
  }
  if (message.has_destination()) {
    dict.Set("destination", (message.destination()));
  }
  if (message.has_tab_title()) {
    dict.Set("tab_title", (message.tab_title()));
  }
  if (message.has_tab_url()) {
    dict.Set("tab_url", (message.tab_url()));
  }
  if (message.has_print_metadata()) {
    dict.Set("print_metadata", ::enterprise_connectors::ToValue(message.print_metadata()));
  }
  if (message.has_decryption_key()) {
    dict.Set("decryption_key", base::Base64Encode(message.decryption_key()));
  }
  if (message.has_copied_text_source()) {
    dict.Set("copied_text_source", ::enterprise_connectors::ToValue(message.copied_text_source()));
  }
  if (!message.referrer_chain().empty()) {
    base::ListValue list;
    for (const auto& value : message.referrer_chain()) {
      list.Append(::safe_browsing::ToValue(value));
    }
    dict.Set("referrer_chain", std::move(list));
  }
  if (message.has_content_area_account_email()) {
    dict.Set("content_area_account_email", (message.content_area_account_email()));
  }
  if (message.has_source_content_area_account_email()) {
    dict.Set("source_content_area_account_email", (message.source_content_area_account_email()));
  }
  if (!message.frame_url_chain().empty()) {
    base::ListValue list;
    for (const auto& value : message.frame_url_chain()) {
      list.Append((value));
    }
    dict.Set("frame_url_chain", std::move(list));
  }
  if (message.has_file_size()) {
    dict.Set("file_size", ::proto_extras::ToNumericTypeForValue(message.file_size()));
  }
  return base::Value(std::move(dict));
}
void MaybeToValue(const std::optional<ContentMetaData_PrintMetadata>& 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 ContentMetaData_PrintMetadata& message) {
  base::DictValue dict;
  ::proto_extras::SerializeUnknownFields(message, dict);
  if (message.has_printer_name()) {
    dict.Set("printer_name", (message.printer_name()));
  }
  if (message.has_printer_type()) {
    dict.Set("printer_type", ::enterprise_connectors::ContentMetaData_PrintMetadata_PrinterType_Name(message.printer_type()));
  }
  return base::Value(std::move(dict));
}
void MaybeToValue(const std::optional<ContentMetaData_CopiedTextSource>& 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 ContentMetaData_CopiedTextSource& message) {
  base::DictValue dict;
  ::proto_extras::SerializeUnknownFields(message, dict);
  if (message.has_url()) {
    dict.Set("url", (message.url()));
  }
  if (message.has_context()) {
    dict.Set("context", ::enterprise_connectors::ContentMetaData_CopiedTextSource_CopiedTextSourceType_Name(message.context()));
  }
  return base::Value(std::move(dict));
}
void MaybeToValue(const std::optional<ClientMetadata>& 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 ClientMetadata& message) {
  base::DictValue dict;
  ::proto_extras::SerializeUnknownFields(message, dict);
  if (message.has_browser()) {
    dict.Set("browser", ::enterprise_connectors::ToValue(message.browser()));
  }
  if (message.has_device()) {
    dict.Set("device", ::enterprise_connectors::ToValue(message.device()));
  }
  if (message.has_profile()) {
    dict.Set("profile", ::enterprise_connectors::ToValue(message.profile()));
  }
  if (message.has_is_chrome_os_managed_guest_session()) {
    dict.Set("is_chrome_os_managed_guest_session", static_cast<bool>(message.is_chrome_os_managed_guest_session()));
  }
  return base::Value(std::move(dict));
}
void MaybeToValue(const std::optional<ClientMetadata_Browser>& 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 ClientMetadata_Browser& message) {
  base::DictValue dict;
  ::proto_extras::SerializeUnknownFields(message, dict);
  if (message.has_browser_id()) {
    dict.Set("browser_id", (message.browser_id()));
  }
  if (message.has_user_agent()) {
    dict.Set("user_agent", (message.user_agent()));
  }
  if (message.has_chrome_version()) {
    dict.Set("chrome_version", (message.chrome_version()));
  }
  if (message.has_machine_user()) {
    dict.Set("machine_user", (message.machine_user()));
  }
  return base::Value(std::move(dict));
}
void MaybeToValue(const std::optional<ClientMetadata_Device>& 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 ClientMetadata_Device& message) {
  base::DictValue dict;
  ::proto_extras::SerializeUnknownFields(message, dict);
  if (message.has_dm_token()) {
    dict.Set("dm_token", (message.dm_token()));
  }
  if (message.has_client_id()) {
    dict.Set("client_id", (message.client_id()));
  }
  if (message.has_os_version()) {
    dict.Set("os_version", (message.os_version()));
  }
  if (message.has_os_platform()) {
    dict.Set("os_platform", (message.os_platform()));
  }
  if (message.has_name()) {
    dict.Set("name", (message.name()));
  }
  if (message.has_device_fqdn()) {
    dict.Set("device_fqdn", (message.device_fqdn()));
  }
  if (message.has_network_name()) {
    dict.Set("network_name", (message.network_name()));
  }
  return base::Value(std::move(dict));
}
void MaybeToValue(const std::optional<ClientMetadata_Profile>& 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 ClientMetadata_Profile& message) {
  base::DictValue dict;
  ::proto_extras::SerializeUnknownFields(message, dict);
  if (message.has_dm_token()) {
    dict.Set("dm_token", (message.dm_token()));
  }
  if (message.has_gaia_email()) {
    dict.Set("gaia_email", (message.gaia_email()));
  }
  if (message.has_profile_path()) {
    dict.Set("profile_path", (message.profile_path()));
  }
  if (message.has_profile_name()) {
    dict.Set("profile_name", (message.profile_name()));
  }
  if (message.has_client_id()) {
    dict.Set("client_id", (message.client_id()));
  }
  return base::Value(std::move(dict));
}
void MaybeToValue(const std::optional<ContentAnalysisRequest>& 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 ContentAnalysisRequest& message) {
  base::DictValue dict;
  ::proto_extras::SerializeUnknownFields(message, dict);
  if (message.has_device_token()) {
    dict.Set("device_token", (message.device_token()));
  }
  if (message.has_request_token()) {
    dict.Set("request_token", (message.request_token()));
  }
  if (message.has_analysis_connector()) {
    dict.Set("analysis_connector", ::enterprise_connectors::AnalysisConnector_Name(message.analysis_connector()));
  }
  if (message.has_request_data()) {
    dict.Set("request_data", ::enterprise_connectors::ToValue(message.request_data()));
  }
  if (!message.tags().empty()) {
    base::ListValue list;
    for (const auto& value : message.tags()) {
      list.Append((value));
    }
    dict.Set("tags", std::move(list));
  }
  if (message.has_client_metadata()) {
    dict.Set("client_metadata", ::enterprise_connectors::ToValue(message.client_metadata()));
  }
  if (message.has_text_content()) {
    dict.Set("text_content", (message.text_content()));
  }
  if (message.has_file_path()) {
    dict.Set("file_path", (message.file_path()));
  }
  if (message.has_expires_at()) {
    dict.Set("expires_at", ::proto_extras::ToNumericTypeForValue(message.expires_at()));
  }
  if (message.has_user_action_id()) {
    dict.Set("user_action_id", (message.user_action_id()));
  }
  if (message.has_user_action_requests_count()) {
    dict.Set("user_action_requests_count", ::proto_extras::ToNumericTypeForValue(message.user_action_requests_count()));
  }
  if (message.has_reason()) {
    dict.Set("reason", ::enterprise_connectors::ContentAnalysisRequest_Reason_Name(message.reason()));
  }
  if (message.has_blocking()) {
    dict.Set("blocking", static_cast<bool>(message.blocking()));
  }
  if (!message.local_ips().empty()) {
    base::ListValue list;
    for (const auto& value : message.local_ips()) {
      list.Append((value));
    }
    dict.Set("local_ips", std::move(list));
  }
  if (message.has_is_content_encrypted()) {
    dict.Set("is_content_encrypted", static_cast<bool>(message.is_content_encrypted()));
  }
  if (message.has_content_hash_in_final_call()) {
    dict.Set("content_hash_in_final_call", static_cast<bool>(message.content_hash_in_final_call()));
  }
  if (message.has_is_mobile()) {
    dict.Set("is_mobile", static_cast<bool>(message.is_mobile()));
  }
  return base::Value(std::move(dict));
}
void MaybeToValue(const std::optional<ContentAnalysisResponse>& 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 ContentAnalysisResponse& message) {
  base::DictValue dict;
  ::proto_extras::SerializeUnknownFields(message, dict);
  if (message.has_request_token()) {
    dict.Set("request_token", (message.request_token()));
  }
  if (!message.results().empty()) {
    base::ListValue list;
    for (const auto& value : message.results()) {
      list.Append(::enterprise_connectors::ToValue(value));
    }
    dict.Set("results", std::move(list));
  }
  return base::Value(std::move(dict));
}
void MaybeToValue(const std::optional<ContentAnalysisResponse_Result>& 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 ContentAnalysisResponse_Result& message) {
  base::DictValue dict;
  ::proto_extras::SerializeUnknownFields(message, dict);
  if (message.has_tag()) {
    dict.Set("tag", (message.tag()));
  }
  if (message.has_status()) {
    dict.Set("status", ::enterprise_connectors::ContentAnalysisResponse_Result_Status_Name(message.status()));
  }
  if (!message.triggered_rules().empty()) {
    base::ListValue list;
    for (const auto& value : message.triggered_rules()) {
      list.Append(::enterprise_connectors::ToValue(value));
    }
    dict.Set("triggered_rules", std::move(list));
  }
  if (message.has_custom_message()) {
    dict.Set("custom_message", ::enterprise_connectors::ToValue(message.custom_message()));
  }
  if (message.has_status_error_message()) {
    dict.Set("status_error_message", ::enterprise_connectors::ContentAnalysisResponse_Result_StatusErrorMessage_Name(message.status_error_message()));
  }
  return base::Value(std::move(dict));
}
void MaybeToValue(const std::optional<ContentAnalysisResponse_Result_CustomMessage>& 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 ContentAnalysisResponse_Result_CustomMessage& message) {
  base::DictValue dict;
  ::proto_extras::SerializeUnknownFields(message, dict);
  if (message.has_learn_more_url()) {
    dict.Set("learn_more_url", (message.learn_more_url()));
  }
  if (message.has_message()) {
    dict.Set("message", (message.message()));
  }
  return base::Value(std::move(dict));
}
void MaybeToValue(const std::optional<ContentAnalysisResponse_Result_TriggeredRule>& 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 ContentAnalysisResponse_Result_TriggeredRule& message) {
  base::DictValue dict;
  ::proto_extras::SerializeUnknownFields(message, dict);
  if (message.has_action()) {
    dict.Set("action", ::enterprise_connectors::ContentAnalysisResponse_Result_TriggeredRule_Action_Name(message.action()));
  }
  if (message.has_rule_name()) {
    dict.Set("rule_name", (message.rule_name()));
  }
  if (message.has_rule_id()) {
    dict.Set("rule_id", (message.rule_id()));
  }
  if (message.has_custom_message()) {
    dict.Set("custom_message", ::enterprise_connectors::ToValue(message.custom_message()));
  }
  if (message.has_url_category()) {
    dict.Set("url_category", (message.url_category()));
  }
  if (message.has_custom_rule_message()) {
    dict.Set("custom_rule_message", ::enterprise_connectors::ToValue(message.custom_rule_message()));
  }
  if (message.has_force_save_to_cloud_destination()) {
    dict.Set("force_save_to_cloud_destination", ::enterprise_connectors::ContentAnalysisResponse_Result_TriggeredRule_ForceSaveToCloudDestination_Name(message.force_save_to_cloud_destination()));
  }
  return base::Value(std::move(dict));
}
void MaybeToValue(const std::optional<ContentAnalysisResponse_Result_TriggeredRule_CustomRuleMessageSegment>& 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 ContentAnalysisResponse_Result_TriggeredRule_CustomRuleMessageSegment& message) {
  base::DictValue dict;
  ::proto_extras::SerializeUnknownFields(message, dict);
  if (message.has_text()) {
    dict.Set("text", (message.text()));
  }
  if (message.has_link()) {
    dict.Set("link", (message.link()));
  }
  return base::Value(std::move(dict));
}
void MaybeToValue(const std::optional<ContentAnalysisResponse_Result_TriggeredRule_CustomRuleMessage>& 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 ContentAnalysisResponse_Result_TriggeredRule_CustomRuleMessage& message) {
  base::DictValue dict;
  ::proto_extras::SerializeUnknownFields(message, dict);
  if (!message.message_segments().empty()) {
    base::ListValue list;
    for (const auto& value : message.message_segments()) {
      list.Append(::enterprise_connectors::ToValue(value));
    }
    dict.Set("message_segments", std::move(list));
  }
  return base::Value(std::move(dict));
}
void MaybeToValue(const std::optional<ContentAnalysisAcknowledgement>& 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 ContentAnalysisAcknowledgement& message) {
  base::DictValue dict;
  ::proto_extras::SerializeUnknownFields(message, dict);
  if (message.has_request_token()) {
    dict.Set("request_token", (message.request_token()));
  }
  if (message.has_status()) {
    dict.Set("status", ::enterprise_connectors::ContentAnalysisAcknowledgement_Status_Name(message.status()));
  }
  if (message.has_final_action()) {
    dict.Set("final_action", ::enterprise_connectors::ContentAnalysisAcknowledgement_FinalAction_Name(message.final_action()));
  }
  return base::Value(std::move(dict));
}
}  // namespace enterprise_connectors