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.as_str());
}
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.as_str());
}
if let Some(var_3) = &input.agent_name {
object.key("AgentName").string(var_3.as_str());
}
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.as_str());
}
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.as_str());
}
}
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.as_str());
}
}
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.as_str());
}
if let Some(var_16) = &input.efs_filesystem_arn {
object.key("EfsFilesystemArn").string(var_16.as_str());
}
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.as_str());
}
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.as_str());
}
}
array_25.finish();
}
if let Some(var_27) = &input.subdirectory {
object.key("Subdirectory").string(var_27.as_str());
}
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_open_zfs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateLocationFsxOpenZfsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_32) = &input.fsx_filesystem_arn {
object.key("FsxFilesystemArn").string(var_32.as_str());
}
if let Some(var_33) = &input.protocol {
let mut object_34 = object.key("Protocol").start_object();
crate::json_ser::serialize_structure_crate_model_fsx_protocol(&mut object_34, var_33)?;
object_34.finish();
}
if let Some(var_35) = &input.security_group_arns {
let mut array_36 = object.key("SecurityGroupArns").start_array();
for item_37 in var_35 {
{
array_36.value().string(item_37.as_str());
}
}
array_36.finish();
}
if let Some(var_38) = &input.subdirectory {
object.key("Subdirectory").string(var_38.as_str());
}
if let Some(var_39) = &input.tags {
let mut array_40 = object.key("Tags").start_array();
for item_41 in var_39 {
{
let mut object_42 = array_40.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag_list_entry(
&mut object_42,
item_41,
)?;
object_42.finish();
}
}
array_40.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_43) = &input.subdirectory {
object.key("Subdirectory").string(var_43.as_str());
}
if let Some(var_44) = &input.fsx_filesystem_arn {
object.key("FsxFilesystemArn").string(var_44.as_str());
}
if let Some(var_45) = &input.security_group_arns {
let mut array_46 = object.key("SecurityGroupArns").start_array();
for item_47 in var_45 {
{
array_46.value().string(item_47.as_str());
}
}
array_46.finish();
}
if let Some(var_48) = &input.tags {
let mut array_49 = object.key("Tags").start_array();
for item_50 in var_48 {
{
let mut object_51 = array_49.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag_list_entry(
&mut object_51,
item_50,
)?;
object_51.finish();
}
}
array_49.finish();
}
if let Some(var_52) = &input.user {
object.key("User").string(var_52.as_str());
}
if let Some(var_53) = &input.domain {
object.key("Domain").string(var_53.as_str());
}
if let Some(var_54) = &input.password {
object.key("Password").string(var_54.as_str());
}
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_55) = &input.subdirectory {
object.key("Subdirectory").string(var_55.as_str());
}
if let Some(var_56) = &input.name_nodes {
let mut array_57 = object.key("NameNodes").start_array();
for item_58 in var_56 {
{
let mut object_59 = array_57.value().start_object();
crate::json_ser::serialize_structure_crate_model_hdfs_name_node(
&mut object_59,
item_58,
)?;
object_59.finish();
}
}
array_57.finish();
}
if let Some(var_60) = &input.block_size {
object.key("BlockSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_60).into()),
);
}
if let Some(var_61) = &input.replication_factor {
object.key("ReplicationFactor").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_61).into()),
);
}
if let Some(var_62) = &input.kms_key_provider_uri {
object.key("KmsKeyProviderUri").string(var_62.as_str());
}
if let Some(var_63) = &input.qop_configuration {
let mut object_64 = object.key("QopConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_qop_configuration(&mut object_64, var_63)?;
object_64.finish();
}
if let Some(var_65) = &input.authentication_type {
object.key("AuthenticationType").string(var_65.as_str());
}
if let Some(var_66) = &input.simple_user {
object.key("SimpleUser").string(var_66.as_str());
}
if let Some(var_67) = &input.kerberos_principal {
object.key("KerberosPrincipal").string(var_67.as_str());
}
if let Some(var_68) = &input.kerberos_keytab {
object
.key("KerberosKeytab")
.string_unchecked(&aws_smithy_types::base64::encode(var_68));
}
if let Some(var_69) = &input.kerberos_krb5_conf {
object
.key("KerberosKrb5Conf")
.string_unchecked(&aws_smithy_types::base64::encode(var_69));
}
if let Some(var_70) = &input.agent_arns {
let mut array_71 = object.key("AgentArns").start_array();
for item_72 in var_70 {
{
array_71.value().string(item_72.as_str());
}
}
array_71.finish();
}
if let Some(var_73) = &input.tags {
let mut array_74 = object.key("Tags").start_array();
for item_75 in var_73 {
{
let mut object_76 = array_74.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag_list_entry(
&mut object_76,
item_75,
)?;
object_76.finish();
}
}
array_74.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_77) = &input.subdirectory {
object.key("Subdirectory").string(var_77.as_str());
}
if let Some(var_78) = &input.server_hostname {
object.key("ServerHostname").string(var_78.as_str());
}
if let Some(var_79) = &input.on_prem_config {
let mut object_80 = object.key("OnPremConfig").start_object();
crate::json_ser::serialize_structure_crate_model_on_prem_config(&mut object_80, var_79)?;
object_80.finish();
}
if let Some(var_81) = &input.mount_options {
let mut object_82 = object.key("MountOptions").start_object();
crate::json_ser::serialize_structure_crate_model_nfs_mount_options(&mut object_82, var_81)?;
object_82.finish();
}
if let Some(var_83) = &input.tags {
let mut array_84 = object.key("Tags").start_array();
for item_85 in var_83 {
{
let mut object_86 = array_84.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag_list_entry(
&mut object_86,
item_85,
)?;
object_86.finish();
}
}
array_84.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_87) = &input.server_hostname {
object.key("ServerHostname").string(var_87.as_str());
}
if let Some(var_88) = &input.server_port {
object.key("ServerPort").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_88).into()),
);
}
if let Some(var_89) = &input.server_protocol {
object.key("ServerProtocol").string(var_89.as_str());
}
if let Some(var_90) = &input.subdirectory {
object.key("Subdirectory").string(var_90.as_str());
}
if let Some(var_91) = &input.bucket_name {
object.key("BucketName").string(var_91.as_str());
}
if let Some(var_92) = &input.access_key {
object.key("AccessKey").string(var_92.as_str());
}
if let Some(var_93) = &input.secret_key {
object.key("SecretKey").string(var_93.as_str());
}
if let Some(var_94) = &input.agent_arns {
let mut array_95 = object.key("AgentArns").start_array();
for item_96 in var_94 {
{
array_95.value().string(item_96.as_str());
}
}
array_95.finish();
}
if let Some(var_97) = &input.tags {
let mut array_98 = object.key("Tags").start_array();
for item_99 in var_97 {
{
let mut object_100 = array_98.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag_list_entry(
&mut object_100,
item_99,
)?;
object_100.finish();
}
}
array_98.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_101) = &input.subdirectory {
object.key("Subdirectory").string(var_101.as_str());
}
if let Some(var_102) = &input.s3_bucket_arn {
object.key("S3BucketArn").string(var_102.as_str());
}
if let Some(var_103) = &input.s3_storage_class {
object.key("S3StorageClass").string(var_103.as_str());
}
if let Some(var_104) = &input.s3_config {
let mut object_105 = object.key("S3Config").start_object();
crate::json_ser::serialize_structure_crate_model_s3_config(&mut object_105, var_104)?;
object_105.finish();
}
if let Some(var_106) = &input.agent_arns {
let mut array_107 = object.key("AgentArns").start_array();
for item_108 in var_106 {
{
array_107.value().string(item_108.as_str());
}
}
array_107.finish();
}
if let Some(var_109) = &input.tags {
let mut array_110 = object.key("Tags").start_array();
for item_111 in var_109 {
{
let mut object_112 = array_110.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag_list_entry(
&mut object_112,
item_111,
)?;
object_112.finish();
}
}
array_110.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_113) = &input.subdirectory {
object.key("Subdirectory").string(var_113.as_str());
}
if let Some(var_114) = &input.server_hostname {
object.key("ServerHostname").string(var_114.as_str());
}
if let Some(var_115) = &input.user {
object.key("User").string(var_115.as_str());
}
if let Some(var_116) = &input.domain {
object.key("Domain").string(var_116.as_str());
}
if let Some(var_117) = &input.password {
object.key("Password").string(var_117.as_str());
}
if let Some(var_118) = &input.agent_arns {
let mut array_119 = object.key("AgentArns").start_array();
for item_120 in var_118 {
{
array_119.value().string(item_120.as_str());
}
}
array_119.finish();
}
if let Some(var_121) = &input.mount_options {
let mut object_122 = object.key("MountOptions").start_object();
crate::json_ser::serialize_structure_crate_model_smb_mount_options(
&mut object_122,
var_121,
)?;
object_122.finish();
}
if let Some(var_123) = &input.tags {
let mut array_124 = object.key("Tags").start_array();
for item_125 in var_123 {
{
let mut object_126 = array_124.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag_list_entry(
&mut object_126,
item_125,
)?;
object_126.finish();
}
}
array_124.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_127) = &input.source_location_arn {
object.key("SourceLocationArn").string(var_127.as_str());
}
if let Some(var_128) = &input.destination_location_arn {
object
.key("DestinationLocationArn")
.string(var_128.as_str());
}
if let Some(var_129) = &input.cloud_watch_log_group_arn {
object.key("CloudWatchLogGroupArn").string(var_129.as_str());
}
if let Some(var_130) = &input.name {
object.key("Name").string(var_130.as_str());
}
if let Some(var_131) = &input.options {
let mut object_132 = object.key("Options").start_object();
crate::json_ser::serialize_structure_crate_model_options(&mut object_132, var_131)?;
object_132.finish();
}
if let Some(var_133) = &input.excludes {
let mut array_134 = object.key("Excludes").start_array();
for item_135 in var_133 {
{
let mut object_136 = array_134.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter_rule(
&mut object_136,
item_135,
)?;
object_136.finish();
}
}
array_134.finish();
}
if let Some(var_137) = &input.schedule {
let mut object_138 = object.key("Schedule").start_object();
crate::json_ser::serialize_structure_crate_model_task_schedule(&mut object_138, var_137)?;
object_138.finish();
}
if let Some(var_139) = &input.tags {
let mut array_140 = object.key("Tags").start_array();
for item_141 in var_139 {
{
let mut object_142 = array_140.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag_list_entry(
&mut object_142,
item_141,
)?;
object_142.finish();
}
}
array_140.finish();
}
if let Some(var_143) = &input.includes {
let mut array_144 = object.key("Includes").start_array();
for item_145 in var_143 {
{
let mut object_146 = array_144.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter_rule(
&mut object_146,
item_145,
)?;
object_146.finish();
}
}
array_144.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_147) = &input.agent_arn {
object.key("AgentArn").string(var_147.as_str());
}
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_148) = &input.location_arn {
object.key("LocationArn").string(var_148.as_str());
}
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_149) = &input.task_arn {
object.key("TaskArn").string(var_149.as_str());
}
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_150) = &input.agent_arn {
object.key("AgentArn").string(var_150.as_str());
}
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_151) = &input.location_arn {
object.key("LocationArn").string(var_151.as_str());
}
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_152) = &input.location_arn {
object.key("LocationArn").string(var_152.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_location_fsx_open_zfs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeLocationFsxOpenZfsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_153) = &input.location_arn {
object.key("LocationArn").string(var_153.as_str());
}
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_154) = &input.location_arn {
object.key("LocationArn").string(var_154.as_str());
}
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_155) = &input.location_arn {
object.key("LocationArn").string(var_155.as_str());
}
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_156) = &input.location_arn {
object.key("LocationArn").string(var_156.as_str());
}
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_157) = &input.location_arn {
object.key("LocationArn").string(var_157.as_str());
}
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_158) = &input.location_arn {
object.key("LocationArn").string(var_158.as_str());
}
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_159) = &input.location_arn {
object.key("LocationArn").string(var_159.as_str());
}
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_160) = &input.task_arn {
object.key("TaskArn").string(var_160.as_str());
}
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_161) = &input.task_execution_arn {
object.key("TaskExecutionArn").string(var_161.as_str());
}
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_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.as_str());
}
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_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.as_str());
}
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_location_filter(
&mut object_169,
item_168,
)?;
object_169.finish();
}
}
array_167.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_170) = &input.resource_arn {
object.key("ResourceArn").string(var_170.as_str());
}
if let Some(var_171) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_171).into()),
);
}
if let Some(var_172) = &input.next_token {
object.key("NextToken").string(var_172.as_str());
}
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_173) = &input.task_arn {
object.key("TaskArn").string(var_173.as_str());
}
if let Some(var_174) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_174).into()),
);
}
if let Some(var_175) = &input.next_token {
object.key("NextToken").string(var_175.as_str());
}
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_176) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_176).into()),
);
}
if let Some(var_177) = &input.next_token {
object.key("NextToken").string(var_177.as_str());
}
if let Some(var_178) = &input.filters {
let mut array_179 = object.key("Filters").start_array();
for item_180 in var_178 {
{
let mut object_181 = array_179.value().start_object();
crate::json_ser::serialize_structure_crate_model_task_filter(
&mut object_181,
item_180,
)?;
object_181.finish();
}
}
array_179.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_182) = &input.task_arn {
object.key("TaskArn").string(var_182.as_str());
}
if let Some(var_183) = &input.override_options {
let mut object_184 = object.key("OverrideOptions").start_object();
crate::json_ser::serialize_structure_crate_model_options(&mut object_184, var_183)?;
object_184.finish();
}
if let Some(var_185) = &input.includes {
let mut array_186 = object.key("Includes").start_array();
for item_187 in var_185 {
{
let mut object_188 = array_186.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter_rule(
&mut object_188,
item_187,
)?;
object_188.finish();
}
}
array_186.finish();
}
if let Some(var_189) = &input.excludes {
let mut array_190 = object.key("Excludes").start_array();
for item_191 in var_189 {
{
let mut object_192 = array_190.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter_rule(
&mut object_192,
item_191,
)?;
object_192.finish();
}
}
array_190.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_193) = &input.resource_arn {
object.key("ResourceArn").string(var_193.as_str());
}
if let Some(var_194) = &input.tags {
let mut array_195 = object.key("Tags").start_array();
for item_196 in var_194 {
{
let mut object_197 = array_195.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag_list_entry(
&mut object_197,
item_196,
)?;
object_197.finish();
}
}
array_195.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_198) = &input.resource_arn {
object.key("ResourceArn").string(var_198.as_str());
}
if let Some(var_199) = &input.keys {
let mut array_200 = object.key("Keys").start_array();
for item_201 in var_199 {
{
array_200.value().string(item_201.as_str());
}
}
array_200.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_202) = &input.agent_arn {
object.key("AgentArn").string(var_202.as_str());
}
if let Some(var_203) = &input.name {
object.key("Name").string(var_203.as_str());
}
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_204) = &input.location_arn {
object.key("LocationArn").string(var_204.as_str());
}
if let Some(var_205) = &input.subdirectory {
object.key("Subdirectory").string(var_205.as_str());
}
if let Some(var_206) = &input.name_nodes {
let mut array_207 = object.key("NameNodes").start_array();
for item_208 in var_206 {
{
let mut object_209 = array_207.value().start_object();
crate::json_ser::serialize_structure_crate_model_hdfs_name_node(
&mut object_209,
item_208,
)?;
object_209.finish();
}
}
array_207.finish();
}
if let Some(var_210) = &input.block_size {
object.key("BlockSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_210).into()),
);
}
if let Some(var_211) = &input.replication_factor {
object.key("ReplicationFactor").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_211).into()),
);
}
if let Some(var_212) = &input.kms_key_provider_uri {
object.key("KmsKeyProviderUri").string(var_212.as_str());
}
if let Some(var_213) = &input.qop_configuration {
let mut object_214 = object.key("QopConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_qop_configuration(
&mut object_214,
var_213,
)?;
object_214.finish();
}
if let Some(var_215) = &input.authentication_type {
object.key("AuthenticationType").string(var_215.as_str());
}
if let Some(var_216) = &input.simple_user {
object.key("SimpleUser").string(var_216.as_str());
}
if let Some(var_217) = &input.kerberos_principal {
object.key("KerberosPrincipal").string(var_217.as_str());
}
if let Some(var_218) = &input.kerberos_keytab {
object
.key("KerberosKeytab")
.string_unchecked(&aws_smithy_types::base64::encode(var_218));
}
if let Some(var_219) = &input.kerberos_krb5_conf {
object
.key("KerberosKrb5Conf")
.string_unchecked(&aws_smithy_types::base64::encode(var_219));
}
if let Some(var_220) = &input.agent_arns {
let mut array_221 = object.key("AgentArns").start_array();
for item_222 in var_220 {
{
array_221.value().string(item_222.as_str());
}
}
array_221.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_223) = &input.location_arn {
object.key("LocationArn").string(var_223.as_str());
}
if let Some(var_224) = &input.subdirectory {
object.key("Subdirectory").string(var_224.as_str());
}
if let Some(var_225) = &input.on_prem_config {
let mut object_226 = object.key("OnPremConfig").start_object();
crate::json_ser::serialize_structure_crate_model_on_prem_config(&mut object_226, var_225)?;
object_226.finish();
}
if let Some(var_227) = &input.mount_options {
let mut object_228 = object.key("MountOptions").start_object();
crate::json_ser::serialize_structure_crate_model_nfs_mount_options(
&mut object_228,
var_227,
)?;
object_228.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_229) = &input.location_arn {
object.key("LocationArn").string(var_229.as_str());
}
if let Some(var_230) = &input.server_port {
object.key("ServerPort").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_230).into()),
);
}
if let Some(var_231) = &input.server_protocol {
object.key("ServerProtocol").string(var_231.as_str());
}
if let Some(var_232) = &input.subdirectory {
object.key("Subdirectory").string(var_232.as_str());
}
if let Some(var_233) = &input.access_key {
object.key("AccessKey").string(var_233.as_str());
}
if let Some(var_234) = &input.secret_key {
object.key("SecretKey").string(var_234.as_str());
}
if let Some(var_235) = &input.agent_arns {
let mut array_236 = object.key("AgentArns").start_array();
for item_237 in var_235 {
{
array_236.value().string(item_237.as_str());
}
}
array_236.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_238) = &input.location_arn {
object.key("LocationArn").string(var_238.as_str());
}
if let Some(var_239) = &input.subdirectory {
object.key("Subdirectory").string(var_239.as_str());
}
if let Some(var_240) = &input.user {
object.key("User").string(var_240.as_str());
}
if let Some(var_241) = &input.domain {
object.key("Domain").string(var_241.as_str());
}
if let Some(var_242) = &input.password {
object.key("Password").string(var_242.as_str());
}
if let Some(var_243) = &input.agent_arns {
let mut array_244 = object.key("AgentArns").start_array();
for item_245 in var_243 {
{
array_244.value().string(item_245.as_str());
}
}
array_244.finish();
}
if let Some(var_246) = &input.mount_options {
let mut object_247 = object.key("MountOptions").start_object();
crate::json_ser::serialize_structure_crate_model_smb_mount_options(
&mut object_247,
var_246,
)?;
object_247.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_248) = &input.task_arn {
object.key("TaskArn").string(var_248.as_str());
}
if let Some(var_249) = &input.options {
let mut object_250 = object.key("Options").start_object();
crate::json_ser::serialize_structure_crate_model_options(&mut object_250, var_249)?;
object_250.finish();
}
if let Some(var_251) = &input.excludes {
let mut array_252 = object.key("Excludes").start_array();
for item_253 in var_251 {
{
let mut object_254 = array_252.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter_rule(
&mut object_254,
item_253,
)?;
object_254.finish();
}
}
array_252.finish();
}
if let Some(var_255) = &input.schedule {
let mut object_256 = object.key("Schedule").start_object();
crate::json_ser::serialize_structure_crate_model_task_schedule(&mut object_256, var_255)?;
object_256.finish();
}
if let Some(var_257) = &input.name {
object.key("Name").string(var_257.as_str());
}
if let Some(var_258) = &input.cloud_watch_log_group_arn {
object.key("CloudWatchLogGroupArn").string(var_258.as_str());
}
if let Some(var_259) = &input.includes {
let mut array_260 = object.key("Includes").start_array();
for item_261 in var_259 {
{
let mut object_262 = array_260.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter_rule(
&mut object_262,
item_261,
)?;
object_262.finish();
}
}
array_260.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_263) = &input.task_execution_arn {
object.key("TaskExecutionArn").string(var_263.as_str());
}
if let Some(var_264) = &input.options {
let mut object_265 = object.key("Options").start_object();
crate::json_ser::serialize_structure_crate_model_options(&mut object_265, var_264)?;
object_265.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_266) = &input.key {
object.key("Key").string(var_266.as_str());
}
if let Some(var_267) = &input.value {
object.key("Value").string(var_267.as_str());
}
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_268) = &input.subnet_arn {
object.key("SubnetArn").string(var_268.as_str());
}
if let Some(var_269) = &input.security_group_arns {
let mut array_270 = object.key("SecurityGroupArns").start_array();
for item_271 in var_269 {
{
array_270.value().string(item_271.as_str());
}
}
array_270.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_fsx_protocol(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FsxProtocol,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_272) = &input.nfs {
let mut object_273 = object.key("NFS").start_object();
crate::json_ser::serialize_structure_crate_model_fsx_protocol_nfs(
&mut object_273,
var_272,
)?;
object_273.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_274) = &input.hostname {
object.key("Hostname").string(var_274.as_str());
}
if let Some(var_275) = &input.port {
object.key("Port").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_275).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_276) = &input.rpc_protection {
object.key("RpcProtection").string(var_276.as_str());
}
if let Some(var_277) = &input.data_transfer_protection {
object
.key("DataTransferProtection")
.string(var_277.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_278) = &input.agent_arns {
let mut array_279 = object.key("AgentArns").start_array();
for item_280 in var_278 {
{
array_279.value().string(item_280.as_str());
}
}
array_279.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_281) = &input.version {
object.key("Version").string(var_281.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_282) = &input.bucket_access_role_arn {
object.key("BucketAccessRoleArn").string(var_282.as_str());
}
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_283) = &input.version {
object.key("Version").string(var_283.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_284) = &input.verify_mode {
object.key("VerifyMode").string(var_284.as_str());
}
if let Some(var_285) = &input.overwrite_mode {
object.key("OverwriteMode").string(var_285.as_str());
}
if let Some(var_286) = &input.atime {
object.key("Atime").string(var_286.as_str());
}
if let Some(var_287) = &input.mtime {
object.key("Mtime").string(var_287.as_str());
}
if let Some(var_288) = &input.uid {
object.key("Uid").string(var_288.as_str());
}
if let Some(var_289) = &input.gid {
object.key("Gid").string(var_289.as_str());
}
if let Some(var_290) = &input.preserve_deleted_files {
object.key("PreserveDeletedFiles").string(var_290.as_str());
}
if let Some(var_291) = &input.preserve_devices {
object.key("PreserveDevices").string(var_291.as_str());
}
if let Some(var_292) = &input.posix_permissions {
object.key("PosixPermissions").string(var_292.as_str());
}
if let Some(var_293) = &input.bytes_per_second {
object.key("BytesPerSecond").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_293).into()),
);
}
if let Some(var_294) = &input.task_queueing {
object.key("TaskQueueing").string(var_294.as_str());
}
if let Some(var_295) = &input.log_level {
object.key("LogLevel").string(var_295.as_str());
}
if let Some(var_296) = &input.transfer_mode {
object.key("TransferMode").string(var_296.as_str());
}
if let Some(var_297) = &input.security_descriptor_copy_flags {
object
.key("SecurityDescriptorCopyFlags")
.string(var_297.as_str());
}
if let Some(var_298) = &input.object_tags {
object.key("ObjectTags").string(var_298.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_299) = &input.filter_type {
object.key("FilterType").string(var_299.as_str());
}
if let Some(var_300) = &input.value {
object.key("Value").string(var_300.as_str());
}
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_301) = &input.schedule_expression {
object.key("ScheduleExpression").string(var_301.as_str());
}
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_302) = &input.name {
object.key("Name").string(var_302.as_str());
}
if let Some(var_303) = &input.values {
let mut array_304 = object.key("Values").start_array();
for item_305 in var_303 {
{
array_304.value().string(item_305.as_str());
}
}
array_304.finish();
}
if let Some(var_306) = &input.operator {
object.key("Operator").string(var_306.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_307) = &input.name {
object.key("Name").string(var_307.as_str());
}
if let Some(var_308) = &input.values {
let mut array_309 = object.key("Values").start_array();
for item_310 in var_308 {
{
array_309.value().string(item_310.as_str());
}
}
array_309.finish();
}
if let Some(var_311) = &input.operator {
object.key("Operator").string(var_311.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_fsx_protocol_nfs(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FsxProtocolNfs,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_312) = &input.mount_options {
let mut object_313 = object.key("MountOptions").start_object();
crate::json_ser::serialize_structure_crate_model_nfs_mount_options(
&mut object_313,
var_312,
)?;
object_313.finish();
}
Ok(())
}