#[allow(unused_imports)]
use super::*;
#[doc(hidden)]
impl serde::ser::Serialize for super::Function {
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.description.is_empty() {
state.serialize_entry("description", &self.description)?;
}
if self.build_config.is_some() {
state.serialize_entry("buildConfig", &self.build_config)?;
}
if self.service_config.is_some() {
state.serialize_entry("serviceConfig", &self.service_config)?;
}
if self.event_trigger.is_some() {
state.serialize_entry("eventTrigger", &self.event_trigger)?;
}
if !wkt::internal::is_default(&self.state) {
state.serialize_entry("state", &self.state)?;
}
if self.update_time.is_some() {
state.serialize_entry("updateTime", &self.update_time)?;
}
if !self.labels.is_empty() {
state.serialize_entry("labels", &self.labels)?;
}
if !self.state_messages.is_empty() {
state.serialize_entry("stateMessages", &self.state_messages)?;
}
if !wkt::internal::is_default(&self.environment) {
state.serialize_entry("environment", &self.environment)?;
}
if !self.url.is_empty() {
state.serialize_entry("url", &self.url)?;
}
if !self.kms_key_name.is_empty() {
state.serialize_entry("kmsKeyName", &self.kms_key_name)?;
}
if !wkt::internal::is_default(&self.satisfies_pzs) {
state.serialize_entry("satisfiesPzs", &self.satisfies_pzs)?;
}
if self.create_time.is_some() {
state.serialize_entry("createTime", &self.create_time)?;
}
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::StateMessage {
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.severity) {
state.serialize_entry("severity", &self.severity)?;
}
if !self.r#type.is_empty() {
state.serialize_entry("type", &self.r#type)?;
}
if !self.message.is_empty() {
state.serialize_entry("message", &self.message)?;
}
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::StorageSource {
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.bucket.is_empty() {
state.serialize_entry("bucket", &self.bucket)?;
}
if !self.object.is_empty() {
state.serialize_entry("object", &self.object)?;
}
if !wkt::internal::is_default(&self.generation) {
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("generation", &__With(&self.generation))?;
}
if !self.source_upload_url.is_empty() {
state.serialize_entry("sourceUploadUrl", &self.source_upload_url)?;
}
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::RepoSource {
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 let Some(value) = self.branch_name() {
state.serialize_entry("branchName", value)?;
}
if let Some(value) = self.tag_name() {
state.serialize_entry("tagName", value)?;
}
if let Some(value) = self.commit_sha() {
state.serialize_entry("commitSha", value)?;
}
if !self.project_id.is_empty() {
state.serialize_entry("projectId", &self.project_id)?;
}
if !self.repo_name.is_empty() {
state.serialize_entry("repoName", &self.repo_name)?;
}
if !self.dir.is_empty() {
state.serialize_entry("dir", &self.dir)?;
}
if !wkt::internal::is_default(&self.invert_regex) {
state.serialize_entry("invertRegex", &self.invert_regex)?;
}
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::Source {
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 let Some(value) = self.storage_source() {
state.serialize_entry("storageSource", value)?;
}
if let Some(value) = self.repo_source() {
state.serialize_entry("repoSource", value)?;
}
if let Some(value) = self.git_uri() {
state.serialize_entry("gitUri", 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::SourceProvenance {
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.resolved_storage_source.is_some() {
state.serialize_entry("resolvedStorageSource", &self.resolved_storage_source)?;
}
if self.resolved_repo_source.is_some() {
state.serialize_entry("resolvedRepoSource", &self.resolved_repo_source)?;
}
if !self.git_uri.is_empty() {
state.serialize_entry("gitUri", &self.git_uri)?;
}
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::BuildConfig {
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 let Some(value) = self.automatic_update_policy() {
state.serialize_entry("automaticUpdatePolicy", value)?;
}
if let Some(value) = self.on_deploy_update_policy() {
state.serialize_entry("onDeployUpdatePolicy", value)?;
}
if !self.build.is_empty() {
state.serialize_entry("build", &self.build)?;
}
if !self.runtime.is_empty() {
state.serialize_entry("runtime", &self.runtime)?;
}
if !self.entry_point.is_empty() {
state.serialize_entry("entryPoint", &self.entry_point)?;
}
if self.source.is_some() {
state.serialize_entry("source", &self.source)?;
}
if self.source_provenance.is_some() {
state.serialize_entry("sourceProvenance", &self.source_provenance)?;
}
if !self.worker_pool.is_empty() {
state.serialize_entry("workerPool", &self.worker_pool)?;
}
if !self.environment_variables.is_empty() {
state.serialize_entry("environmentVariables", &self.environment_variables)?;
}
if !wkt::internal::is_default(&self.docker_registry) {
state.serialize_entry("dockerRegistry", &self.docker_registry)?;
}
if !self.docker_repository.is_empty() {
state.serialize_entry("dockerRepository", &self.docker_repository)?;
}
if !self.service_account.is_empty() {
state.serialize_entry("serviceAccount", &self.service_account)?;
}
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::ServiceConfig {
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.is_empty() {
state.serialize_entry("service", &self.service)?;
}
if !wkt::internal::is_default(&self.timeout_seconds) {
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("timeoutSeconds", &__With(&self.timeout_seconds))?;
}
if !self.available_memory.is_empty() {
state.serialize_entry("availableMemory", &self.available_memory)?;
}
if !self.available_cpu.is_empty() {
state.serialize_entry("availableCpu", &self.available_cpu)?;
}
if !self.environment_variables.is_empty() {
state.serialize_entry("environmentVariables", &self.environment_variables)?;
}
if !wkt::internal::is_default(&self.max_instance_count) {
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("maxInstanceCount", &__With(&self.max_instance_count))?;
}
if !wkt::internal::is_default(&self.min_instance_count) {
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("minInstanceCount", &__With(&self.min_instance_count))?;
}
if !self.vpc_connector.is_empty() {
state.serialize_entry("vpcConnector", &self.vpc_connector)?;
}
if !wkt::internal::is_default(&self.vpc_connector_egress_settings) {
state.serialize_entry(
"vpcConnectorEgressSettings",
&self.vpc_connector_egress_settings,
)?;
}
if !wkt::internal::is_default(&self.ingress_settings) {
state.serialize_entry("ingressSettings", &self.ingress_settings)?;
}
if !self.uri.is_empty() {
state.serialize_entry("uri", &self.uri)?;
}
if !self.service_account_email.is_empty() {
state.serialize_entry("serviceAccountEmail", &self.service_account_email)?;
}
if !wkt::internal::is_default(&self.all_traffic_on_latest_revision) {
state.serialize_entry(
"allTrafficOnLatestRevision",
&self.all_traffic_on_latest_revision,
)?;
}
if !self.secret_environment_variables.is_empty() {
state.serialize_entry(
"secretEnvironmentVariables",
&self.secret_environment_variables,
)?;
}
if !self.secret_volumes.is_empty() {
state.serialize_entry("secretVolumes", &self.secret_volumes)?;
}
if !self.revision.is_empty() {
state.serialize_entry("revision", &self.revision)?;
}
if !wkt::internal::is_default(&self.max_instance_request_concurrency) {
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(
"maxInstanceRequestConcurrency",
&__With(&self.max_instance_request_concurrency),
)?;
}
if !wkt::internal::is_default(&self.security_level) {
state.serialize_entry("securityLevel", &self.security_level)?;
}
if !self.binary_authorization_policy.is_empty() {
state.serialize_entry(
"binaryAuthorizationPolicy",
&self.binary_authorization_policy,
)?;
}
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::SecretEnvVar {
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.key.is_empty() {
state.serialize_entry("key", &self.key)?;
}
if !self.project_id.is_empty() {
state.serialize_entry("projectId", &self.project_id)?;
}
if !self.secret.is_empty() {
state.serialize_entry("secret", &self.secret)?;
}
if !self.version.is_empty() {
state.serialize_entry("version", &self.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::SecretVolume {
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.mount_path.is_empty() {
state.serialize_entry("mountPath", &self.mount_path)?;
}
if !self.project_id.is_empty() {
state.serialize_entry("projectId", &self.project_id)?;
}
if !self.secret.is_empty() {
state.serialize_entry("secret", &self.secret)?;
}
if !self.versions.is_empty() {
state.serialize_entry("versions", &self.versions)?;
}
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::secret_volume::SecretVersion {
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.version.is_empty() {
state.serialize_entry("version", &self.version)?;
}
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::EventTrigger {
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.trigger.is_empty() {
state.serialize_entry("trigger", &self.trigger)?;
}
if !self.trigger_region.is_empty() {
state.serialize_entry("triggerRegion", &self.trigger_region)?;
}
if !self.event_type.is_empty() {
state.serialize_entry("eventType", &self.event_type)?;
}
if !self.event_filters.is_empty() {
state.serialize_entry("eventFilters", &self.event_filters)?;
}
if !self.pubsub_topic.is_empty() {
state.serialize_entry("pubsubTopic", &self.pubsub_topic)?;
}
if !self.service_account_email.is_empty() {
state.serialize_entry("serviceAccountEmail", &self.service_account_email)?;
}
if !wkt::internal::is_default(&self.retry_policy) {
state.serialize_entry("retryPolicy", &self.retry_policy)?;
}
if !self.channel.is_empty() {
state.serialize_entry("channel", &self.channel)?;
}
if !self.service.is_empty() {
state.serialize_entry("service", &self.service)?;
}
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::EventFilter {
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.attribute.is_empty() {
state.serialize_entry("attribute", &self.attribute)?;
}
if !self.value.is_empty() {
state.serialize_entry("value", &self.value)?;
}
if !self.operator.is_empty() {
state.serialize_entry("operator", &self.operator)?;
}
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::GetFunctionRequest {
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.revision.is_empty() {
state.serialize_entry("revision", &self.revision)?;
}
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::ListFunctionsRequest {
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.filter.is_empty() {
state.serialize_entry("filter", &self.filter)?;
}
if !self.order_by.is_empty() {
state.serialize_entry("orderBy", &self.order_by)?;
}
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::ListFunctionsResponse {
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.functions.is_empty() {
state.serialize_entry("functions", &self.functions)?;
}
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::CreateFunctionRequest {
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.function.is_some() {
state.serialize_entry("function", &self.function)?;
}
if !self.function_id.is_empty() {
state.serialize_entry("functionId", &self.function_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::UpdateFunctionRequest {
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.function.is_some() {
state.serialize_entry("function", &self.function)?;
}
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::DeleteFunctionRequest {
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::GenerateUploadUrlRequest {
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.kms_key_name.is_empty() {
state.serialize_entry("kmsKeyName", &self.kms_key_name)?;
}
if !wkt::internal::is_default(&self.environment) {
state.serialize_entry("environment", &self.environment)?;
}
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::GenerateUploadUrlResponse {
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.upload_url.is_empty() {
state.serialize_entry("uploadUrl", &self.upload_url)?;
}
if self.storage_source.is_some() {
state.serialize_entry("storageSource", &self.storage_source)?;
}
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::GenerateDownloadUrlRequest {
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::GenerateDownloadUrlResponse {
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.download_url.is_empty() {
state.serialize_entry("downloadUrl", &self.download_url)?;
}
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::ListRuntimesRequest {
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.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::ListRuntimesResponse {
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.runtimes.is_empty() {
state.serialize_entry("runtimes", &self.runtimes)?;
}
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::list_runtimes_response::Runtime {
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.display_name.is_empty() {
state.serialize_entry("displayName", &self.display_name)?;
}
if !wkt::internal::is_default(&self.stage) {
state.serialize_entry("stage", &self.stage)?;
}
if !self.warnings.is_empty() {
state.serialize_entry("warnings", &self.warnings)?;
}
if !wkt::internal::is_default(&self.environment) {
state.serialize_entry("environment", &self.environment)?;
}
if self.deprecation_date.is_some() {
state.serialize_entry("deprecationDate", &self.deprecation_date)?;
}
if self.decommission_date.is_some() {
state.serialize_entry("decommissionDate", &self.decommission_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::AutomaticUpdatePolicy {
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._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::OnDeployUpdatePolicy {
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.runtime_version.is_empty() {
state.serialize_entry("runtimeVersion", &self.runtime_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::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_detail.is_empty() {
state.serialize_entry("statusDetail", &self.status_detail)?;
}
if !wkt::internal::is_default(&self.cancel_requested) {
state.serialize_entry("cancelRequested", &self.cancel_requested)?;
}
if !self.api_version.is_empty() {
state.serialize_entry("apiVersion", &self.api_version)?;
}
if self.request_resource.is_some() {
state.serialize_entry("requestResource", &self.request_resource)?;
}
if !self.stages.is_empty() {
state.serialize_entry("stages", &self.stages)?;
}
if !self.source_token.is_empty() {
state.serialize_entry("sourceToken", &self.source_token)?;
}
if !self.build_name.is_empty() {
state.serialize_entry("buildName", &self.build_name)?;
}
if !wkt::internal::is_default(&self.operation_type) {
state.serialize_entry("operationType", &self.operation_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::LocationMetadata {
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.environments.is_empty() {
state.serialize_entry("environments", &self.environments)?;
}
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::Stage {
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.name) {
state.serialize_entry("name", &self.name)?;
}
if !self.message.is_empty() {
state.serialize_entry("message", &self.message)?;
}
if !wkt::internal::is_default(&self.state) {
state.serialize_entry("state", &self.state)?;
}
if !self.resource.is_empty() {
state.serialize_entry("resource", &self.resource)?;
}
if !self.resource_uri.is_empty() {
state.serialize_entry("resourceUri", &self.resource_uri)?;
}
if !self.state_messages.is_empty() {
state.serialize_entry("stateMessages", &self.state_messages)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}