pub fn serialize_structure_crate_input_cancel_task_execution_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CancelTaskExecutionInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_1) = &input.task_execution_arn {
object.key("TaskExecutionArn").string(var_1);
}
Ok(())
}
pub fn serialize_structure_crate_input_create_agent_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateAgentInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_2) = &input.activation_key {
object.key("ActivationKey").string(var_2);
}
if let Some(var_3) = &input.agent_name {
object.key("AgentName").string(var_3);
}
if let Some(var_4) = &input.tags {
let mut array_5 = object.key("Tags").start_array();
for item_6 in var_4 {
{
let mut object_7 = array_5.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag_list_entry(
&mut object_7,
item_6,
)?;
object_7.finish();
}
}
array_5.finish();
}
if let Some(var_8) = &input.vpc_endpoint_id {
object.key("VpcEndpointId").string(var_8);
}
if let Some(var_9) = &input.subnet_arns {
let mut array_10 = object.key("SubnetArns").start_array();
for item_11 in var_9 {
{
array_10.value().string(item_11);
}
}
array_10.finish();
}
if let Some(var_12) = &input.security_group_arns {
let mut array_13 = object.key("SecurityGroupArns").start_array();
for item_14 in var_12 {
{
array_13.value().string(item_14);
}
}
array_13.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_location_efs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateLocationEfsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_15) = &input.subdirectory {
object.key("Subdirectory").string(var_15);
}
if let Some(var_16) = &input.efs_filesystem_arn {
object.key("EfsFilesystemArn").string(var_16);
}
if let Some(var_17) = &input.ec2_config {
let mut object_18 = object.key("Ec2Config").start_object();
crate::json_ser::serialize_structure_crate_model_ec2_config(&mut object_18, var_17)?;
object_18.finish();
}
if let Some(var_19) = &input.tags {
let mut array_20 = object.key("Tags").start_array();
for item_21 in var_19 {
{
let mut object_22 = array_20.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag_list_entry(
&mut object_22,
item_21,
)?;
object_22.finish();
}
}
array_20.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_location_fsx_lustre_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateLocationFsxLustreInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_23) = &input.fsx_filesystem_arn {
object.key("FsxFilesystemArn").string(var_23);
}
if let Some(var_24) = &input.security_group_arns {
let mut array_25 = object.key("SecurityGroupArns").start_array();
for item_26 in var_24 {
{
array_25.value().string(item_26);
}
}
array_25.finish();
}
if let Some(var_27) = &input.subdirectory {
object.key("Subdirectory").string(var_27);
}
if let Some(var_28) = &input.tags {
let mut array_29 = object.key("Tags").start_array();
for item_30 in var_28 {
{
let mut object_31 = array_29.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag_list_entry(
&mut object_31,
item_30,
)?;
object_31.finish();
}
}
array_29.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_location_fsx_windows_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateLocationFsxWindowsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_32) = &input.subdirectory {
object.key("Subdirectory").string(var_32);
}
if let Some(var_33) = &input.fsx_filesystem_arn {
object.key("FsxFilesystemArn").string(var_33);
}
if let Some(var_34) = &input.security_group_arns {
let mut array_35 = object.key("SecurityGroupArns").start_array();
for item_36 in var_34 {
{
array_35.value().string(item_36);
}
}
array_35.finish();
}
if let Some(var_37) = &input.tags {
let mut array_38 = object.key("Tags").start_array();
for item_39 in var_37 {
{
let mut object_40 = array_38.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag_list_entry(
&mut object_40,
item_39,
)?;
object_40.finish();
}
}
array_38.finish();
}
if let Some(var_41) = &input.user {
object.key("User").string(var_41);
}
if let Some(var_42) = &input.domain {
object.key("Domain").string(var_42);
}
if let Some(var_43) = &input.password {
object.key("Password").string(var_43);
}
Ok(())
}
pub fn serialize_structure_crate_input_create_location_hdfs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateLocationHdfsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_44) = &input.subdirectory {
object.key("Subdirectory").string(var_44);
}
if let Some(var_45) = &input.name_nodes {
let mut array_46 = object.key("NameNodes").start_array();
for item_47 in var_45 {
{
let mut object_48 = array_46.value().start_object();
crate::json_ser::serialize_structure_crate_model_hdfs_name_node(
&mut object_48,
item_47,
)?;
object_48.finish();
}
}
array_46.finish();
}
if let Some(var_49) = &input.block_size {
object.key("BlockSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_49).into()),
);
}
if let Some(var_50) = &input.replication_factor {
object.key("ReplicationFactor").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_50).into()),
);
}
if let Some(var_51) = &input.kms_key_provider_uri {
object.key("KmsKeyProviderUri").string(var_51);
}
if let Some(var_52) = &input.qop_configuration {
let mut object_53 = object.key("QopConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_qop_configuration(&mut object_53, var_52)?;
object_53.finish();
}
if let Some(var_54) = &input.authentication_type {
object.key("AuthenticationType").string(var_54.as_str());
}
if let Some(var_55) = &input.simple_user {
object.key("SimpleUser").string(var_55);
}
if let Some(var_56) = &input.kerberos_principal {
object.key("KerberosPrincipal").string(var_56);
}
if let Some(var_57) = &input.kerberos_keytab {
object
.key("KerberosKeytab")
.string_unchecked(&aws_smithy_types::base64::encode(var_57));
}
if let Some(var_58) = &input.kerberos_krb5_conf {
object
.key("KerberosKrb5Conf")
.string_unchecked(&aws_smithy_types::base64::encode(var_58));
}
if let Some(var_59) = &input.agent_arns {
let mut array_60 = object.key("AgentArns").start_array();
for item_61 in var_59 {
{
array_60.value().string(item_61);
}
}
array_60.finish();
}
if let Some(var_62) = &input.tags {
let mut array_63 = object.key("Tags").start_array();
for item_64 in var_62 {
{
let mut object_65 = array_63.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag_list_entry(
&mut object_65,
item_64,
)?;
object_65.finish();
}
}
array_63.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_location_nfs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateLocationNfsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_66) = &input.subdirectory {
object.key("Subdirectory").string(var_66);
}
if let Some(var_67) = &input.server_hostname {
object.key("ServerHostname").string(var_67);
}
if let Some(var_68) = &input.on_prem_config {
let mut object_69 = object.key("OnPremConfig").start_object();
crate::json_ser::serialize_structure_crate_model_on_prem_config(&mut object_69, var_68)?;
object_69.finish();
}
if let Some(var_70) = &input.mount_options {
let mut object_71 = object.key("MountOptions").start_object();
crate::json_ser::serialize_structure_crate_model_nfs_mount_options(&mut object_71, var_70)?;
object_71.finish();
}
if let Some(var_72) = &input.tags {
let mut array_73 = object.key("Tags").start_array();
for item_74 in var_72 {
{
let mut object_75 = array_73.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag_list_entry(
&mut object_75,
item_74,
)?;
object_75.finish();
}
}
array_73.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_location_object_storage_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateLocationObjectStorageInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_76) = &input.server_hostname {
object.key("ServerHostname").string(var_76);
}
if let Some(var_77) = &input.server_port {
object.key("ServerPort").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_77).into()),
);
}
if let Some(var_78) = &input.server_protocol {
object.key("ServerProtocol").string(var_78.as_str());
}
if let Some(var_79) = &input.subdirectory {
object.key("Subdirectory").string(var_79);
}
if let Some(var_80) = &input.bucket_name {
object.key("BucketName").string(var_80);
}
if let Some(var_81) = &input.access_key {
object.key("AccessKey").string(var_81);
}
if let Some(var_82) = &input.secret_key {
object.key("SecretKey").string(var_82);
}
if let Some(var_83) = &input.agent_arns {
let mut array_84 = object.key("AgentArns").start_array();
for item_85 in var_83 {
{
array_84.value().string(item_85);
}
}
array_84.finish();
}
if let Some(var_86) = &input.tags {
let mut array_87 = object.key("Tags").start_array();
for item_88 in var_86 {
{
let mut object_89 = array_87.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag_list_entry(
&mut object_89,
item_88,
)?;
object_89.finish();
}
}
array_87.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_location_s3_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateLocationS3Input,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_90) = &input.subdirectory {
object.key("Subdirectory").string(var_90);
}
if let Some(var_91) = &input.s3_bucket_arn {
object.key("S3BucketArn").string(var_91);
}
if let Some(var_92) = &input.s3_storage_class {
object.key("S3StorageClass").string(var_92.as_str());
}
if let Some(var_93) = &input.s3_config {
let mut object_94 = object.key("S3Config").start_object();
crate::json_ser::serialize_structure_crate_model_s3_config(&mut object_94, var_93)?;
object_94.finish();
}
if let Some(var_95) = &input.agent_arns {
let mut array_96 = object.key("AgentArns").start_array();
for item_97 in var_95 {
{
array_96.value().string(item_97);
}
}
array_96.finish();
}
if let Some(var_98) = &input.tags {
let mut array_99 = object.key("Tags").start_array();
for item_100 in var_98 {
{
let mut object_101 = array_99.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag_list_entry(
&mut object_101,
item_100,
)?;
object_101.finish();
}
}
array_99.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_location_smb_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateLocationSmbInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_102) = &input.subdirectory {
object.key("Subdirectory").string(var_102);
}
if let Some(var_103) = &input.server_hostname {
object.key("ServerHostname").string(var_103);
}
if let Some(var_104) = &input.user {
object.key("User").string(var_104);
}
if let Some(var_105) = &input.domain {
object.key("Domain").string(var_105);
}
if let Some(var_106) = &input.password {
object.key("Password").string(var_106);
}
if let Some(var_107) = &input.agent_arns {
let mut array_108 = object.key("AgentArns").start_array();
for item_109 in var_107 {
{
array_108.value().string(item_109);
}
}
array_108.finish();
}
if let Some(var_110) = &input.mount_options {
let mut object_111 = object.key("MountOptions").start_object();
crate::json_ser::serialize_structure_crate_model_smb_mount_options(
&mut object_111,
var_110,
)?;
object_111.finish();
}
if let Some(var_112) = &input.tags {
let mut array_113 = object.key("Tags").start_array();
for item_114 in var_112 {
{
let mut object_115 = array_113.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag_list_entry(
&mut object_115,
item_114,
)?;
object_115.finish();
}
}
array_113.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_task_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateTaskInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_116) = &input.source_location_arn {
object.key("SourceLocationArn").string(var_116);
}
if let Some(var_117) = &input.destination_location_arn {
object.key("DestinationLocationArn").string(var_117);
}
if let Some(var_118) = &input.cloud_watch_log_group_arn {
object.key("CloudWatchLogGroupArn").string(var_118);
}
if let Some(var_119) = &input.name {
object.key("Name").string(var_119);
}
if let Some(var_120) = &input.options {
let mut object_121 = object.key("Options").start_object();
crate::json_ser::serialize_structure_crate_model_options(&mut object_121, var_120)?;
object_121.finish();
}
if let Some(var_122) = &input.excludes {
let mut array_123 = object.key("Excludes").start_array();
for item_124 in var_122 {
{
let mut object_125 = array_123.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter_rule(
&mut object_125,
item_124,
)?;
object_125.finish();
}
}
array_123.finish();
}
if let Some(var_126) = &input.schedule {
let mut object_127 = object.key("Schedule").start_object();
crate::json_ser::serialize_structure_crate_model_task_schedule(&mut object_127, var_126)?;
object_127.finish();
}
if let Some(var_128) = &input.tags {
let mut array_129 = object.key("Tags").start_array();
for item_130 in var_128 {
{
let mut object_131 = array_129.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag_list_entry(
&mut object_131,
item_130,
)?;
object_131.finish();
}
}
array_129.finish();
}
if let Some(var_132) = &input.includes {
let mut array_133 = object.key("Includes").start_array();
for item_134 in var_132 {
{
let mut object_135 = array_133.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter_rule(
&mut object_135,
item_134,
)?;
object_135.finish();
}
}
array_133.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_agent_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteAgentInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_136) = &input.agent_arn {
object.key("AgentArn").string(var_136);
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_location_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteLocationInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_137) = &input.location_arn {
object.key("LocationArn").string(var_137);
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_task_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteTaskInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_138) = &input.task_arn {
object.key("TaskArn").string(var_138);
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_agent_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeAgentInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_139) = &input.agent_arn {
object.key("AgentArn").string(var_139);
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_location_efs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeLocationEfsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_140) = &input.location_arn {
object.key("LocationArn").string(var_140);
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_location_fsx_lustre_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeLocationFsxLustreInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_141) = &input.location_arn {
object.key("LocationArn").string(var_141);
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_location_fsx_windows_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeLocationFsxWindowsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_142) = &input.location_arn {
object.key("LocationArn").string(var_142);
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_location_hdfs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeLocationHdfsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_143) = &input.location_arn {
object.key("LocationArn").string(var_143);
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_location_nfs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeLocationNfsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_144) = &input.location_arn {
object.key("LocationArn").string(var_144);
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_location_object_storage_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeLocationObjectStorageInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_145) = &input.location_arn {
object.key("LocationArn").string(var_145);
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_location_s3_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeLocationS3Input,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_146) = &input.location_arn {
object.key("LocationArn").string(var_146);
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_location_smb_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeLocationSmbInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_147) = &input.location_arn {
object.key("LocationArn").string(var_147);
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_task_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeTaskInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_148) = &input.task_arn {
object.key("TaskArn").string(var_148);
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_task_execution_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeTaskExecutionInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_149) = &input.task_execution_arn {
object.key("TaskExecutionArn").string(var_149);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_agents_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListAgentsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_150) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_150).into()),
);
}
if let Some(var_151) = &input.next_token {
object.key("NextToken").string(var_151);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_locations_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListLocationsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_152) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_152).into()),
);
}
if let Some(var_153) = &input.next_token {
object.key("NextToken").string(var_153);
}
if let Some(var_154) = &input.filters {
let mut array_155 = object.key("Filters").start_array();
for item_156 in var_154 {
{
let mut object_157 = array_155.value().start_object();
crate::json_ser::serialize_structure_crate_model_location_filter(
&mut object_157,
item_156,
)?;
object_157.finish();
}
}
array_155.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_tags_for_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListTagsForResourceInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_158) = &input.resource_arn {
object.key("ResourceArn").string(var_158);
}
if let Some(var_159) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_159).into()),
);
}
if let Some(var_160) = &input.next_token {
object.key("NextToken").string(var_160);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_task_executions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListTaskExecutionsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_161) = &input.task_arn {
object.key("TaskArn").string(var_161);
}
if let Some(var_162) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_162).into()),
);
}
if let Some(var_163) = &input.next_token {
object.key("NextToken").string(var_163);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_tasks_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListTasksInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_164) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_164).into()),
);
}
if let Some(var_165) = &input.next_token {
object.key("NextToken").string(var_165);
}
if let Some(var_166) = &input.filters {
let mut array_167 = object.key("Filters").start_array();
for item_168 in var_166 {
{
let mut object_169 = array_167.value().start_object();
crate::json_ser::serialize_structure_crate_model_task_filter(
&mut object_169,
item_168,
)?;
object_169.finish();
}
}
array_167.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_start_task_execution_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartTaskExecutionInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_170) = &input.task_arn {
object.key("TaskArn").string(var_170);
}
if let Some(var_171) = &input.override_options {
let mut object_172 = object.key("OverrideOptions").start_object();
crate::json_ser::serialize_structure_crate_model_options(&mut object_172, var_171)?;
object_172.finish();
}
if let Some(var_173) = &input.includes {
let mut array_174 = object.key("Includes").start_array();
for item_175 in var_173 {
{
let mut object_176 = array_174.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter_rule(
&mut object_176,
item_175,
)?;
object_176.finish();
}
}
array_174.finish();
}
if let Some(var_177) = &input.excludes {
let mut array_178 = object.key("Excludes").start_array();
for item_179 in var_177 {
{
let mut object_180 = array_178.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter_rule(
&mut object_180,
item_179,
)?;
object_180.finish();
}
}
array_178.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_tag_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::TagResourceInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_181) = &input.resource_arn {
object.key("ResourceArn").string(var_181);
}
if let Some(var_182) = &input.tags {
let mut array_183 = object.key("Tags").start_array();
for item_184 in var_182 {
{
let mut object_185 = array_183.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag_list_entry(
&mut object_185,
item_184,
)?;
object_185.finish();
}
}
array_183.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_untag_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UntagResourceInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_186) = &input.resource_arn {
object.key("ResourceArn").string(var_186);
}
if let Some(var_187) = &input.keys {
let mut array_188 = object.key("Keys").start_array();
for item_189 in var_187 {
{
array_188.value().string(item_189);
}
}
array_188.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_agent_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateAgentInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_190) = &input.agent_arn {
object.key("AgentArn").string(var_190);
}
if let Some(var_191) = &input.name {
object.key("Name").string(var_191);
}
Ok(())
}
pub fn serialize_structure_crate_input_update_location_hdfs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateLocationHdfsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_192) = &input.location_arn {
object.key("LocationArn").string(var_192);
}
if let Some(var_193) = &input.subdirectory {
object.key("Subdirectory").string(var_193);
}
if let Some(var_194) = &input.name_nodes {
let mut array_195 = object.key("NameNodes").start_array();
for item_196 in var_194 {
{
let mut object_197 = array_195.value().start_object();
crate::json_ser::serialize_structure_crate_model_hdfs_name_node(
&mut object_197,
item_196,
)?;
object_197.finish();
}
}
array_195.finish();
}
if let Some(var_198) = &input.block_size {
object.key("BlockSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_198).into()),
);
}
if let Some(var_199) = &input.replication_factor {
object.key("ReplicationFactor").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_199).into()),
);
}
if let Some(var_200) = &input.kms_key_provider_uri {
object.key("KmsKeyProviderUri").string(var_200);
}
if let Some(var_201) = &input.qop_configuration {
let mut object_202 = object.key("QopConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_qop_configuration(
&mut object_202,
var_201,
)?;
object_202.finish();
}
if let Some(var_203) = &input.authentication_type {
object.key("AuthenticationType").string(var_203.as_str());
}
if let Some(var_204) = &input.simple_user {
object.key("SimpleUser").string(var_204);
}
if let Some(var_205) = &input.kerberos_principal {
object.key("KerberosPrincipal").string(var_205);
}
if let Some(var_206) = &input.kerberos_keytab {
object
.key("KerberosKeytab")
.string_unchecked(&aws_smithy_types::base64::encode(var_206));
}
if let Some(var_207) = &input.kerberos_krb5_conf {
object
.key("KerberosKrb5Conf")
.string_unchecked(&aws_smithy_types::base64::encode(var_207));
}
if let Some(var_208) = &input.agent_arns {
let mut array_209 = object.key("AgentArns").start_array();
for item_210 in var_208 {
{
array_209.value().string(item_210);
}
}
array_209.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_location_nfs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateLocationNfsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_211) = &input.location_arn {
object.key("LocationArn").string(var_211);
}
if let Some(var_212) = &input.subdirectory {
object.key("Subdirectory").string(var_212);
}
if let Some(var_213) = &input.on_prem_config {
let mut object_214 = object.key("OnPremConfig").start_object();
crate::json_ser::serialize_structure_crate_model_on_prem_config(&mut object_214, var_213)?;
object_214.finish();
}
if let Some(var_215) = &input.mount_options {
let mut object_216 = object.key("MountOptions").start_object();
crate::json_ser::serialize_structure_crate_model_nfs_mount_options(
&mut object_216,
var_215,
)?;
object_216.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_location_object_storage_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateLocationObjectStorageInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_217) = &input.location_arn {
object.key("LocationArn").string(var_217);
}
if let Some(var_218) = &input.server_port {
object.key("ServerPort").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_218).into()),
);
}
if let Some(var_219) = &input.server_protocol {
object.key("ServerProtocol").string(var_219.as_str());
}
if let Some(var_220) = &input.subdirectory {
object.key("Subdirectory").string(var_220);
}
if let Some(var_221) = &input.access_key {
object.key("AccessKey").string(var_221);
}
if let Some(var_222) = &input.secret_key {
object.key("SecretKey").string(var_222);
}
if let Some(var_223) = &input.agent_arns {
let mut array_224 = object.key("AgentArns").start_array();
for item_225 in var_223 {
{
array_224.value().string(item_225);
}
}
array_224.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_location_smb_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateLocationSmbInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_226) = &input.location_arn {
object.key("LocationArn").string(var_226);
}
if let Some(var_227) = &input.subdirectory {
object.key("Subdirectory").string(var_227);
}
if let Some(var_228) = &input.user {
object.key("User").string(var_228);
}
if let Some(var_229) = &input.domain {
object.key("Domain").string(var_229);
}
if let Some(var_230) = &input.password {
object.key("Password").string(var_230);
}
if let Some(var_231) = &input.agent_arns {
let mut array_232 = object.key("AgentArns").start_array();
for item_233 in var_231 {
{
array_232.value().string(item_233);
}
}
array_232.finish();
}
if let Some(var_234) = &input.mount_options {
let mut object_235 = object.key("MountOptions").start_object();
crate::json_ser::serialize_structure_crate_model_smb_mount_options(
&mut object_235,
var_234,
)?;
object_235.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_task_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateTaskInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_236) = &input.task_arn {
object.key("TaskArn").string(var_236);
}
if let Some(var_237) = &input.options {
let mut object_238 = object.key("Options").start_object();
crate::json_ser::serialize_structure_crate_model_options(&mut object_238, var_237)?;
object_238.finish();
}
if let Some(var_239) = &input.excludes {
let mut array_240 = object.key("Excludes").start_array();
for item_241 in var_239 {
{
let mut object_242 = array_240.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter_rule(
&mut object_242,
item_241,
)?;
object_242.finish();
}
}
array_240.finish();
}
if let Some(var_243) = &input.schedule {
let mut object_244 = object.key("Schedule").start_object();
crate::json_ser::serialize_structure_crate_model_task_schedule(&mut object_244, var_243)?;
object_244.finish();
}
if let Some(var_245) = &input.name {
object.key("Name").string(var_245);
}
if let Some(var_246) = &input.cloud_watch_log_group_arn {
object.key("CloudWatchLogGroupArn").string(var_246);
}
if let Some(var_247) = &input.includes {
let mut array_248 = object.key("Includes").start_array();
for item_249 in var_247 {
{
let mut object_250 = array_248.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter_rule(
&mut object_250,
item_249,
)?;
object_250.finish();
}
}
array_248.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_task_execution_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateTaskExecutionInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_251) = &input.task_execution_arn {
object.key("TaskExecutionArn").string(var_251);
}
if let Some(var_252) = &input.options {
let mut object_253 = object.key("Options").start_object();
crate::json_ser::serialize_structure_crate_model_options(&mut object_253, var_252)?;
object_253.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_tag_list_entry(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TagListEntry,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_254) = &input.key {
object.key("Key").string(var_254);
}
if let Some(var_255) = &input.value {
object.key("Value").string(var_255);
}
Ok(())
}
pub fn serialize_structure_crate_model_ec2_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Ec2Config,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_256) = &input.subnet_arn {
object.key("SubnetArn").string(var_256);
}
if let Some(var_257) = &input.security_group_arns {
let mut array_258 = object.key("SecurityGroupArns").start_array();
for item_259 in var_257 {
{
array_258.value().string(item_259);
}
}
array_258.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_hdfs_name_node(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::HdfsNameNode,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_260) = &input.hostname {
object.key("Hostname").string(var_260);
}
if let Some(var_261) = &input.port {
object.key("Port").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_261).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_qop_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::QopConfiguration,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_262) = &input.rpc_protection {
object.key("RpcProtection").string(var_262.as_str());
}
if let Some(var_263) = &input.data_transfer_protection {
object
.key("DataTransferProtection")
.string(var_263.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_on_prem_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OnPremConfig,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_264) = &input.agent_arns {
let mut array_265 = object.key("AgentArns").start_array();
for item_266 in var_264 {
{
array_265.value().string(item_266);
}
}
array_265.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_nfs_mount_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::NfsMountOptions,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_267) = &input.version {
object.key("Version").string(var_267.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_s3_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::S3Config,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_268) = &input.bucket_access_role_arn {
object.key("BucketAccessRoleArn").string(var_268);
}
Ok(())
}
pub fn serialize_structure_crate_model_smb_mount_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SmbMountOptions,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_269) = &input.version {
object.key("Version").string(var_269.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Options,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_270) = &input.verify_mode {
object.key("VerifyMode").string(var_270.as_str());
}
if let Some(var_271) = &input.overwrite_mode {
object.key("OverwriteMode").string(var_271.as_str());
}
if let Some(var_272) = &input.atime {
object.key("Atime").string(var_272.as_str());
}
if let Some(var_273) = &input.mtime {
object.key("Mtime").string(var_273.as_str());
}
if let Some(var_274) = &input.uid {
object.key("Uid").string(var_274.as_str());
}
if let Some(var_275) = &input.gid {
object.key("Gid").string(var_275.as_str());
}
if let Some(var_276) = &input.preserve_deleted_files {
object.key("PreserveDeletedFiles").string(var_276.as_str());
}
if let Some(var_277) = &input.preserve_devices {
object.key("PreserveDevices").string(var_277.as_str());
}
if let Some(var_278) = &input.posix_permissions {
object.key("PosixPermissions").string(var_278.as_str());
}
if let Some(var_279) = &input.bytes_per_second {
object.key("BytesPerSecond").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_279).into()),
);
}
if let Some(var_280) = &input.task_queueing {
object.key("TaskQueueing").string(var_280.as_str());
}
if let Some(var_281) = &input.log_level {
object.key("LogLevel").string(var_281.as_str());
}
if let Some(var_282) = &input.transfer_mode {
object.key("TransferMode").string(var_282.as_str());
}
if let Some(var_283) = &input.security_descriptor_copy_flags {
object
.key("SecurityDescriptorCopyFlags")
.string(var_283.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_filter_rule(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FilterRule,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_284) = &input.filter_type {
object.key("FilterType").string(var_284.as_str());
}
if let Some(var_285) = &input.value {
object.key("Value").string(var_285);
}
Ok(())
}
pub fn serialize_structure_crate_model_task_schedule(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TaskSchedule,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_286) = &input.schedule_expression {
object.key("ScheduleExpression").string(var_286);
}
Ok(())
}
pub fn serialize_structure_crate_model_location_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LocationFilter,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_287) = &input.name {
object.key("Name").string(var_287.as_str());
}
if let Some(var_288) = &input.values {
let mut array_289 = object.key("Values").start_array();
for item_290 in var_288 {
{
array_289.value().string(item_290);
}
}
array_289.finish();
}
if let Some(var_291) = &input.operator {
object.key("Operator").string(var_291.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_task_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TaskFilter,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_292) = &input.name {
object.key("Name").string(var_292.as_str());
}
if let Some(var_293) = &input.values {
let mut array_294 = object.key("Values").start_array();
for item_295 in var_293 {
{
array_294.value().string(item_295);
}
}
array_294.finish();
}
if let Some(var_296) = &input.operator {
object.key("Operator").string(var_296.as_str());
}
Ok(())
}