#[allow(unused_imports)]
use super::*;
#[doc(hidden)]
impl serde::ser::Serialize for super::DiagnosticConfig {
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.gcs_bucket.is_empty() {
state.serialize_entry("gcsBucket", &self.gcs_bucket)?;
}
if !self.relative_path.is_empty() {
state.serialize_entry("relativePath", &self.relative_path)?;
}
if !wkt::internal::is_default(&self.enable_repair_flag) {
state.serialize_entry("enableRepairFlag", &self.enable_repair_flag)?;
}
if !wkt::internal::is_default(&self.enable_packet_capture_flag) {
state.serialize_entry("enablePacketCaptureFlag", &self.enable_packet_capture_flag)?;
}
if !wkt::internal::is_default(&self.enable_copy_home_files_flag) {
state.serialize_entry("enableCopyHomeFilesFlag", &self.enable_copy_home_files_flag)?;
}
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::Event {
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_time.is_some() {
state.serialize_entry("reportTime", &self.report_time)?;
}
if !wkt::internal::is_default(&self.r#type) {
state.serialize_entry("type", &self.r#type)?;
}
if !self.details.is_empty() {
state.serialize_entry("details", &self.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::NetworkInterface {
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.network.is_empty() {
state.serialize_entry("network", &self.network)?;
}
if !self.subnet.is_empty() {
state.serialize_entry("subnet", &self.subnet)?;
}
if !wkt::internal::is_default(&self.nic_type) {
state.serialize_entry("nicType", &self.nic_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::VmImage {
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.project.is_empty() {
state.serialize_entry("project", &self.project)?;
}
if let Some(value) = self.name() {
state.serialize_entry("name", value)?;
}
if let Some(value) = self.family() {
state.serialize_entry("family", 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::ContainerImage {
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.repository.is_empty() {
state.serialize_entry("repository", &self.repository)?;
}
if !self.tag.is_empty() {
state.serialize_entry("tag", &self.tag)?;
}
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::AcceleratorConfig {
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.r#type) {
state.serialize_entry("type", &self.r#type)?;
}
if !wkt::internal::is_default(&self.core_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("coreCount", &__With(&self.core_count))?;
}
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::ShieldedInstanceConfig {
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.enable_secure_boot) {
state.serialize_entry("enableSecureBoot", &self.enable_secure_boot)?;
}
if !wkt::internal::is_default(&self.enable_vtpm) {
state.serialize_entry("enableVtpm", &self.enable_vtpm)?;
}
if !wkt::internal::is_default(&self.enable_integrity_monitoring) {
state.serialize_entry(
"enableIntegrityMonitoring",
&self.enable_integrity_monitoring,
)?;
}
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::GPUDriverConfig {
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.enable_gpu_driver) {
state.serialize_entry("enableGpuDriver", &self.enable_gpu_driver)?;
}
if !self.custom_gpu_driver_path.is_empty() {
state.serialize_entry("customGpuDriverPath", &self.custom_gpu_driver_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::DataDisk {
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.disk_size_gb) {
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("diskSizeGb", &__With(&self.disk_size_gb))?;
}
if !wkt::internal::is_default(&self.disk_type) {
state.serialize_entry("diskType", &self.disk_type)?;
}
if !wkt::internal::is_default(&self.disk_encryption) {
state.serialize_entry("diskEncryption", &self.disk_encryption)?;
}
if !self.kms_key.is_empty() {
state.serialize_entry("kmsKey", &self.kms_key)?;
}
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::BootDisk {
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.disk_size_gb) {
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("diskSizeGb", &__With(&self.disk_size_gb))?;
}
if !wkt::internal::is_default(&self.disk_type) {
state.serialize_entry("diskType", &self.disk_type)?;
}
if !wkt::internal::is_default(&self.disk_encryption) {
state.serialize_entry("diskEncryption", &self.disk_encryption)?;
}
if !self.kms_key.is_empty() {
state.serialize_entry("kmsKey", &self.kms_key)?;
}
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::ServiceAccount {
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.email.is_empty() {
state.serialize_entry("email", &self.email)?;
}
if !self.scopes.is_empty() {
state.serialize_entry("scopes", &self.scopes)?;
}
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::GceSetup {
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.machine_type.is_empty() {
state.serialize_entry("machineType", &self.machine_type)?;
}
if !self.accelerator_configs.is_empty() {
state.serialize_entry("acceleratorConfigs", &self.accelerator_configs)?;
}
if !self.service_accounts.is_empty() {
state.serialize_entry("serviceAccounts", &self.service_accounts)?;
}
if let Some(value) = self.vm_image() {
state.serialize_entry("vmImage", value)?;
}
if let Some(value) = self.container_image() {
state.serialize_entry("containerImage", value)?;
}
if self.boot_disk.is_some() {
state.serialize_entry("bootDisk", &self.boot_disk)?;
}
if !self.data_disks.is_empty() {
state.serialize_entry("dataDisks", &self.data_disks)?;
}
if self.shielded_instance_config.is_some() {
state.serialize_entry("shieldedInstanceConfig", &self.shielded_instance_config)?;
}
if !self.network_interfaces.is_empty() {
state.serialize_entry("networkInterfaces", &self.network_interfaces)?;
}
if !wkt::internal::is_default(&self.disable_public_ip) {
state.serialize_entry("disablePublicIp", &self.disable_public_ip)?;
}
if !self.tags.is_empty() {
state.serialize_entry("tags", &self.tags)?;
}
if !self.metadata.is_empty() {
state.serialize_entry("metadata", &self.metadata)?;
}
if !wkt::internal::is_default(&self.enable_ip_forwarding) {
state.serialize_entry("enableIpForwarding", &self.enable_ip_forwarding)?;
}
if self.gpu_driver_config.is_some() {
state.serialize_entry("gpuDriverConfig", &self.gpu_driver_config)?;
}
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::UpgradeHistoryEntry {
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.snapshot.is_empty() {
state.serialize_entry("snapshot", &self.snapshot)?;
}
if !self.vm_image.is_empty() {
state.serialize_entry("vmImage", &self.vm_image)?;
}
if !self.container_image.is_empty() {
state.serialize_entry("containerImage", &self.container_image)?;
}
if !self.framework.is_empty() {
state.serialize_entry("framework", &self.framework)?;
}
if !self.version.is_empty() {
state.serialize_entry("version", &self.version)?;
}
if !wkt::internal::is_default(&self.state) {
state.serialize_entry("state", &self.state)?;
}
if self.create_time.is_some() {
state.serialize_entry("createTime", &self.create_time)?;
}
if !wkt::internal::is_default(&self.action) {
state.serialize_entry("action", &self.action)?;
}
if !self.target_version.is_empty() {
state.serialize_entry("targetVersion", &self.target_version)?;
}
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::Instance {
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 let Some(value) = self.gce_setup() {
state.serialize_entry("gceSetup", value)?;
}
if !self.proxy_uri.is_empty() {
state.serialize_entry("proxyUri", &self.proxy_uri)?;
}
if !self.instance_owners.is_empty() {
state.serialize_entry("instanceOwners", &self.instance_owners)?;
}
if !self.creator.is_empty() {
state.serialize_entry("creator", &self.creator)?;
}
if !wkt::internal::is_default(&self.state) {
state.serialize_entry("state", &self.state)?;
}
if !self.upgrade_history.is_empty() {
state.serialize_entry("upgradeHistory", &self.upgrade_history)?;
}
if !self.id.is_empty() {
state.serialize_entry("id", &self.id)?;
}
if !wkt::internal::is_default(&self.health_state) {
state.serialize_entry("healthState", &self.health_state)?;
}
if !self.health_info.is_empty() {
state.serialize_entry("healthInfo", &self.health_info)?;
}
if self.create_time.is_some() {
state.serialize_entry("createTime", &self.create_time)?;
}
if self.update_time.is_some() {
state.serialize_entry("updateTime", &self.update_time)?;
}
if !wkt::internal::is_default(&self.disable_proxy_access) {
state.serialize_entry("disableProxyAccess", &self.disable_proxy_access)?;
}
if !self.labels.is_empty() {
state.serialize_entry("labels", &self.labels)?;
}
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::OperationMetadata {
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.create_time.is_some() {
state.serialize_entry("createTime", &self.create_time)?;
}
if self.end_time.is_some() {
state.serialize_entry("endTime", &self.end_time)?;
}
if !self.target.is_empty() {
state.serialize_entry("target", &self.target)?;
}
if !self.verb.is_empty() {
state.serialize_entry("verb", &self.verb)?;
}
if !self.status_message.is_empty() {
state.serialize_entry("statusMessage", &self.status_message)?;
}
if !wkt::internal::is_default(&self.requested_cancellation) {
state.serialize_entry("requestedCancellation", &self.requested_cancellation)?;
}
if !self.api_version.is_empty() {
state.serialize_entry("apiVersion", &self.api_version)?;
}
if !self.endpoint.is_empty() {
state.serialize_entry("endpoint", &self.endpoint)?;
}
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::ListInstancesRequest {
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.order_by.is_empty() {
state.serialize_entry("orderBy", &self.order_by)?;
}
if !self.filter.is_empty() {
state.serialize_entry("filter", &self.filter)?;
}
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::ListInstancesResponse {
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.instances.is_empty() {
state.serialize_entry("instances", &self.instances)?;
}
if !self.next_page_token.is_empty() {
state.serialize_entry("nextPageToken", &self.next_page_token)?;
}
if !self.unreachable.is_empty() {
state.serialize_entry("unreachable", &self.unreachable)?;
}
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::GetInstanceRequest {
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::CreateInstanceRequest {
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.instance_id.is_empty() {
state.serialize_entry("instanceId", &self.instance_id)?;
}
if self.instance.is_some() {
state.serialize_entry("instance", &self.instance)?;
}
if !self.request_id.is_empty() {
state.serialize_entry("requestId", &self.request_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::UpdateInstanceRequest {
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.instance.is_some() {
state.serialize_entry("instance", &self.instance)?;
}
if self.update_mask.is_some() {
state.serialize_entry("updateMask", &self.update_mask)?;
}
if !self.request_id.is_empty() {
state.serialize_entry("requestId", &self.request_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::DeleteInstanceRequest {
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.request_id.is_empty() {
state.serialize_entry("requestId", &self.request_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::StartInstanceRequest {
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::StopInstanceRequest {
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::ResetInstanceRequest {
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::CheckInstanceUpgradabilityRequest {
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.notebook_instance.is_empty() {
state.serialize_entry("notebookInstance", &self.notebook_instance)?;
}
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::CheckInstanceUpgradabilityResponse {
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.upgradeable) {
state.serialize_entry("upgradeable", &self.upgradeable)?;
}
if !self.upgrade_version.is_empty() {
state.serialize_entry("upgradeVersion", &self.upgrade_version)?;
}
if !self.upgrade_info.is_empty() {
state.serialize_entry("upgradeInfo", &self.upgrade_info)?;
}
if !self.upgrade_image.is_empty() {
state.serialize_entry("upgradeImage", &self.upgrade_image)?;
}
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::UpgradeInstanceRequest {
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::RollbackInstanceRequest {
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.target_snapshot.is_empty() {
state.serialize_entry("targetSnapshot", &self.target_snapshot)?;
}
if !self.revision_id.is_empty() {
state.serialize_entry("revisionId", &self.revision_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::DiagnoseInstanceRequest {
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.diagnostic_config.is_some() {
state.serialize_entry("diagnosticConfig", &self.diagnostic_config)?;
}
if !wkt::internal::is_default(&self.timeout_minutes) {
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("timeoutMinutes", &__With(&self.timeout_minutes))?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}