pub fn serialize_structure_crate_input_create_certificate_authority_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateCertificateAuthorityInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.certificate_authority_configuration {
#[allow(unused_mut)]
let mut object_2 = object
.key("CertificateAuthorityConfiguration")
.start_object();
crate::json_ser::serialize_structure_crate_model_certificate_authority_configuration(
&mut object_2,
var_1,
)?;
object_2.finish();
}
if let Some(var_3) = &input.revocation_configuration {
#[allow(unused_mut)]
let mut object_4 = object.key("RevocationConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_revocation_configuration(
&mut object_4,
var_3,
)?;
object_4.finish();
}
if let Some(var_5) = &input.certificate_authority_type {
object
.key("CertificateAuthorityType")
.string(var_5.as_str());
}
if let Some(var_6) = &input.idempotency_token {
object.key("IdempotencyToken").string(var_6.as_str());
}
if let Some(var_7) = &input.key_storage_security_standard {
object
.key("KeyStorageSecurityStandard")
.string(var_7.as_str());
}
if let Some(var_8) = &input.tags {
let mut array_9 = object.key("Tags").start_array();
for item_10 in var_8 {
{
#[allow(unused_mut)]
let mut object_11 = array_9.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_11, item_10)?;
object_11.finish();
}
}
array_9.finish();
}
if let Some(var_12) = &input.usage_mode {
object.key("UsageMode").string(var_12.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_certificate_authority_audit_report_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateCertificateAuthorityAuditReportInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_13) = &input.certificate_authority_arn {
object
.key("CertificateAuthorityArn")
.string(var_13.as_str());
}
if let Some(var_14) = &input.s3_bucket_name {
object.key("S3BucketName").string(var_14.as_str());
}
if let Some(var_15) = &input.audit_report_response_format {
object
.key("AuditReportResponseFormat")
.string(var_15.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_permission_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreatePermissionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_16) = &input.certificate_authority_arn {
object
.key("CertificateAuthorityArn")
.string(var_16.as_str());
}
if let Some(var_17) = &input.principal {
object.key("Principal").string(var_17.as_str());
}
if let Some(var_18) = &input.source_account {
object.key("SourceAccount").string(var_18.as_str());
}
if let Some(var_19) = &input.actions {
let mut array_20 = object.key("Actions").start_array();
for item_21 in var_19 {
{
array_20.value().string(item_21.as_str());
}
}
array_20.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_certificate_authority_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteCertificateAuthorityInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_22) = &input.certificate_authority_arn {
object
.key("CertificateAuthorityArn")
.string(var_22.as_str());
}
if let Some(var_23) = &input.permanent_deletion_time_in_days {
object.key("PermanentDeletionTimeInDays").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_23).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_permission_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeletePermissionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_24) = &input.certificate_authority_arn {
object
.key("CertificateAuthorityArn")
.string(var_24.as_str());
}
if let Some(var_25) = &input.principal {
object.key("Principal").string(var_25.as_str());
}
if let Some(var_26) = &input.source_account {
object.key("SourceAccount").string(var_26.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeletePolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_27) = &input.resource_arn {
object.key("ResourceArn").string(var_27.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_certificate_authority_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeCertificateAuthorityInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_28) = &input.certificate_authority_arn {
object
.key("CertificateAuthorityArn")
.string(var_28.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_certificate_authority_audit_report_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeCertificateAuthorityAuditReportInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_29) = &input.certificate_authority_arn {
object
.key("CertificateAuthorityArn")
.string(var_29.as_str());
}
if let Some(var_30) = &input.audit_report_id {
object.key("AuditReportId").string(var_30.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_certificate_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetCertificateInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_31) = &input.certificate_authority_arn {
object
.key("CertificateAuthorityArn")
.string(var_31.as_str());
}
if let Some(var_32) = &input.certificate_arn {
object.key("CertificateArn").string(var_32.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_certificate_authority_certificate_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetCertificateAuthorityCertificateInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_33) = &input.certificate_authority_arn {
object
.key("CertificateAuthorityArn")
.string(var_33.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_certificate_authority_csr_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetCertificateAuthorityCsrInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_34) = &input.certificate_authority_arn {
object
.key("CertificateAuthorityArn")
.string(var_34.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetPolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_35) = &input.resource_arn {
object.key("ResourceArn").string(var_35.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_import_certificate_authority_certificate_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ImportCertificateAuthorityCertificateInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_36) = &input.certificate_authority_arn {
object
.key("CertificateAuthorityArn")
.string(var_36.as_str());
}
if let Some(var_37) = &input.certificate {
object
.key("Certificate")
.string_unchecked(&aws_smithy_types::base64::encode(var_37));
}
if let Some(var_38) = &input.certificate_chain {
object
.key("CertificateChain")
.string_unchecked(&aws_smithy_types::base64::encode(var_38));
}
Ok(())
}
pub fn serialize_structure_crate_input_issue_certificate_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::IssueCertificateInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_39) = &input.api_passthrough {
#[allow(unused_mut)]
let mut object_40 = object.key("ApiPassthrough").start_object();
crate::json_ser::serialize_structure_crate_model_api_passthrough(&mut object_40, var_39)?;
object_40.finish();
}
if let Some(var_41) = &input.certificate_authority_arn {
object
.key("CertificateAuthorityArn")
.string(var_41.as_str());
}
if let Some(var_42) = &input.csr {
object
.key("Csr")
.string_unchecked(&aws_smithy_types::base64::encode(var_42));
}
if let Some(var_43) = &input.signing_algorithm {
object.key("SigningAlgorithm").string(var_43.as_str());
}
if let Some(var_44) = &input.template_arn {
object.key("TemplateArn").string(var_44.as_str());
}
if let Some(var_45) = &input.validity {
#[allow(unused_mut)]
let mut object_46 = object.key("Validity").start_object();
crate::json_ser::serialize_structure_crate_model_validity(&mut object_46, var_45)?;
object_46.finish();
}
if let Some(var_47) = &input.validity_not_before {
#[allow(unused_mut)]
let mut object_48 = object.key("ValidityNotBefore").start_object();
crate::json_ser::serialize_structure_crate_model_validity(&mut object_48, var_47)?;
object_48.finish();
}
if let Some(var_49) = &input.idempotency_token {
object.key("IdempotencyToken").string(var_49.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_certificate_authorities_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListCertificateAuthoritiesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_50) = &input.next_token {
object.key("NextToken").string(var_50.as_str());
}
if let Some(var_51) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_51).into()),
);
}
if let Some(var_52) = &input.resource_owner {
object.key("ResourceOwner").string(var_52.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_permissions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListPermissionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_53) = &input.certificate_authority_arn {
object
.key("CertificateAuthorityArn")
.string(var_53.as_str());
}
if let Some(var_54) = &input.next_token {
object.key("NextToken").string(var_54.as_str());
}
if let Some(var_55) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_55).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_tags_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListTagsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_56) = &input.certificate_authority_arn {
object
.key("CertificateAuthorityArn")
.string(var_56.as_str());
}
if let Some(var_57) = &input.next_token {
object.key("NextToken").string(var_57.as_str());
}
if let Some(var_58) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_58).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_put_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutPolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_59) = &input.resource_arn {
object.key("ResourceArn").string(var_59.as_str());
}
if let Some(var_60) = &input.policy {
object.key("Policy").string(var_60.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_restore_certificate_authority_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RestoreCertificateAuthorityInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_61) = &input.certificate_authority_arn {
object
.key("CertificateAuthorityArn")
.string(var_61.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_revoke_certificate_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RevokeCertificateInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_62) = &input.certificate_authority_arn {
object
.key("CertificateAuthorityArn")
.string(var_62.as_str());
}
if let Some(var_63) = &input.certificate_serial {
object.key("CertificateSerial").string(var_63.as_str());
}
if let Some(var_64) = &input.revocation_reason {
object.key("RevocationReason").string(var_64.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_tag_certificate_authority_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::TagCertificateAuthorityInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_65) = &input.certificate_authority_arn {
object
.key("CertificateAuthorityArn")
.string(var_65.as_str());
}
if let Some(var_66) = &input.tags {
let mut array_67 = object.key("Tags").start_array();
for item_68 in var_66 {
{
#[allow(unused_mut)]
let mut object_69 = array_67.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_69, item_68)?;
object_69.finish();
}
}
array_67.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_untag_certificate_authority_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UntagCertificateAuthorityInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_70) = &input.certificate_authority_arn {
object
.key("CertificateAuthorityArn")
.string(var_70.as_str());
}
if let Some(var_71) = &input.tags {
let mut array_72 = object.key("Tags").start_array();
for item_73 in var_71 {
{
#[allow(unused_mut)]
let mut object_74 = array_72.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_74, item_73)?;
object_74.finish();
}
}
array_72.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_certificate_authority_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateCertificateAuthorityInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_75) = &input.certificate_authority_arn {
object
.key("CertificateAuthorityArn")
.string(var_75.as_str());
}
if let Some(var_76) = &input.revocation_configuration {
#[allow(unused_mut)]
let mut object_77 = object.key("RevocationConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_revocation_configuration(
&mut object_77,
var_76,
)?;
object_77.finish();
}
if let Some(var_78) = &input.status {
object.key("Status").string(var_78.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_certificate_authority_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CertificateAuthorityConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_79) = &input.key_algorithm {
object.key("KeyAlgorithm").string(var_79.as_str());
}
if let Some(var_80) = &input.signing_algorithm {
object.key("SigningAlgorithm").string(var_80.as_str());
}
if let Some(var_81) = &input.subject {
#[allow(unused_mut)]
let mut object_82 = object.key("Subject").start_object();
crate::json_ser::serialize_structure_crate_model_asn1_subject(&mut object_82, var_81)?;
object_82.finish();
}
if let Some(var_83) = &input.csr_extensions {
#[allow(unused_mut)]
let mut object_84 = object.key("CsrExtensions").start_object();
crate::json_ser::serialize_structure_crate_model_csr_extensions(&mut object_84, var_83)?;
object_84.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_revocation_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RevocationConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_85) = &input.crl_configuration {
#[allow(unused_mut)]
let mut object_86 = object.key("CrlConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_crl_configuration(&mut object_86, var_85)?;
object_86.finish();
}
if let Some(var_87) = &input.ocsp_configuration {
#[allow(unused_mut)]
let mut object_88 = object.key("OcspConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_ocsp_configuration(
&mut object_88,
var_87,
)?;
object_88.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_tag(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Tag,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_89) = &input.key {
object.key("Key").string(var_89.as_str());
}
if let Some(var_90) = &input.value {
object.key("Value").string(var_90.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_api_passthrough(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ApiPassthrough,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_91) = &input.extensions {
#[allow(unused_mut)]
let mut object_92 = object.key("Extensions").start_object();
crate::json_ser::serialize_structure_crate_model_extensions(&mut object_92, var_91)?;
object_92.finish();
}
if let Some(var_93) = &input.subject {
#[allow(unused_mut)]
let mut object_94 = object.key("Subject").start_object();
crate::json_ser::serialize_structure_crate_model_asn1_subject(&mut object_94, var_93)?;
object_94.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_validity(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Validity,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_95) = &input.value {
object.key("Value").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_95).into()),
);
}
if let Some(var_96) = &input.r#type {
object.key("Type").string(var_96.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_asn1_subject(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Asn1Subject,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_97) = &input.country {
object.key("Country").string(var_97.as_str());
}
if let Some(var_98) = &input.organization {
object.key("Organization").string(var_98.as_str());
}
if let Some(var_99) = &input.organizational_unit {
object.key("OrganizationalUnit").string(var_99.as_str());
}
if let Some(var_100) = &input.distinguished_name_qualifier {
object
.key("DistinguishedNameQualifier")
.string(var_100.as_str());
}
if let Some(var_101) = &input.state {
object.key("State").string(var_101.as_str());
}
if let Some(var_102) = &input.common_name {
object.key("CommonName").string(var_102.as_str());
}
if let Some(var_103) = &input.serial_number {
object.key("SerialNumber").string(var_103.as_str());
}
if let Some(var_104) = &input.locality {
object.key("Locality").string(var_104.as_str());
}
if let Some(var_105) = &input.title {
object.key("Title").string(var_105.as_str());
}
if let Some(var_106) = &input.surname {
object.key("Surname").string(var_106.as_str());
}
if let Some(var_107) = &input.given_name {
object.key("GivenName").string(var_107.as_str());
}
if let Some(var_108) = &input.initials {
object.key("Initials").string(var_108.as_str());
}
if let Some(var_109) = &input.pseudonym {
object.key("Pseudonym").string(var_109.as_str());
}
if let Some(var_110) = &input.generation_qualifier {
object.key("GenerationQualifier").string(var_110.as_str());
}
if let Some(var_111) = &input.custom_attributes {
let mut array_112 = object.key("CustomAttributes").start_array();
for item_113 in var_111 {
{
#[allow(unused_mut)]
let mut object_114 = array_112.value().start_object();
crate::json_ser::serialize_structure_crate_model_custom_attribute(
&mut object_114,
item_113,
)?;
object_114.finish();
}
}
array_112.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_csr_extensions(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CsrExtensions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_115) = &input.key_usage {
#[allow(unused_mut)]
let mut object_116 = object.key("KeyUsage").start_object();
crate::json_ser::serialize_structure_crate_model_key_usage(&mut object_116, var_115)?;
object_116.finish();
}
if let Some(var_117) = &input.subject_information_access {
let mut array_118 = object.key("SubjectInformationAccess").start_array();
for item_119 in var_117 {
{
#[allow(unused_mut)]
let mut object_120 = array_118.value().start_object();
crate::json_ser::serialize_structure_crate_model_access_description(
&mut object_120,
item_119,
)?;
object_120.finish();
}
}
array_118.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_crl_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CrlConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_121) = &input.enabled {
object.key("Enabled").boolean(*var_121);
}
if let Some(var_122) = &input.expiration_in_days {
object.key("ExpirationInDays").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_122).into()),
);
}
if let Some(var_123) = &input.custom_cname {
object.key("CustomCname").string(var_123.as_str());
}
if let Some(var_124) = &input.s3_bucket_name {
object.key("S3BucketName").string(var_124.as_str());
}
if let Some(var_125) = &input.s3_object_acl {
object.key("S3ObjectAcl").string(var_125.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_ocsp_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OcspConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_126) = &input.enabled {
object.key("Enabled").boolean(*var_126);
}
if let Some(var_127) = &input.ocsp_custom_cname {
object.key("OcspCustomCname").string(var_127.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_extensions(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Extensions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_128) = &input.certificate_policies {
let mut array_129 = object.key("CertificatePolicies").start_array();
for item_130 in var_128 {
{
#[allow(unused_mut)]
let mut object_131 = array_129.value().start_object();
crate::json_ser::serialize_structure_crate_model_policy_information(
&mut object_131,
item_130,
)?;
object_131.finish();
}
}
array_129.finish();
}
if let Some(var_132) = &input.extended_key_usage {
let mut array_133 = object.key("ExtendedKeyUsage").start_array();
for item_134 in var_132 {
{
#[allow(unused_mut)]
let mut object_135 = array_133.value().start_object();
crate::json_ser::serialize_structure_crate_model_extended_key_usage(
&mut object_135,
item_134,
)?;
object_135.finish();
}
}
array_133.finish();
}
if let Some(var_136) = &input.key_usage {
#[allow(unused_mut)]
let mut object_137 = object.key("KeyUsage").start_object();
crate::json_ser::serialize_structure_crate_model_key_usage(&mut object_137, var_136)?;
object_137.finish();
}
if let Some(var_138) = &input.subject_alternative_names {
let mut array_139 = object.key("SubjectAlternativeNames").start_array();
for item_140 in var_138 {
{
#[allow(unused_mut)]
let mut object_141 = array_139.value().start_object();
crate::json_ser::serialize_structure_crate_model_general_name(
&mut object_141,
item_140,
)?;
object_141.finish();
}
}
array_139.finish();
}
if let Some(var_142) = &input.custom_extensions {
let mut array_143 = object.key("CustomExtensions").start_array();
for item_144 in var_142 {
{
#[allow(unused_mut)]
let mut object_145 = array_143.value().start_object();
crate::json_ser::serialize_structure_crate_model_custom_extension(
&mut object_145,
item_144,
)?;
object_145.finish();
}
}
array_143.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_custom_attribute(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CustomAttribute,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_146) = &input.object_identifier {
object.key("ObjectIdentifier").string(var_146.as_str());
}
if let Some(var_147) = &input.value {
object.key("Value").string(var_147.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_key_usage(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::KeyUsage,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.digital_signature {
object
.key("DigitalSignature")
.boolean(input.digital_signature);
}
if input.non_repudiation {
object.key("NonRepudiation").boolean(input.non_repudiation);
}
if input.key_encipherment {
object
.key("KeyEncipherment")
.boolean(input.key_encipherment);
}
if input.data_encipherment {
object
.key("DataEncipherment")
.boolean(input.data_encipherment);
}
if input.key_agreement {
object.key("KeyAgreement").boolean(input.key_agreement);
}
if input.key_cert_sign {
object.key("KeyCertSign").boolean(input.key_cert_sign);
}
if input.crl_sign {
object.key("CRLSign").boolean(input.crl_sign);
}
if input.encipher_only {
object.key("EncipherOnly").boolean(input.encipher_only);
}
if input.decipher_only {
object.key("DecipherOnly").boolean(input.decipher_only);
}
Ok(())
}
pub fn serialize_structure_crate_model_access_description(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AccessDescription,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_148) = &input.access_method {
#[allow(unused_mut)]
let mut object_149 = object.key("AccessMethod").start_object();
crate::json_ser::serialize_structure_crate_model_access_method(&mut object_149, var_148)?;
object_149.finish();
}
if let Some(var_150) = &input.access_location {
#[allow(unused_mut)]
let mut object_151 = object.key("AccessLocation").start_object();
crate::json_ser::serialize_structure_crate_model_general_name(&mut object_151, var_150)?;
object_151.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_policy_information(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PolicyInformation,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_152) = &input.cert_policy_id {
object.key("CertPolicyId").string(var_152.as_str());
}
if let Some(var_153) = &input.policy_qualifiers {
let mut array_154 = object.key("PolicyQualifiers").start_array();
for item_155 in var_153 {
{
#[allow(unused_mut)]
let mut object_156 = array_154.value().start_object();
crate::json_ser::serialize_structure_crate_model_policy_qualifier_info(
&mut object_156,
item_155,
)?;
object_156.finish();
}
}
array_154.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_extended_key_usage(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ExtendedKeyUsage,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_157) = &input.extended_key_usage_type {
object.key("ExtendedKeyUsageType").string(var_157.as_str());
}
if let Some(var_158) = &input.extended_key_usage_object_identifier {
object
.key("ExtendedKeyUsageObjectIdentifier")
.string(var_158.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_general_name(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GeneralName,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_159) = &input.other_name {
#[allow(unused_mut)]
let mut object_160 = object.key("OtherName").start_object();
crate::json_ser::serialize_structure_crate_model_other_name(&mut object_160, var_159)?;
object_160.finish();
}
if let Some(var_161) = &input.rfc822_name {
object.key("Rfc822Name").string(var_161.as_str());
}
if let Some(var_162) = &input.dns_name {
object.key("DnsName").string(var_162.as_str());
}
if let Some(var_163) = &input.directory_name {
#[allow(unused_mut)]
let mut object_164 = object.key("DirectoryName").start_object();
crate::json_ser::serialize_structure_crate_model_asn1_subject(&mut object_164, var_163)?;
object_164.finish();
}
if let Some(var_165) = &input.edi_party_name {
#[allow(unused_mut)]
let mut object_166 = object.key("EdiPartyName").start_object();
crate::json_ser::serialize_structure_crate_model_edi_party_name(&mut object_166, var_165)?;
object_166.finish();
}
if let Some(var_167) = &input.uniform_resource_identifier {
object
.key("UniformResourceIdentifier")
.string(var_167.as_str());
}
if let Some(var_168) = &input.ip_address {
object.key("IpAddress").string(var_168.as_str());
}
if let Some(var_169) = &input.registered_id {
object.key("RegisteredId").string(var_169.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_custom_extension(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CustomExtension,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_170) = &input.object_identifier {
object.key("ObjectIdentifier").string(var_170.as_str());
}
if let Some(var_171) = &input.value {
object.key("Value").string(var_171.as_str());
}
if let Some(var_172) = &input.critical {
object.key("Critical").boolean(*var_172);
}
Ok(())
}
pub fn serialize_structure_crate_model_access_method(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AccessMethod,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_173) = &input.custom_object_identifier {
object
.key("CustomObjectIdentifier")
.string(var_173.as_str());
}
if let Some(var_174) = &input.access_method_type {
object.key("AccessMethodType").string(var_174.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_policy_qualifier_info(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PolicyQualifierInfo,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_175) = &input.policy_qualifier_id {
object.key("PolicyQualifierId").string(var_175.as_str());
}
if let Some(var_176) = &input.qualifier {
#[allow(unused_mut)]
let mut object_177 = object.key("Qualifier").start_object();
crate::json_ser::serialize_structure_crate_model_qualifier(&mut object_177, var_176)?;
object_177.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_other_name(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OtherName,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_178) = &input.type_id {
object.key("TypeId").string(var_178.as_str());
}
if let Some(var_179) = &input.value {
object.key("Value").string(var_179.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_edi_party_name(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EdiPartyName,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_180) = &input.party_name {
object.key("PartyName").string(var_180.as_str());
}
if let Some(var_181) = &input.name_assigner {
object.key("NameAssigner").string(var_181.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_qualifier(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Qualifier,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_182) = &input.cps_uri {
object.key("CpsUri").string(var_182.as_str());
}
Ok(())
}