pub fn serialize_structure_crate_input_add_tags_to_vault_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AddTagsToVaultInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.tags {
#[allow(unused_mut)]
let mut object_2 = object.key("Tags").start_object();
for (key_3, value_4) in var_1 {
{
object_2.key(key_3.as_str()).string(value_4.as_str());
}
}
object_2.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_remove_tags_from_vault_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RemoveTagsFromVaultInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_5) = &input.tag_keys {
let mut array_6 = object.key("TagKeys").start_array();
for item_7 in var_5 {
{
array_6.value().string(item_7.as_str());
}
}
array_6.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_set_data_retrieval_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::SetDataRetrievalPolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_8) = &input.policy {
#[allow(unused_mut)]
let mut object_9 = object.key("Policy").start_object();
crate::json_ser::serialize_structure_crate_model_data_retrieval_policy(
&mut object_9,
var_8,
)?;
object_9.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_data_retrieval_policy(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DataRetrievalPolicy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_10) = &input.rules {
let mut array_11 = object.key("Rules").start_array();
for item_12 in var_10 {
{
#[allow(unused_mut)]
let mut object_13 = array_11.value().start_object();
crate::json_ser::serialize_structure_crate_model_data_retrieval_rule(
&mut object_13,
item_12,
)?;
object_13.finish();
}
}
array_11.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_job_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::JobParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_14) = &input.format {
object.key("Format").string(var_14.as_str());
}
if let Some(var_15) = &input.r#type {
object.key("Type").string(var_15.as_str());
}
if let Some(var_16) = &input.archive_id {
object.key("ArchiveId").string(var_16.as_str());
}
if let Some(var_17) = &input.description {
object.key("Description").string(var_17.as_str());
}
if let Some(var_18) = &input.sns_topic {
object.key("SNSTopic").string(var_18.as_str());
}
if let Some(var_19) = &input.retrieval_byte_range {
object.key("RetrievalByteRange").string(var_19.as_str());
}
if let Some(var_20) = &input.tier {
object.key("Tier").string(var_20.as_str());
}
if let Some(var_21) = &input.inventory_retrieval_parameters {
#[allow(unused_mut)]
let mut object_22 = object.key("InventoryRetrievalParameters").start_object();
crate::json_ser::serialize_structure_crate_model_inventory_retrieval_job_input(
&mut object_22,
var_21,
)?;
object_22.finish();
}
if let Some(var_23) = &input.select_parameters {
#[allow(unused_mut)]
let mut object_24 = object.key("SelectParameters").start_object();
crate::json_ser::serialize_structure_crate_model_select_parameters(&mut object_24, var_23)?;
object_24.finish();
}
if let Some(var_25) = &input.output_location {
#[allow(unused_mut)]
let mut object_26 = object.key("OutputLocation").start_object();
crate::json_ser::serialize_structure_crate_model_output_location(&mut object_26, var_25)?;
object_26.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_vault_lock_policy(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::VaultLockPolicy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_27) = &input.policy {
object.key("Policy").string(var_27.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_vault_access_policy(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::VaultAccessPolicy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_28) = &input.policy {
object.key("Policy").string(var_28.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_vault_notification_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::VaultNotificationConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_29) = &input.sns_topic {
object.key("SNSTopic").string(var_29.as_str());
}
if let Some(var_30) = &input.events {
let mut array_31 = object.key("Events").start_array();
for item_32 in var_30 {
{
array_31.value().string(item_32.as_str());
}
}
array_31.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_data_retrieval_rule(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DataRetrievalRule,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_33) = &input.strategy {
object.key("Strategy").string(var_33.as_str());
}
if let Some(var_34) = &input.bytes_per_hour {
object.key("BytesPerHour").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_34).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_inventory_retrieval_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::InventoryRetrievalJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_35) = &input.start_date {
object.key("StartDate").string(var_35.as_str());
}
if let Some(var_36) = &input.end_date {
object.key("EndDate").string(var_36.as_str());
}
if let Some(var_37) = &input.limit {
object.key("Limit").string(var_37.as_str());
}
if let Some(var_38) = &input.marker {
object.key("Marker").string(var_38.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_select_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SelectParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_39) = &input.input_serialization {
#[allow(unused_mut)]
let mut object_40 = object.key("InputSerialization").start_object();
crate::json_ser::serialize_structure_crate_model_input_serialization(
&mut object_40,
var_39,
)?;
object_40.finish();
}
if let Some(var_41) = &input.expression_type {
object.key("ExpressionType").string(var_41.as_str());
}
if let Some(var_42) = &input.expression {
object.key("Expression").string(var_42.as_str());
}
if let Some(var_43) = &input.output_serialization {
#[allow(unused_mut)]
let mut object_44 = object.key("OutputSerialization").start_object();
crate::json_ser::serialize_structure_crate_model_output_serialization(
&mut object_44,
var_43,
)?;
object_44.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_output_location(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OutputLocation,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_45) = &input.s3 {
#[allow(unused_mut)]
let mut object_46 = object.key("S3").start_object();
crate::json_ser::serialize_structure_crate_model_s3_location(&mut object_46, var_45)?;
object_46.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_input_serialization(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::InputSerialization,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_47) = &input.csv {
#[allow(unused_mut)]
let mut object_48 = object.key("csv").start_object();
crate::json_ser::serialize_structure_crate_model_csv_input(&mut object_48, var_47)?;
object_48.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_output_serialization(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OutputSerialization,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_49) = &input.csv {
#[allow(unused_mut)]
let mut object_50 = object.key("csv").start_object();
crate::json_ser::serialize_structure_crate_model_csv_output(&mut object_50, var_49)?;
object_50.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_s3_location(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::S3Location,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_51) = &input.bucket_name {
object.key("BucketName").string(var_51.as_str());
}
if let Some(var_52) = &input.prefix {
object.key("Prefix").string(var_52.as_str());
}
if let Some(var_53) = &input.encryption {
#[allow(unused_mut)]
let mut object_54 = object.key("Encryption").start_object();
crate::json_ser::serialize_structure_crate_model_encryption(&mut object_54, var_53)?;
object_54.finish();
}
if let Some(var_55) = &input.canned_acl {
object.key("CannedACL").string(var_55.as_str());
}
if let Some(var_56) = &input.access_control_list {
let mut array_57 = object.key("AccessControlList").start_array();
for item_58 in var_56 {
{
#[allow(unused_mut)]
let mut object_59 = array_57.value().start_object();
crate::json_ser::serialize_structure_crate_model_grant(&mut object_59, item_58)?;
object_59.finish();
}
}
array_57.finish();
}
if let Some(var_60) = &input.tagging {
#[allow(unused_mut)]
let mut object_61 = object.key("Tagging").start_object();
for (key_62, value_63) in var_60 {
{
object_61.key(key_62.as_str()).string(value_63.as_str());
}
}
object_61.finish();
}
if let Some(var_64) = &input.user_metadata {
#[allow(unused_mut)]
let mut object_65 = object.key("UserMetadata").start_object();
for (key_66, value_67) in var_64 {
{
object_65.key(key_66.as_str()).string(value_67.as_str());
}
}
object_65.finish();
}
if let Some(var_68) = &input.storage_class {
object.key("StorageClass").string(var_68.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_csv_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CsvInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_69) = &input.file_header_info {
object.key("FileHeaderInfo").string(var_69.as_str());
}
if let Some(var_70) = &input.comments {
object.key("Comments").string(var_70.as_str());
}
if let Some(var_71) = &input.quote_escape_character {
object.key("QuoteEscapeCharacter").string(var_71.as_str());
}
if let Some(var_72) = &input.record_delimiter {
object.key("RecordDelimiter").string(var_72.as_str());
}
if let Some(var_73) = &input.field_delimiter {
object.key("FieldDelimiter").string(var_73.as_str());
}
if let Some(var_74) = &input.quote_character {
object.key("QuoteCharacter").string(var_74.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_csv_output(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CsvOutput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_75) = &input.quote_fields {
object.key("QuoteFields").string(var_75.as_str());
}
if let Some(var_76) = &input.quote_escape_character {
object.key("QuoteEscapeCharacter").string(var_76.as_str());
}
if let Some(var_77) = &input.record_delimiter {
object.key("RecordDelimiter").string(var_77.as_str());
}
if let Some(var_78) = &input.field_delimiter {
object.key("FieldDelimiter").string(var_78.as_str());
}
if let Some(var_79) = &input.quote_character {
object.key("QuoteCharacter").string(var_79.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_encryption(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Encryption,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_80) = &input.encryption_type {
object.key("EncryptionType").string(var_80.as_str());
}
if let Some(var_81) = &input.kms_key_id {
object.key("KMSKeyId").string(var_81.as_str());
}
if let Some(var_82) = &input.kms_context {
object.key("KMSContext").string(var_82.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_grant(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Grant,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_83) = &input.grantee {
#[allow(unused_mut)]
let mut object_84 = object.key("Grantee").start_object();
crate::json_ser::serialize_structure_crate_model_grantee(&mut object_84, var_83)?;
object_84.finish();
}
if let Some(var_85) = &input.permission {
object.key("Permission").string(var_85.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_grantee(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Grantee,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_86) = &input.r#type {
object.key("Type").string(var_86.as_str());
}
if let Some(var_87) = &input.display_name {
object.key("DisplayName").string(var_87.as_str());
}
if let Some(var_88) = &input.uri {
object.key("URI").string(var_88.as_str());
}
if let Some(var_89) = &input.id {
object.key("ID").string(var_89.as_str());
}
if let Some(var_90) = &input.email_address {
object.key("EmailAddress").string(var_90.as_str());
}
Ok(())
}