#[allow(unused_imports)]
use super::*;
#[doc(hidden)]
impl serde::ser::Serialize for super::CheckError {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !wkt::internal::is_default(&self.code) {
state.serialize_entry("code", &self.code)?;
}
if !self.subject.is_empty() {
state.serialize_entry("subject", &self.subject)?;
}
if !self.detail.is_empty() {
state.serialize_entry("detail", &self.detail)?;
}
if self.status.is_some() {
state.serialize_entry("status", &self.status)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::Distribution {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !wkt::internal::is_default(&self.count) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry("count", &__With(&self.count))?;
}
if !wkt::internal::is_default(&self.mean) {
struct __With<'a>(&'a f64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::F64>::serialize(self.0, serializer)
}
}
state.serialize_entry("mean", &__With(&self.mean))?;
}
if !wkt::internal::is_default(&self.minimum) {
struct __With<'a>(&'a f64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::F64>::serialize(self.0, serializer)
}
}
state.serialize_entry("minimum", &__With(&self.minimum))?;
}
if !wkt::internal::is_default(&self.maximum) {
struct __With<'a>(&'a f64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::F64>::serialize(self.0, serializer)
}
}
state.serialize_entry("maximum", &__With(&self.maximum))?;
}
if !wkt::internal::is_default(&self.sum_of_squared_deviation) {
struct __With<'a>(&'a f64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::F64>::serialize(self.0, serializer)
}
}
state.serialize_entry(
"sumOfSquaredDeviation",
&__With(&self.sum_of_squared_deviation),
)?;
}
if !self.bucket_counts.is_empty() {
struct __With<'a>(&'a std::vec::Vec<i64>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::vec::Vec<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("bucketCounts", &__With(&self.bucket_counts))?;
}
if let Some(value) = self.linear_buckets() {
state.serialize_entry("linearBuckets", value)?;
}
if let Some(value) = self.exponential_buckets() {
state.serialize_entry("exponentialBuckets", value)?;
}
if let Some(value) = self.explicit_buckets() {
state.serialize_entry("explicitBuckets", value)?;
}
if !self.exemplars.is_empty() {
state.serialize_entry("exemplars", &self.exemplars)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::distribution::LinearBuckets {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !wkt::internal::is_default(&self.num_finite_buckets) {
struct __With<'a>(&'a i32);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
}
}
state.serialize_entry("numFiniteBuckets", &__With(&self.num_finite_buckets))?;
}
if !wkt::internal::is_default(&self.width) {
struct __With<'a>(&'a f64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::F64>::serialize(self.0, serializer)
}
}
state.serialize_entry("width", &__With(&self.width))?;
}
if !wkt::internal::is_default(&self.offset) {
struct __With<'a>(&'a f64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::F64>::serialize(self.0, serializer)
}
}
state.serialize_entry("offset", &__With(&self.offset))?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::distribution::ExponentialBuckets {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !wkt::internal::is_default(&self.num_finite_buckets) {
struct __With<'a>(&'a i32);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
}
}
state.serialize_entry("numFiniteBuckets", &__With(&self.num_finite_buckets))?;
}
if !wkt::internal::is_default(&self.growth_factor) {
struct __With<'a>(&'a f64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::F64>::serialize(self.0, serializer)
}
}
state.serialize_entry("growthFactor", &__With(&self.growth_factor))?;
}
if !wkt::internal::is_default(&self.scale) {
struct __With<'a>(&'a f64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::F64>::serialize(self.0, serializer)
}
}
state.serialize_entry("scale", &__With(&self.scale))?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::distribution::ExplicitBuckets {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.bounds.is_empty() {
struct __With<'a>(&'a std::vec::Vec<f64>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::vec::Vec<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("bounds", &__With(&self.bounds))?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::HttpRequest {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.request_method.is_empty() {
state.serialize_entry("requestMethod", &self.request_method)?;
}
if !self.request_url.is_empty() {
state.serialize_entry("requestUrl", &self.request_url)?;
}
if !wkt::internal::is_default(&self.request_size) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry("requestSize", &__With(&self.request_size))?;
}
if !wkt::internal::is_default(&self.status) {
struct __With<'a>(&'a i32);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
}
}
state.serialize_entry("status", &__With(&self.status))?;
}
if !wkt::internal::is_default(&self.response_size) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry("responseSize", &__With(&self.response_size))?;
}
if !self.user_agent.is_empty() {
state.serialize_entry("userAgent", &self.user_agent)?;
}
if !self.remote_ip.is_empty() {
state.serialize_entry("remoteIp", &self.remote_ip)?;
}
if !self.server_ip.is_empty() {
state.serialize_entry("serverIp", &self.server_ip)?;
}
if !self.referer.is_empty() {
state.serialize_entry("referer", &self.referer)?;
}
if self.latency.is_some() {
state.serialize_entry("latency", &self.latency)?;
}
if !wkt::internal::is_default(&self.cache_lookup) {
state.serialize_entry("cacheLookup", &self.cache_lookup)?;
}
if !wkt::internal::is_default(&self.cache_hit) {
state.serialize_entry("cacheHit", &self.cache_hit)?;
}
if !wkt::internal::is_default(&self.cache_validated_with_origin_server) {
state.serialize_entry(
"cacheValidatedWithOriginServer",
&self.cache_validated_with_origin_server,
)?;
}
if !wkt::internal::is_default(&self.cache_fill_bytes) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry("cacheFillBytes", &__With(&self.cache_fill_bytes))?;
}
if !self.protocol.is_empty() {
state.serialize_entry("protocol", &self.protocol)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::LogEntry {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.name.is_empty() {
state.serialize_entry("name", &self.name)?;
}
if self.timestamp.is_some() {
state.serialize_entry("timestamp", &self.timestamp)?;
}
if !wkt::internal::is_default(&self.severity) {
state.serialize_entry("severity", &self.severity)?;
}
if self.http_request.is_some() {
state.serialize_entry("httpRequest", &self.http_request)?;
}
if !self.trace.is_empty() {
state.serialize_entry("trace", &self.trace)?;
}
if !self.insert_id.is_empty() {
state.serialize_entry("insertId", &self.insert_id)?;
}
if !self.labels.is_empty() {
state.serialize_entry("labels", &self.labels)?;
}
if let Some(value) = self.proto_payload() {
state.serialize_entry("protoPayload", value)?;
}
if let Some(value) = self.text_payload() {
state.serialize_entry("textPayload", value)?;
}
if let Some(value) = self.struct_payload() {
state.serialize_entry("structPayload", value)?;
}
if self.operation.is_some() {
state.serialize_entry("operation", &self.operation)?;
}
if self.source_location.is_some() {
state.serialize_entry("sourceLocation", &self.source_location)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::LogEntryOperation {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.id.is_empty() {
state.serialize_entry("id", &self.id)?;
}
if !self.producer.is_empty() {
state.serialize_entry("producer", &self.producer)?;
}
if !wkt::internal::is_default(&self.first) {
state.serialize_entry("first", &self.first)?;
}
if !wkt::internal::is_default(&self.last) {
state.serialize_entry("last", &self.last)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::LogEntrySourceLocation {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.file.is_empty() {
state.serialize_entry("file", &self.file)?;
}
if !wkt::internal::is_default(&self.line) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry("line", &__With(&self.line))?;
}
if !self.function.is_empty() {
state.serialize_entry("function", &self.function)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::MetricValue {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.labels.is_empty() {
state.serialize_entry("labels", &self.labels)?;
}
if self.start_time.is_some() {
state.serialize_entry("startTime", &self.start_time)?;
}
if self.end_time.is_some() {
state.serialize_entry("endTime", &self.end_time)?;
}
if let Some(value) = self.bool_value() {
state.serialize_entry("boolValue", value)?;
}
if let Some(value) = self.int64_value() {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry("int64Value", &__With(value))?;
}
if let Some(value) = self.double_value() {
struct __With<'a>(&'a f64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::F64>::serialize(self.0, serializer)
}
}
state.serialize_entry("doubleValue", &__With(value))?;
}
if let Some(value) = self.string_value() {
state.serialize_entry("stringValue", value)?;
}
if let Some(value) = self.distribution_value() {
state.serialize_entry("distributionValue", value)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::MetricValueSet {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.metric_name.is_empty() {
state.serialize_entry("metricName", &self.metric_name)?;
}
if !self.metric_values.is_empty() {
state.serialize_entry("metricValues", &self.metric_values)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::Operation {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.operation_id.is_empty() {
state.serialize_entry("operationId", &self.operation_id)?;
}
if !self.operation_name.is_empty() {
state.serialize_entry("operationName", &self.operation_name)?;
}
if !self.consumer_id.is_empty() {
state.serialize_entry("consumerId", &self.consumer_id)?;
}
if self.start_time.is_some() {
state.serialize_entry("startTime", &self.start_time)?;
}
if self.end_time.is_some() {
state.serialize_entry("endTime", &self.end_time)?;
}
if !self.labels.is_empty() {
state.serialize_entry("labels", &self.labels)?;
}
if !self.metric_value_sets.is_empty() {
state.serialize_entry("metricValueSets", &self.metric_value_sets)?;
}
if !self.log_entries.is_empty() {
state.serialize_entry("logEntries", &self.log_entries)?;
}
if !wkt::internal::is_default(&self.importance) {
state.serialize_entry("importance", &self.importance)?;
}
if !self.extensions.is_empty() {
state.serialize_entry("extensions", &self.extensions)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::AllocateQuotaRequest {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.service_name.is_empty() {
state.serialize_entry("serviceName", &self.service_name)?;
}
if self.allocate_operation.is_some() {
state.serialize_entry("allocateOperation", &self.allocate_operation)?;
}
if !self.service_config_id.is_empty() {
state.serialize_entry("serviceConfigId", &self.service_config_id)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::QuotaOperation {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.operation_id.is_empty() {
state.serialize_entry("operationId", &self.operation_id)?;
}
if !self.method_name.is_empty() {
state.serialize_entry("methodName", &self.method_name)?;
}
if !self.consumer_id.is_empty() {
state.serialize_entry("consumerId", &self.consumer_id)?;
}
if !self.labels.is_empty() {
state.serialize_entry("labels", &self.labels)?;
}
if !self.quota_metrics.is_empty() {
state.serialize_entry("quotaMetrics", &self.quota_metrics)?;
}
if !wkt::internal::is_default(&self.quota_mode) {
state.serialize_entry("quotaMode", &self.quota_mode)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::AllocateQuotaResponse {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.operation_id.is_empty() {
state.serialize_entry("operationId", &self.operation_id)?;
}
if !self.allocate_errors.is_empty() {
state.serialize_entry("allocateErrors", &self.allocate_errors)?;
}
if !self.quota_metrics.is_empty() {
state.serialize_entry("quotaMetrics", &self.quota_metrics)?;
}
if !self.service_config_id.is_empty() {
state.serialize_entry("serviceConfigId", &self.service_config_id)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::QuotaError {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !wkt::internal::is_default(&self.code) {
state.serialize_entry("code", &self.code)?;
}
if !self.subject.is_empty() {
state.serialize_entry("subject", &self.subject)?;
}
if !self.description.is_empty() {
state.serialize_entry("description", &self.description)?;
}
if self.status.is_some() {
state.serialize_entry("status", &self.status)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::CheckRequest {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.service_name.is_empty() {
state.serialize_entry("serviceName", &self.service_name)?;
}
if self.operation.is_some() {
state.serialize_entry("operation", &self.operation)?;
}
if !self.service_config_id.is_empty() {
state.serialize_entry("serviceConfigId", &self.service_config_id)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::CheckResponse {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.operation_id.is_empty() {
state.serialize_entry("operationId", &self.operation_id)?;
}
if !self.check_errors.is_empty() {
state.serialize_entry("checkErrors", &self.check_errors)?;
}
if !self.service_config_id.is_empty() {
state.serialize_entry("serviceConfigId", &self.service_config_id)?;
}
if !self.service_rollout_id.is_empty() {
state.serialize_entry("serviceRolloutId", &self.service_rollout_id)?;
}
if self.check_info.is_some() {
state.serialize_entry("checkInfo", &self.check_info)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::check_response::CheckInfo {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.unused_arguments.is_empty() {
state.serialize_entry("unusedArguments", &self.unused_arguments)?;
}
if self.consumer_info.is_some() {
state.serialize_entry("consumerInfo", &self.consumer_info)?;
}
if !self.api_key_uid.is_empty() {
state.serialize_entry("apiKeyUid", &self.api_key_uid)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::check_response::ConsumerInfo {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !wkt::internal::is_default(&self.project_number) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry("projectNumber", &__With(&self.project_number))?;
}
if !wkt::internal::is_default(&self.r#type) {
state.serialize_entry("type", &self.r#type)?;
}
if !wkt::internal::is_default(&self.consumer_number) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry("consumerNumber", &__With(&self.consumer_number))?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::ReportRequest {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.service_name.is_empty() {
state.serialize_entry("serviceName", &self.service_name)?;
}
if !self.operations.is_empty() {
state.serialize_entry("operations", &self.operations)?;
}
if !self.service_config_id.is_empty() {
state.serialize_entry("serviceConfigId", &self.service_config_id)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::ReportResponse {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.report_errors.is_empty() {
state.serialize_entry("reportErrors", &self.report_errors)?;
}
if !self.service_config_id.is_empty() {
state.serialize_entry("serviceConfigId", &self.service_config_id)?;
}
if !self.service_rollout_id.is_empty() {
state.serialize_entry("serviceRolloutId", &self.service_rollout_id)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::report_response::ReportError {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.operation_id.is_empty() {
state.serialize_entry("operationId", &self.operation_id)?;
}
if self.status.is_some() {
state.serialize_entry("status", &self.status)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}