#[allow(unused_imports)]
use super::*;
#[doc(hidden)]
impl serde::ser::Serialize for super::Challenge {
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.create_time.is_some() {
state.serialize_entry("createTime", &self.create_time)?;
}
if self.expire_time.is_some() {
state.serialize_entry("expireTime", &self.expire_time)?;
}
if !wkt::internal::is_default(&self.used) {
state.serialize_entry("used", &self.used)?;
}
if !self.tpm_nonce.is_empty() {
state.serialize_entry("tpmNonce", &self.tpm_nonce)?;
}
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::CreateChallengeRequest {
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.challenge.is_some() {
state.serialize_entry("challenge", &self.challenge)?;
}
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::VerifyAttestationRequest {
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.td_ccel() {
state.serialize_entry("tdCcel", value)?;
}
if let Some(value) = self.sev_snp_attestation() {
state.serialize_entry("sevSnpAttestation", value)?;
}
if let Some(value) = self.nvidia_attestation() {
state.serialize_entry("nvidiaAttestation", value)?;
}
if !self.challenge.is_empty() {
state.serialize_entry("challenge", &self.challenge)?;
}
if self.gcp_credentials.is_some() {
state.serialize_entry("gcpCredentials", &self.gcp_credentials)?;
}
if self.tpm_attestation.is_some() {
state.serialize_entry("tpmAttestation", &self.tpm_attestation)?;
}
if self.confidential_space_info.is_some() {
state.serialize_entry("confidentialSpaceInfo", &self.confidential_space_info)?;
}
if self.token_options.is_some() {
state.serialize_entry("tokenOptions", &self.token_options)?;
}
if !self.attester.is_empty() {
state.serialize_entry("attester", &self.attester)?;
}
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::NvidiaAttestation {
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.spt() {
state.serialize_entry("spt", value)?;
}
if let Some(value) = self.ppcie() {
state.serialize_entry("ppcie", value)?;
}
if let Some(value) = self.mpt() {
state.serialize_entry("mpt", 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::nvidia_attestation::GpuInfo {
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.uuid.is_empty() {
state.serialize_entry("uuid", &self.uuid)?;
}
if !self.driver_version.is_empty() {
state.serialize_entry("driverVersion", &self.driver_version)?;
}
if !self.vbios_version.is_empty() {
state.serialize_entry("vbiosVersion", &self.vbios_version)?;
}
if !wkt::internal::is_default(&self.gpu_architecture_type) {
state.serialize_entry("gpuArchitectureType", &self.gpu_architecture_type)?;
}
if !self.attestation_certificate_chain.is_empty() {
struct __With<'a>(&'a ::bytes::Bytes);
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::<serde_with::base64::Base64>::serialize(self.0, serializer)
}
}
state.serialize_entry(
"attestationCertificateChain",
&__With(&self.attestation_certificate_chain),
)?;
}
if !self.attestation_report.is_empty() {
struct __With<'a>(&'a ::bytes::Bytes);
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::<serde_with::base64::Base64>::serialize(self.0, serializer)
}
}
state.serialize_entry("attestationReport", &__With(&self.attestation_report))?;
}
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::nvidia_attestation::SwitchInfo {
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.uuid.is_empty() {
state.serialize_entry("uuid", &self.uuid)?;
}
if !self.attestation_certificate_chain.is_empty() {
struct __With<'a>(&'a ::bytes::Bytes);
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::<serde_with::base64::Base64>::serialize(self.0, serializer)
}
}
state.serialize_entry(
"attestationCertificateChain",
&__With(&self.attestation_certificate_chain),
)?;
}
if !self.attestation_report.is_empty() {
struct __With<'a>(&'a ::bytes::Bytes);
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::<serde_with::base64::Base64>::serialize(self.0, serializer)
}
}
state.serialize_entry("attestationReport", &__With(&self.attestation_report))?;
}
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::nvidia_attestation::SinglePassthroughAttestation {
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.gpu_quote.is_some() {
state.serialize_entry("gpuQuote", &self.gpu_quote)?;
}
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::nvidia_attestation::ProtectedPcieAttestation {
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.gpu_quotes.is_empty() {
state.serialize_entry("gpuQuotes", &self.gpu_quotes)?;
}
if !self.switch_quotes.is_empty() {
state.serialize_entry("switchQuotes", &self.switch_quotes)?;
}
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::nvidia_attestation::MultiGpuSecurePassthroughAttestation {
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.gpu_quotes.is_empty() {
state.serialize_entry("gpuQuotes", &self.gpu_quotes)?;
}
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::TdxCcelAttestation {
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.ccel_acpi_table.is_empty() {
struct __With<'a>(&'a ::bytes::Bytes);
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::<serde_with::base64::Base64>::serialize(self.0, serializer)
}
}
state.serialize_entry("ccelAcpiTable", &__With(&self.ccel_acpi_table))?;
}
if !self.ccel_data.is_empty() {
struct __With<'a>(&'a ::bytes::Bytes);
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::<serde_with::base64::Base64>::serialize(self.0, serializer)
}
}
state.serialize_entry("ccelData", &__With(&self.ccel_data))?;
}
if !self.canonical_event_log.is_empty() {
struct __With<'a>(&'a ::bytes::Bytes);
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::<serde_with::base64::Base64>::serialize(self.0, serializer)
}
}
state.serialize_entry("canonicalEventLog", &__With(&self.canonical_event_log))?;
}
if !self.td_quote.is_empty() {
struct __With<'a>(&'a ::bytes::Bytes);
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::<serde_with::base64::Base64>::serialize(self.0, serializer)
}
}
state.serialize_entry("tdQuote", &__With(&self.td_quote))?;
}
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::SevSnpAttestation {
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.is_empty() {
struct __With<'a>(&'a ::bytes::Bytes);
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::<serde_with::base64::Base64>::serialize(self.0, serializer)
}
}
state.serialize_entry("report", &__With(&self.report))?;
}
if !self.aux_blob.is_empty() {
struct __With<'a>(&'a ::bytes::Bytes);
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::<serde_with::base64::Base64>::serialize(self.0, serializer)
}
}
state.serialize_entry("auxBlob", &__With(&self.aux_blob))?;
}
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::VerifyAttestationResponse {
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.oidc_claims_token.is_empty() {
state.serialize_entry("oidcClaimsToken", &self.oidc_claims_token)?;
}
if !self.partial_errors.is_empty() {
state.serialize_entry("partialErrors", &self.partial_errors)?;
}
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::GcpCredentials {
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_account_id_tokens.is_empty() {
state.serialize_entry("serviceAccountIdTokens", &self.service_account_id_tokens)?;
}
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::TokenOptions {
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.aws_principal_tags_options() {
state.serialize_entry("awsPrincipalTagsOptions", value)?;
}
if !self.audience.is_empty() {
state.serialize_entry("audience", &self.audience)?;
}
if !self.nonce.is_empty() {
state.serialize_entry("nonce", &self.nonce)?;
}
if !wkt::internal::is_default(&self.token_type) {
state.serialize_entry("tokenType", &self.token_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::AwsPrincipalTagsOptions {
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.allowed_principal_tags.is_some() {
state.serialize_entry("allowedPrincipalTags", &self.allowed_principal_tags)?;
}
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::aws_principal_tags_options::AllowedPrincipalTags {
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.container_image_signatures.is_some() {
state.serialize_entry("containerImageSignatures", &self.container_image_signatures)?;
}
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::aws_principal_tags_options::allowed_principal_tags::ContainerImageSignatures
{
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_ids.is_empty() {
state.serialize_entry("keyIds", &self.key_ids)?;
}
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::TpmAttestation {
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.quotes.is_empty() {
state.serialize_entry("quotes", &self.quotes)?;
}
if !self.tcg_event_log.is_empty() {
struct __With<'a>(&'a ::bytes::Bytes);
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::<serde_with::base64::Base64>::serialize(self.0, serializer)
}
}
state.serialize_entry("tcgEventLog", &__With(&self.tcg_event_log))?;
}
if !self.canonical_event_log.is_empty() {
struct __With<'a>(&'a ::bytes::Bytes);
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::<serde_with::base64::Base64>::serialize(self.0, serializer)
}
}
state.serialize_entry("canonicalEventLog", &__With(&self.canonical_event_log))?;
}
if !self.ak_cert.is_empty() {
struct __With<'a>(&'a ::bytes::Bytes);
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::<serde_with::base64::Base64>::serialize(self.0, serializer)
}
}
state.serialize_entry("akCert", &__With(&self.ak_cert))?;
}
if !self.cert_chain.is_empty() {
struct __With<'a>(&'a std::vec::Vec<::bytes::Bytes>);
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<serde_with::base64::Base64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("certChain", &__With(&self.cert_chain))?;
}
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::tpm_attestation::Quote {
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.hash_algo) {
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("hashAlgo", &__With(&self.hash_algo))?;
}
if !self.pcr_values.is_empty() {
struct __With<'a>(&'a std::collections::HashMap<i32, ::bytes::Bytes>);
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::collections::HashMap<wkt::internal::I32, serde_with::base64::Base64>,
>::serialize(self.0, serializer)
}
}
state.serialize_entry("pcrValues", &__With(&self.pcr_values))?;
}
if !self.raw_quote.is_empty() {
struct __With<'a>(&'a ::bytes::Bytes);
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::<serde_with::base64::Base64>::serialize(self.0, serializer)
}
}
state.serialize_entry("rawQuote", &__With(&self.raw_quote))?;
}
if !self.raw_signature.is_empty() {
struct __With<'a>(&'a ::bytes::Bytes);
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::<serde_with::base64::Base64>::serialize(self.0, serializer)
}
}
state.serialize_entry("rawSignature", &__With(&self.raw_signature))?;
}
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::ConfidentialSpaceInfo {
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.signed_entities.is_empty() {
state.serialize_entry("signedEntities", &self.signed_entities)?;
}
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::SignedEntity {
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.container_image_signatures.is_empty() {
state.serialize_entry("containerImageSignatures", &self.container_image_signatures)?;
}
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::ContainerImageSignature {
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.payload.is_empty() {
struct __With<'a>(&'a ::bytes::Bytes);
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::<serde_with::base64::Base64>::serialize(self.0, serializer)
}
}
state.serialize_entry("payload", &__With(&self.payload))?;
}
if !self.signature.is_empty() {
struct __With<'a>(&'a ::bytes::Bytes);
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::<serde_with::base64::Base64>::serialize(self.0, serializer)
}
}
state.serialize_entry("signature", &__With(&self.signature))?;
}
if !self.public_key.is_empty() {
struct __With<'a>(&'a ::bytes::Bytes);
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::<serde_with::base64::Base64>::serialize(self.0, serializer)
}
}
state.serialize_entry("publicKey", &__With(&self.public_key))?;
}
if !wkt::internal::is_default(&self.sig_alg) {
state.serialize_entry("sigAlg", &self.sig_alg)?;
}
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::VerifyConfidentialSpaceRequest {
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.td_ccel() {
state.serialize_entry("tdCcel", value)?;
}
if let Some(value) = self.tpm_attestation() {
state.serialize_entry("tpmAttestation", value)?;
}
if !self.challenge.is_empty() {
state.serialize_entry("challenge", &self.challenge)?;
}
if self.gcp_credentials.is_some() {
state.serialize_entry("gcpCredentials", &self.gcp_credentials)?;
}
if !self.signed_entities.is_empty() {
state.serialize_entry("signedEntities", &self.signed_entities)?;
}
if self.gce_shielded_identity.is_some() {
state.serialize_entry("gceShieldedIdentity", &self.gce_shielded_identity)?;
}
if self.options.is_some() {
state.serialize_entry("options", &self.options)?;
}
if self.nvidia_attestation.is_some() {
state.serialize_entry("nvidiaAttestation", &self.nvidia_attestation)?;
}
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::verify_confidential_space_request::ConfidentialSpaceOptions {
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.aws_principal_tags_options() {
state.serialize_entry("awsPrincipalTagsOptions", value)?;
}
if !self.audience.is_empty() {
state.serialize_entry("audience", &self.audience)?;
}
if !wkt::internal::is_default(&self.token_profile) {
state.serialize_entry("tokenProfile", &self.token_profile)?;
}
if !self.nonce.is_empty() {
state.serialize_entry("nonce", &self.nonce)?;
}
if !wkt::internal::is_default(&self.signature_type) {
state.serialize_entry("signatureType", &self.signature_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::GceShieldedIdentity {
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.ak_cert.is_empty() {
struct __With<'a>(&'a ::bytes::Bytes);
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::<serde_with::base64::Base64>::serialize(self.0, serializer)
}
}
state.serialize_entry("akCert", &__With(&self.ak_cert))?;
}
if !self.ak_cert_chain.is_empty() {
struct __With<'a>(&'a std::vec::Vec<::bytes::Bytes>);
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<serde_with::base64::Base64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("akCertChain", &__With(&self.ak_cert_chain))?;
}
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::VerifyConfidentialSpaceResponse {
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.attestation_token.is_empty() {
state.serialize_entry("attestationToken", &self.attestation_token)?;
}
if !self.partial_errors.is_empty() {
state.serialize_entry("partialErrors", &self.partial_errors)?;
}
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::VerifyConfidentialGkeRequest {
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.tpm_attestation() {
state.serialize_entry("tpmAttestation", value)?;
}
if !self.challenge.is_empty() {
state.serialize_entry("challenge", &self.challenge)?;
}
if self.options.is_some() {
state.serialize_entry("options", &self.options)?;
}
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::verify_confidential_gke_request::ConfidentialGkeOptions {
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.audience.is_empty() {
state.serialize_entry("audience", &self.audience)?;
}
if !self.nonce.is_empty() {
state.serialize_entry("nonce", &self.nonce)?;
}
if !wkt::internal::is_default(&self.signature_type) {
state.serialize_entry("signatureType", &self.signature_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::VerifyConfidentialGkeResponse {
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.attestation_token.is_empty() {
state.serialize_entry("attestationToken", &self.attestation_token)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}