#[allow(unused_imports)]
use super::*;
#[doc(hidden)]
impl serde::ser::Serialize for super::ListChildAccountsRequest {
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.parent.is_empty() {
state.serialize_entry("parent", &self.parent)?;
}
if self.label_id.is_some() {
struct __With<'a>(&'a std::option::Option<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::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("labelId", &__With(&self.label_id))?;
}
if self.full_name.is_some() {
state.serialize_entry("fullName", &self.full_name)?;
}
if !wkt::internal::is_default(&self.page_size) {
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("pageSize", &__With(&self.page_size))?;
}
if !self.page_token.is_empty() {
state.serialize_entry("pageToken", &self.page_token)?;
}
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::ListChildAccountsResponse {
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.accounts.is_empty() {
state.serialize_entry("accounts", &self.accounts)?;
}
if !self.next_page_token.is_empty() {
state.serialize_entry("nextPageToken", &self.next_page_token)?;
}
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::GetAccountRequest {
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.parent.is_some() {
state.serialize_entry("parent", &self.parent)?;
}
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::UpdateAccountLabelsRequest {
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.label_ids.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("labelIds", &__With(&self.label_ids))?;
}
if self.parent.is_some() {
state.serialize_entry("parent", &self.parent)?;
}
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::Account {
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.full_name.is_empty() {
state.serialize_entry("fullName", &self.full_name)?;
}
if self.display_name.is_some() {
state.serialize_entry("displayName", &self.display_name)?;
}
if self.homepage_uri.is_some() {
state.serialize_entry("homepageUri", &self.homepage_uri)?;
}
if self.parent.is_some() {
state.serialize_entry("parent", &self.parent)?;
}
if !self.label_ids.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("labelIds", &__With(&self.label_ids))?;
}
if !self.automatic_label_ids.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("automaticLabelIds", &__With(&self.automatic_label_ids))?;
}
if !wkt::internal::is_default(&self.account_type) {
state.serialize_entry("accountType", &self.account_type)?;
}
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::AccountLabel {
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 !wkt::internal::is_default(&self.label_id) {
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("labelId", &__With(&self.label_id))?;
}
if !wkt::internal::is_default(&self.account_id) {
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("accountId", &__With(&self.account_id))?;
}
if self.display_name.is_some() {
state.serialize_entry("displayName", &self.display_name)?;
}
if self.description.is_some() {
state.serialize_entry("description", &self.description)?;
}
if !wkt::internal::is_default(&self.label_type) {
state.serialize_entry("labelType", &self.label_type)?;
}
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::ListAccountLabelsRequest {
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.parent.is_empty() {
state.serialize_entry("parent", &self.parent)?;
}
if !wkt::internal::is_default(&self.page_size) {
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("pageSize", &__With(&self.page_size))?;
}
if !self.page_token.is_empty() {
state.serialize_entry("pageToken", &self.page_token)?;
}
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::ListAccountLabelsResponse {
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.account_labels.is_empty() {
state.serialize_entry("accountLabels", &self.account_labels)?;
}
if !self.next_page_token.is_empty() {
state.serialize_entry("nextPageToken", &self.next_page_token)?;
}
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::CreateAccountLabelRequest {
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.parent.is_empty() {
state.serialize_entry("parent", &self.parent)?;
}
if self.account_label.is_some() {
state.serialize_entry("accountLabel", &self.account_label)?;
}
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::UpdateAccountLabelRequest {
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.account_label.is_some() {
state.serialize_entry("accountLabel", &self.account_label)?;
}
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::DeleteAccountLabelRequest {
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._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::Attributes {
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.cpp_link.is_some() {
state.serialize_entry("cppLink", &self.cpp_link)?;
}
if self.cpp_mobile_link.is_some() {
state.serialize_entry("cppMobileLink", &self.cpp_mobile_link)?;
}
if self.cpp_ads_redirect.is_some() {
state.serialize_entry("cppAdsRedirect", &self.cpp_ads_redirect)?;
}
if self.low_price.is_some() {
state.serialize_entry("lowPrice", &self.low_price)?;
}
if self.high_price.is_some() {
state.serialize_entry("highPrice", &self.high_price)?;
}
if self.number_of_offers.is_some() {
struct __With<'a>(&'a std::option::Option<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::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("numberOfOffers", &__With(&self.number_of_offers))?;
}
if self.headline_offer_condition.is_some() {
state.serialize_entry("headlineOfferCondition", &self.headline_offer_condition)?;
}
if self.headline_offer_price.is_some() {
state.serialize_entry("headlineOfferPrice", &self.headline_offer_price)?;
}
if self.headline_offer_link.is_some() {
state.serialize_entry("headlineOfferLink", &self.headline_offer_link)?;
}
if self.headline_offer_mobile_link.is_some() {
state.serialize_entry("headlineOfferMobileLink", &self.headline_offer_mobile_link)?;
}
if self.headline_offer_shipping_price.is_some() {
state.serialize_entry(
"headlineOfferShippingPrice",
&self.headline_offer_shipping_price,
)?;
}
if self.title.is_some() {
state.serialize_entry("title", &self.title)?;
}
if self.image_link.is_some() {
state.serialize_entry("imageLink", &self.image_link)?;
}
if !self.additional_image_links.is_empty() {
state.serialize_entry("additionalImageLinks", &self.additional_image_links)?;
}
if self.description.is_some() {
state.serialize_entry("description", &self.description)?;
}
if self.brand.is_some() {
state.serialize_entry("brand", &self.brand)?;
}
if self.mpn.is_some() {
state.serialize_entry("mpn", &self.mpn)?;
}
if self.gtin.is_some() {
state.serialize_entry("gtin", &self.gtin)?;
}
if !self.product_types.is_empty() {
state.serialize_entry("productTypes", &self.product_types)?;
}
if self.google_product_category.is_some() {
state.serialize_entry("googleProductCategory", &self.google_product_category)?;
}
if self.adult.is_some() {
state.serialize_entry("adult", &self.adult)?;
}
if self.multipack.is_some() {
struct __With<'a>(&'a std::option::Option<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::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("multipack", &__With(&self.multipack))?;
}
if self.is_bundle.is_some() {
state.serialize_entry("isBundle", &self.is_bundle)?;
}
if self.age_group.is_some() {
state.serialize_entry("ageGroup", &self.age_group)?;
}
if self.color.is_some() {
state.serialize_entry("color", &self.color)?;
}
if self.gender.is_some() {
state.serialize_entry("gender", &self.gender)?;
}
if self.material.is_some() {
state.serialize_entry("material", &self.material)?;
}
if self.pattern.is_some() {
state.serialize_entry("pattern", &self.pattern)?;
}
if self.size.is_some() {
state.serialize_entry("size", &self.size)?;
}
if self.size_system.is_some() {
state.serialize_entry("sizeSystem", &self.size_system)?;
}
if !self.size_types.is_empty() {
state.serialize_entry("sizeTypes", &self.size_types)?;
}
if self.item_group_id.is_some() {
state.serialize_entry("itemGroupId", &self.item_group_id)?;
}
if !self.product_details.is_empty() {
state.serialize_entry("productDetails", &self.product_details)?;
}
if self.product_weight.is_some() {
state.serialize_entry("productWeight", &self.product_weight)?;
}
if self.product_length.is_some() {
state.serialize_entry("productLength", &self.product_length)?;
}
if self.product_width.is_some() {
state.serialize_entry("productWidth", &self.product_width)?;
}
if self.product_height.is_some() {
state.serialize_entry("productHeight", &self.product_height)?;
}
if !self.product_highlights.is_empty() {
state.serialize_entry("productHighlights", &self.product_highlights)?;
}
if !self.certifications.is_empty() {
state.serialize_entry("certifications", &self.certifications)?;
}
if self.expiration_date.is_some() {
state.serialize_entry("expirationDate", &self.expiration_date)?;
}
if !self.included_destinations.is_empty() {
state.serialize_entry("includedDestinations", &self.included_destinations)?;
}
if !self.excluded_destinations.is_empty() {
state.serialize_entry("excludedDestinations", &self.excluded_destinations)?;
}
if self.pause.is_some() {
state.serialize_entry("pause", &self.pause)?;
}
if self.custom_label_0.is_some() {
state.serialize_entry("customLabel0", &self.custom_label_0)?;
}
if self.custom_label_1.is_some() {
state.serialize_entry("customLabel1", &self.custom_label_1)?;
}
if self.custom_label_2.is_some() {
state.serialize_entry("customLabel2", &self.custom_label_2)?;
}
if self.custom_label_3.is_some() {
state.serialize_entry("customLabel3", &self.custom_label_3)?;
}
if self.custom_label_4.is_some() {
state.serialize_entry("customLabel4", &self.custom_label_4)?;
}
if self.headline_offer_installment.is_some() {
state.serialize_entry("headlineOfferInstallment", &self.headline_offer_installment)?;
}
if self.headline_offer_subscription_cost.is_some() {
state.serialize_entry(
"headlineOfferSubscriptionCost",
&self.headline_offer_subscription_cost,
)?;
}
if self.review_count.is_some() {
struct __With<'a>(&'a std::option::Option<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::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("reviewCount", &__With(&self.review_count))?;
}
if self.min_rating.is_some() {
struct __With<'a>(&'a std::option::Option<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::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("minRating", &__With(&self.min_rating))?;
}
if self.max_rating.is_some() {
struct __With<'a>(&'a std::option::Option<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::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("maxRating", &__With(&self.max_rating))?;
}
if self.rating.is_some() {
struct __With<'a>(&'a std::option::Option<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::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("rating", &__With(&self.rating))?;
}
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::Certification {
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.authority.is_empty() {
state.serialize_entry("authority", &self.authority)?;
}
if !self.code.is_empty() {
state.serialize_entry("code", &self.code)?;
}
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::ProductDetail {
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.section_name.is_empty() {
state.serialize_entry("sectionName", &self.section_name)?;
}
if !self.attribute_name.is_empty() {
state.serialize_entry("attributeName", &self.attribute_name)?;
}
if !self.attribute_value.is_empty() {
state.serialize_entry("attributeValue", &self.attribute_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::ProductDimension {
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.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("value", &__With(&self.value))?;
}
if !self.unit.is_empty() {
state.serialize_entry("unit", &self.unit)?;
}
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::ProductWeight {
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.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("value", &__With(&self.value))?;
}
if !self.unit.is_empty() {
state.serialize_entry("unit", &self.unit)?;
}
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::CssProductStatus {
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.destination_statuses.is_empty() {
state.serialize_entry("destinationStatuses", &self.destination_statuses)?;
}
if !self.item_level_issues.is_empty() {
state.serialize_entry("itemLevelIssues", &self.item_level_issues)?;
}
if self.creation_date.is_some() {
state.serialize_entry("creationDate", &self.creation_date)?;
}
if self.last_update_date.is_some() {
state.serialize_entry("lastUpdateDate", &self.last_update_date)?;
}
if self.google_expiration_date.is_some() {
state.serialize_entry("googleExpirationDate", &self.google_expiration_date)?;
}
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::css_product_status::DestinationStatus {
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.destination.is_empty() {
state.serialize_entry("destination", &self.destination)?;
}
if !self.approved_countries.is_empty() {
state.serialize_entry("approvedCountries", &self.approved_countries)?;
}
if !self.pending_countries.is_empty() {
state.serialize_entry("pendingCountries", &self.pending_countries)?;
}
if !self.disapproved_countries.is_empty() {
state.serialize_entry("disapprovedCountries", &self.disapproved_countries)?;
}
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::css_product_status::ItemLevelIssue {
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.code.is_empty() {
state.serialize_entry("code", &self.code)?;
}
if !self.servability.is_empty() {
state.serialize_entry("servability", &self.servability)?;
}
if !self.resolution.is_empty() {
state.serialize_entry("resolution", &self.resolution)?;
}
if !self.attribute.is_empty() {
state.serialize_entry("attribute", &self.attribute)?;
}
if !self.destination.is_empty() {
state.serialize_entry("destination", &self.destination)?;
}
if !self.description.is_empty() {
state.serialize_entry("description", &self.description)?;
}
if !self.detail.is_empty() {
state.serialize_entry("detail", &self.detail)?;
}
if !self.documentation.is_empty() {
state.serialize_entry("documentation", &self.documentation)?;
}
if !self.applicable_countries.is_empty() {
state.serialize_entry("applicableCountries", &self.applicable_countries)?;
}
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::HeadlineOfferSubscriptionCost {
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.period) {
state.serialize_entry("period", &self.period)?;
}
if !wkt::internal::is_default(&self.period_length) {
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("periodLength", &__With(&self.period_length))?;
}
if self.amount.is_some() {
state.serialize_entry("amount", &self.amount)?;
}
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::HeadlineOfferInstallment {
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.months) {
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("months", &__With(&self.months))?;
}
if self.amount.is_some() {
state.serialize_entry("amount", &self.amount)?;
}
if self.downpayment.is_some() {
state.serialize_entry("downpayment", &self.downpayment)?;
}
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::CssProductInput {
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.final_name.is_empty() {
state.serialize_entry("finalName", &self.final_name)?;
}
if !self.raw_provided_id.is_empty() {
state.serialize_entry("rawProvidedId", &self.raw_provided_id)?;
}
if !self.content_language.is_empty() {
state.serialize_entry("contentLanguage", &self.content_language)?;
}
if !self.feed_label.is_empty() {
state.serialize_entry("feedLabel", &self.feed_label)?;
}
if self.freshness_time.is_some() {
state.serialize_entry("freshnessTime", &self.freshness_time)?;
}
if self.attributes.is_some() {
state.serialize_entry("attributes", &self.attributes)?;
}
if !self.custom_attributes.is_empty() {
state.serialize_entry("customAttributes", &self.custom_attributes)?;
}
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::InsertCssProductInputRequest {
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.parent.is_empty() {
state.serialize_entry("parent", &self.parent)?;
}
if self.css_product_input.is_some() {
state.serialize_entry("cssProductInput", &self.css_product_input)?;
}
if !wkt::internal::is_default(&self.feed_id) {
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("feedId", &__With(&self.feed_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::UpdateCssProductInputRequest {
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.css_product_input.is_some() {
state.serialize_entry("cssProductInput", &self.css_product_input)?;
}
if self.update_mask.is_some() {
state.serialize_entry("updateMask", &self.update_mask)?;
}
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::DeleteCssProductInputRequest {
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.supplemental_feed_id.is_some() {
struct __With<'a>(&'a std::option::Option<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::option::Option<wkt::internal::I64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("supplementalFeedId", &__With(&self.supplemental_feed_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::GetCssProductRequest {
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._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::CssProduct {
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.raw_provided_id.is_empty() {
state.serialize_entry("rawProvidedId", &self.raw_provided_id)?;
}
if !self.content_language.is_empty() {
state.serialize_entry("contentLanguage", &self.content_language)?;
}
if !self.feed_label.is_empty() {
state.serialize_entry("feedLabel", &self.feed_label)?;
}
if self.attributes.is_some() {
state.serialize_entry("attributes", &self.attributes)?;
}
if !self.custom_attributes.is_empty() {
state.serialize_entry("customAttributes", &self.custom_attributes)?;
}
if self.css_product_status.is_some() {
state.serialize_entry("cssProductStatus", &self.css_product_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::ListCssProductsRequest {
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.parent.is_empty() {
state.serialize_entry("parent", &self.parent)?;
}
if !wkt::internal::is_default(&self.page_size) {
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("pageSize", &__With(&self.page_size))?;
}
if !self.page_token.is_empty() {
state.serialize_entry("pageToken", &self.page_token)?;
}
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::ListCssProductsResponse {
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.css_products.is_empty() {
state.serialize_entry("cssProducts", &self.css_products)?;
}
if !self.next_page_token.is_empty() {
state.serialize_entry("nextPageToken", &self.next_page_token)?;
}
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::QuotaGroup {
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 !wkt::internal::is_default(&self.quota_usage) {
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("quotaUsage", &__With(&self.quota_usage))?;
}
if !wkt::internal::is_default(&self.quota_limit) {
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("quotaLimit", &__With(&self.quota_limit))?;
}
if !wkt::internal::is_default(&self.quota_minute_limit) {
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("quotaMinuteLimit", &__With(&self.quota_minute_limit))?;
}
if !self.method_details.is_empty() {
state.serialize_entry("methodDetails", &self.method_details)?;
}
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::MethodDetails {
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.method.is_empty() {
state.serialize_entry("method", &self.method)?;
}
if !self.version.is_empty() {
state.serialize_entry("version", &self.version)?;
}
if !self.subapi.is_empty() {
state.serialize_entry("subapi", &self.subapi)?;
}
if !self.path.is_empty() {
state.serialize_entry("path", &self.path)?;
}
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::ListQuotaGroupsRequest {
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.parent.is_empty() {
state.serialize_entry("parent", &self.parent)?;
}
if !wkt::internal::is_default(&self.page_size) {
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("pageSize", &__With(&self.page_size))?;
}
if !self.page_token.is_empty() {
state.serialize_entry("pageToken", &self.page_token)?;
}
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::ListQuotaGroupsResponse {
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.quota_groups.is_empty() {
state.serialize_entry("quotaGroups", &self.quota_groups)?;
}
if !self.next_page_token.is_empty() {
state.serialize_entry("nextPageToken", &self.next_page_token)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}