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_windows_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateLocationFsxWindowsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_23) = &input.subdirectory {
object.key("Subdirectory").string(var_23);
}
if let Some(var_24) = &input.fsx_filesystem_arn {
object.key("FsxFilesystemArn").string(var_24);
}
if let Some(var_25) = &input.security_group_arns {
let mut array_26 = object.key("SecurityGroupArns").start_array();
for item_27 in var_25 {
{
array_26.value().string(item_27);
}
}
array_26.finish();
}
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();
}
if let Some(var_32) = &input.user {
object.key("User").string(var_32);
}
if let Some(var_33) = &input.domain {
object.key("Domain").string(var_33);
}
if let Some(var_34) = &input.password {
object.key("Password").string(var_34);
}
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_35) = &input.subdirectory {
object.key("Subdirectory").string(var_35);
}
if let Some(var_36) = &input.name_nodes {
let mut array_37 = object.key("NameNodes").start_array();
for item_38 in var_36 {
{
let mut object_39 = array_37.value().start_object();
crate::json_ser::serialize_structure_crate_model_hdfs_name_node(
&mut object_39,
item_38,
)?;
object_39.finish();
}
}
array_37.finish();
}
if let Some(var_40) = &input.block_size {
object.key("BlockSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_40).into()),
);
}
if let Some(var_41) = &input.replication_factor {
object.key("ReplicationFactor").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_41).into()),
);
}
if let Some(var_42) = &input.kms_key_provider_uri {
object.key("KmsKeyProviderUri").string(var_42);
}
if let Some(var_43) = &input.qop_configuration {
let mut object_44 = object.key("QopConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_qop_configuration(&mut object_44, var_43)?;
object_44.finish();
}
if let Some(var_45) = &input.authentication_type {
object.key("AuthenticationType").string(var_45.as_str());
}
if let Some(var_46) = &input.simple_user {
object.key("SimpleUser").string(var_46);
}
if let Some(var_47) = &input.kerberos_principal {
object.key("KerberosPrincipal").string(var_47);
}
if let Some(var_48) = &input.kerberos_keytab {
object
.key("KerberosKeytab")
.string_unchecked(&aws_smithy_types::base64::encode(var_48));
}
if let Some(var_49) = &input.kerberos_krb5_conf {
object
.key("KerberosKrb5Conf")
.string_unchecked(&aws_smithy_types::base64::encode(var_49));
}
if let Some(var_50) = &input.agent_arns {
let mut array_51 = object.key("AgentArns").start_array();
for item_52 in var_50 {
{
array_51.value().string(item_52);
}
}
array_51.finish();
}
if let Some(var_53) = &input.tags {
let mut array_54 = object.key("Tags").start_array();
for item_55 in var_53 {
{
let mut object_56 = array_54.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag_list_entry(
&mut object_56,
item_55,
)?;
object_56.finish();
}
}
array_54.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_57) = &input.subdirectory {
object.key("Subdirectory").string(var_57);
}
if let Some(var_58) = &input.server_hostname {
object.key("ServerHostname").string(var_58);
}
if let Some(var_59) = &input.on_prem_config {
let mut object_60 = object.key("OnPremConfig").start_object();
crate::json_ser::serialize_structure_crate_model_on_prem_config(&mut object_60, var_59)?;
object_60.finish();
}
if let Some(var_61) = &input.mount_options {
let mut object_62 = object.key("MountOptions").start_object();
crate::json_ser::serialize_structure_crate_model_nfs_mount_options(&mut object_62, var_61)?;
object_62.finish();
}
if let Some(var_63) = &input.tags {
let mut array_64 = object.key("Tags").start_array();
for item_65 in var_63 {
{
let mut object_66 = array_64.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag_list_entry(
&mut object_66,
item_65,
)?;
object_66.finish();
}
}
array_64.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_67) = &input.server_hostname {
object.key("ServerHostname").string(var_67);
}
if let Some(var_68) = &input.server_port {
object.key("ServerPort").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_68).into()),
);
}
if let Some(var_69) = &input.server_protocol {
object.key("ServerProtocol").string(var_69.as_str());
}
if let Some(var_70) = &input.subdirectory {
object.key("Subdirectory").string(var_70);
}
if let Some(var_71) = &input.bucket_name {
object.key("BucketName").string(var_71);
}
if let Some(var_72) = &input.access_key {
object.key("AccessKey").string(var_72);
}
if let Some(var_73) = &input.secret_key {
object.key("SecretKey").string(var_73);
}
if let Some(var_74) = &input.agent_arns {
let mut array_75 = object.key("AgentArns").start_array();
for item_76 in var_74 {
{
array_75.value().string(item_76);
}
}
array_75.finish();
}
if let Some(var_77) = &input.tags {
let mut array_78 = object.key("Tags").start_array();
for item_79 in var_77 {
{
let mut object_80 = array_78.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag_list_entry(
&mut object_80,
item_79,
)?;
object_80.finish();
}
}
array_78.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_81) = &input.subdirectory {
object.key("Subdirectory").string(var_81);
}
if let Some(var_82) = &input.s3_bucket_arn {
object.key("S3BucketArn").string(var_82);
}
if let Some(var_83) = &input.s3_storage_class {
object.key("S3StorageClass").string(var_83.as_str());
}
if let Some(var_84) = &input.s3_config {
let mut object_85 = object.key("S3Config").start_object();
crate::json_ser::serialize_structure_crate_model_s3_config(&mut object_85, var_84)?;
object_85.finish();
}
if let Some(var_86) = &input.agent_arns {
let mut array_87 = object.key("AgentArns").start_array();
for item_88 in var_86 {
{
array_87.value().string(item_88);
}
}
array_87.finish();
}
if let Some(var_89) = &input.tags {
let mut array_90 = object.key("Tags").start_array();
for item_91 in var_89 {
{
let mut object_92 = array_90.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag_list_entry(
&mut object_92,
item_91,
)?;
object_92.finish();
}
}
array_90.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_93) = &input.subdirectory {
object.key("Subdirectory").string(var_93);
}
if let Some(var_94) = &input.server_hostname {
object.key("ServerHostname").string(var_94);
}
if let Some(var_95) = &input.user {
object.key("User").string(var_95);
}
if let Some(var_96) = &input.domain {
object.key("Domain").string(var_96);
}
if let Some(var_97) = &input.password {
object.key("Password").string(var_97);
}
if let Some(var_98) = &input.agent_arns {
let mut array_99 = object.key("AgentArns").start_array();
for item_100 in var_98 {
{
array_99.value().string(item_100);
}
}
array_99.finish();
}
if let Some(var_101) = &input.mount_options {
let mut object_102 = object.key("MountOptions").start_object();
crate::json_ser::serialize_structure_crate_model_smb_mount_options(
&mut object_102,
var_101,
)?;
object_102.finish();
}
if let Some(var_103) = &input.tags {
let mut array_104 = object.key("Tags").start_array();
for item_105 in var_103 {
{
let mut object_106 = array_104.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag_list_entry(
&mut object_106,
item_105,
)?;
object_106.finish();
}
}
array_104.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_107) = &input.source_location_arn {
object.key("SourceLocationArn").string(var_107);
}
if let Some(var_108) = &input.destination_location_arn {
object.key("DestinationLocationArn").string(var_108);
}
if let Some(var_109) = &input.cloud_watch_log_group_arn {
object.key("CloudWatchLogGroupArn").string(var_109);
}
if let Some(var_110) = &input.name {
object.key("Name").string(var_110);
}
if let Some(var_111) = &input.options {
let mut object_112 = object.key("Options").start_object();
crate::json_ser::serialize_structure_crate_model_options(&mut object_112, var_111)?;
object_112.finish();
}
if let Some(var_113) = &input.excludes {
let mut array_114 = object.key("Excludes").start_array();
for item_115 in var_113 {
{
let mut object_116 = array_114.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter_rule(
&mut object_116,
item_115,
)?;
object_116.finish();
}
}
array_114.finish();
}
if let Some(var_117) = &input.schedule {
let mut object_118 = object.key("Schedule").start_object();
crate::json_ser::serialize_structure_crate_model_task_schedule(&mut object_118, var_117)?;
object_118.finish();
}
if let Some(var_119) = &input.tags {
let mut array_120 = object.key("Tags").start_array();
for item_121 in var_119 {
{
let mut object_122 = array_120.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag_list_entry(
&mut object_122,
item_121,
)?;
object_122.finish();
}
}
array_120.finish();
}
if let Some(var_123) = &input.includes {
let mut array_124 = object.key("Includes").start_array();
for item_125 in var_123 {
{
let mut object_126 = array_124.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter_rule(
&mut object_126,
item_125,
)?;
object_126.finish();
}
}
array_124.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_127) = &input.agent_arn {
object.key("AgentArn").string(var_127);
}
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_128) = &input.location_arn {
object.key("LocationArn").string(var_128);
}
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_129) = &input.task_arn {
object.key("TaskArn").string(var_129);
}
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_130) = &input.agent_arn {
object.key("AgentArn").string(var_130);
}
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_131) = &input.location_arn {
object.key("LocationArn").string(var_131);
}
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_132) = &input.location_arn {
object.key("LocationArn").string(var_132);
}
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_133) = &input.location_arn {
object.key("LocationArn").string(var_133);
}
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_134) = &input.location_arn {
object.key("LocationArn").string(var_134);
}
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_135) = &input.location_arn {
object.key("LocationArn").string(var_135);
}
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_136) = &input.location_arn {
object.key("LocationArn").string(var_136);
}
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_137) = &input.location_arn {
object.key("LocationArn").string(var_137);
}
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_138) = &input.task_arn {
object.key("TaskArn").string(var_138);
}
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_139) = &input.task_execution_arn {
object.key("TaskExecutionArn").string(var_139);
}
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_140) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_140).into()),
);
}
if let Some(var_141) = &input.next_token {
object.key("NextToken").string(var_141);
}
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_142) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_142).into()),
);
}
if let Some(var_143) = &input.next_token {
object.key("NextToken").string(var_143);
}
if let Some(var_144) = &input.filters {
let mut array_145 = object.key("Filters").start_array();
for item_146 in var_144 {
{
let mut object_147 = array_145.value().start_object();
crate::json_ser::serialize_structure_crate_model_location_filter(
&mut object_147,
item_146,
)?;
object_147.finish();
}
}
array_145.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_148) = &input.resource_arn {
object.key("ResourceArn").string(var_148);
}
if let Some(var_149) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_149).into()),
);
}
if let Some(var_150) = &input.next_token {
object.key("NextToken").string(var_150);
}
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_151) = &input.task_arn {
object.key("TaskArn").string(var_151);
}
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);
}
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_154) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_154).into()),
);
}
if let Some(var_155) = &input.next_token {
object.key("NextToken").string(var_155);
}
if let Some(var_156) = &input.filters {
let mut array_157 = object.key("Filters").start_array();
for item_158 in var_156 {
{
let mut object_159 = array_157.value().start_object();
crate::json_ser::serialize_structure_crate_model_task_filter(
&mut object_159,
item_158,
)?;
object_159.finish();
}
}
array_157.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_160) = &input.task_arn {
object.key("TaskArn").string(var_160);
}
if let Some(var_161) = &input.override_options {
let mut object_162 = object.key("OverrideOptions").start_object();
crate::json_ser::serialize_structure_crate_model_options(&mut object_162, var_161)?;
object_162.finish();
}
if let Some(var_163) = &input.includes {
let mut array_164 = object.key("Includes").start_array();
for item_165 in var_163 {
{
let mut object_166 = array_164.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter_rule(
&mut object_166,
item_165,
)?;
object_166.finish();
}
}
array_164.finish();
}
if let Some(var_167) = &input.excludes {
let mut array_168 = object.key("Excludes").start_array();
for item_169 in var_167 {
{
let mut object_170 = array_168.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter_rule(
&mut object_170,
item_169,
)?;
object_170.finish();
}
}
array_168.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_171) = &input.resource_arn {
object.key("ResourceArn").string(var_171);
}
if let Some(var_172) = &input.tags {
let mut array_173 = object.key("Tags").start_array();
for item_174 in var_172 {
{
let mut object_175 = array_173.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag_list_entry(
&mut object_175,
item_174,
)?;
object_175.finish();
}
}
array_173.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_176) = &input.resource_arn {
object.key("ResourceArn").string(var_176);
}
if let Some(var_177) = &input.keys {
let mut array_178 = object.key("Keys").start_array();
for item_179 in var_177 {
{
array_178.value().string(item_179);
}
}
array_178.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_180) = &input.agent_arn {
object.key("AgentArn").string(var_180);
}
if let Some(var_181) = &input.name {
object.key("Name").string(var_181);
}
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_182) = &input.location_arn {
object.key("LocationArn").string(var_182);
}
if let Some(var_183) = &input.subdirectory {
object.key("Subdirectory").string(var_183);
}
if let Some(var_184) = &input.name_nodes {
let mut array_185 = object.key("NameNodes").start_array();
for item_186 in var_184 {
{
let mut object_187 = array_185.value().start_object();
crate::json_ser::serialize_structure_crate_model_hdfs_name_node(
&mut object_187,
item_186,
)?;
object_187.finish();
}
}
array_185.finish();
}
if let Some(var_188) = &input.block_size {
object.key("BlockSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_188).into()),
);
}
if let Some(var_189) = &input.replication_factor {
object.key("ReplicationFactor").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_189).into()),
);
}
if let Some(var_190) = &input.kms_key_provider_uri {
object.key("KmsKeyProviderUri").string(var_190);
}
if let Some(var_191) = &input.qop_configuration {
let mut object_192 = object.key("QopConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_qop_configuration(
&mut object_192,
var_191,
)?;
object_192.finish();
}
if let Some(var_193) = &input.authentication_type {
object.key("AuthenticationType").string(var_193.as_str());
}
if let Some(var_194) = &input.simple_user {
object.key("SimpleUser").string(var_194);
}
if let Some(var_195) = &input.kerberos_principal {
object.key("KerberosPrincipal").string(var_195);
}
if let Some(var_196) = &input.kerberos_keytab {
object
.key("KerberosKeytab")
.string_unchecked(&aws_smithy_types::base64::encode(var_196));
}
if let Some(var_197) = &input.kerberos_krb5_conf {
object
.key("KerberosKrb5Conf")
.string_unchecked(&aws_smithy_types::base64::encode(var_197));
}
if let Some(var_198) = &input.agent_arns {
let mut array_199 = object.key("AgentArns").start_array();
for item_200 in var_198 {
{
array_199.value().string(item_200);
}
}
array_199.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_201) = &input.location_arn {
object.key("LocationArn").string(var_201);
}
if let Some(var_202) = &input.subdirectory {
object.key("Subdirectory").string(var_202);
}
if let Some(var_203) = &input.on_prem_config {
let mut object_204 = object.key("OnPremConfig").start_object();
crate::json_ser::serialize_structure_crate_model_on_prem_config(&mut object_204, var_203)?;
object_204.finish();
}
if let Some(var_205) = &input.mount_options {
let mut object_206 = object.key("MountOptions").start_object();
crate::json_ser::serialize_structure_crate_model_nfs_mount_options(
&mut object_206,
var_205,
)?;
object_206.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_207) = &input.location_arn {
object.key("LocationArn").string(var_207);
}
if let Some(var_208) = &input.server_port {
object.key("ServerPort").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_208).into()),
);
}
if let Some(var_209) = &input.server_protocol {
object.key("ServerProtocol").string(var_209.as_str());
}
if let Some(var_210) = &input.subdirectory {
object.key("Subdirectory").string(var_210);
}
if let Some(var_211) = &input.access_key {
object.key("AccessKey").string(var_211);
}
if let Some(var_212) = &input.secret_key {
object.key("SecretKey").string(var_212);
}
if let Some(var_213) = &input.agent_arns {
let mut array_214 = object.key("AgentArns").start_array();
for item_215 in var_213 {
{
array_214.value().string(item_215);
}
}
array_214.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_216) = &input.location_arn {
object.key("LocationArn").string(var_216);
}
if let Some(var_217) = &input.subdirectory {
object.key("Subdirectory").string(var_217);
}
if let Some(var_218) = &input.user {
object.key("User").string(var_218);
}
if let Some(var_219) = &input.domain {
object.key("Domain").string(var_219);
}
if let Some(var_220) = &input.password {
object.key("Password").string(var_220);
}
if let Some(var_221) = &input.agent_arns {
let mut array_222 = object.key("AgentArns").start_array();
for item_223 in var_221 {
{
array_222.value().string(item_223);
}
}
array_222.finish();
}
if let Some(var_224) = &input.mount_options {
let mut object_225 = object.key("MountOptions").start_object();
crate::json_ser::serialize_structure_crate_model_smb_mount_options(
&mut object_225,
var_224,
)?;
object_225.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_226) = &input.task_arn {
object.key("TaskArn").string(var_226);
}
if let Some(var_227) = &input.options {
let mut object_228 = object.key("Options").start_object();
crate::json_ser::serialize_structure_crate_model_options(&mut object_228, var_227)?;
object_228.finish();
}
if let Some(var_229) = &input.excludes {
let mut array_230 = object.key("Excludes").start_array();
for item_231 in var_229 {
{
let mut object_232 = array_230.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter_rule(
&mut object_232,
item_231,
)?;
object_232.finish();
}
}
array_230.finish();
}
if let Some(var_233) = &input.schedule {
let mut object_234 = object.key("Schedule").start_object();
crate::json_ser::serialize_structure_crate_model_task_schedule(&mut object_234, var_233)?;
object_234.finish();
}
if let Some(var_235) = &input.name {
object.key("Name").string(var_235);
}
if let Some(var_236) = &input.cloud_watch_log_group_arn {
object.key("CloudWatchLogGroupArn").string(var_236);
}
if let Some(var_237) = &input.includes {
let mut array_238 = object.key("Includes").start_array();
for item_239 in var_237 {
{
let mut object_240 = array_238.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter_rule(
&mut object_240,
item_239,
)?;
object_240.finish();
}
}
array_238.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_241) = &input.task_execution_arn {
object.key("TaskExecutionArn").string(var_241);
}
if let Some(var_242) = &input.options {
let mut object_243 = object.key("Options").start_object();
crate::json_ser::serialize_structure_crate_model_options(&mut object_243, var_242)?;
object_243.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_244) = &input.key {
object.key("Key").string(var_244);
}
if let Some(var_245) = &input.value {
object.key("Value").string(var_245);
}
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_246) = &input.subnet_arn {
object.key("SubnetArn").string(var_246);
}
if let Some(var_247) = &input.security_group_arns {
let mut array_248 = object.key("SecurityGroupArns").start_array();
for item_249 in var_247 {
{
array_248.value().string(item_249);
}
}
array_248.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_250) = &input.hostname {
object.key("Hostname").string(var_250);
}
if let Some(var_251) = &input.port {
object.key("Port").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_251).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_252) = &input.rpc_protection {
object.key("RpcProtection").string(var_252.as_str());
}
if let Some(var_253) = &input.data_transfer_protection {
object
.key("DataTransferProtection")
.string(var_253.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_254) = &input.agent_arns {
let mut array_255 = object.key("AgentArns").start_array();
for item_256 in var_254 {
{
array_255.value().string(item_256);
}
}
array_255.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_257) = &input.version {
object.key("Version").string(var_257.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_258) = &input.bucket_access_role_arn {
object.key("BucketAccessRoleArn").string(var_258);
}
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_259) = &input.version {
object.key("Version").string(var_259.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_260) = &input.verify_mode {
object.key("VerifyMode").string(var_260.as_str());
}
if let Some(var_261) = &input.overwrite_mode {
object.key("OverwriteMode").string(var_261.as_str());
}
if let Some(var_262) = &input.atime {
object.key("Atime").string(var_262.as_str());
}
if let Some(var_263) = &input.mtime {
object.key("Mtime").string(var_263.as_str());
}
if let Some(var_264) = &input.uid {
object.key("Uid").string(var_264.as_str());
}
if let Some(var_265) = &input.gid {
object.key("Gid").string(var_265.as_str());
}
if let Some(var_266) = &input.preserve_deleted_files {
object.key("PreserveDeletedFiles").string(var_266.as_str());
}
if let Some(var_267) = &input.preserve_devices {
object.key("PreserveDevices").string(var_267.as_str());
}
if let Some(var_268) = &input.posix_permissions {
object.key("PosixPermissions").string(var_268.as_str());
}
if let Some(var_269) = &input.bytes_per_second {
object.key("BytesPerSecond").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_269).into()),
);
}
if let Some(var_270) = &input.task_queueing {
object.key("TaskQueueing").string(var_270.as_str());
}
if let Some(var_271) = &input.log_level {
object.key("LogLevel").string(var_271.as_str());
}
if let Some(var_272) = &input.transfer_mode {
object.key("TransferMode").string(var_272.as_str());
}
if let Some(var_273) = &input.security_descriptor_copy_flags {
object
.key("SecurityDescriptorCopyFlags")
.string(var_273.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_274) = &input.filter_type {
object.key("FilterType").string(var_274.as_str());
}
if let Some(var_275) = &input.value {
object.key("Value").string(var_275);
}
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_276) = &input.schedule_expression {
object.key("ScheduleExpression").string(var_276);
}
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_277) = &input.name {
object.key("Name").string(var_277.as_str());
}
if let Some(var_278) = &input.values {
let mut array_279 = object.key("Values").start_array();
for item_280 in var_278 {
{
array_279.value().string(item_280);
}
}
array_279.finish();
}
if let Some(var_281) = &input.operator {
object.key("Operator").string(var_281.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_282) = &input.name {
object.key("Name").string(var_282.as_str());
}
if let Some(var_283) = &input.values {
let mut array_284 = object.key("Values").start_array();
for item_285 in var_283 {
{
array_284.value().string(item_285);
}
}
array_284.finish();
}
if let Some(var_286) = &input.operator {
object.key("Operator").string(var_286.as_str());
}
Ok(())
}