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::error::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::error::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 {
{
#[allow(unused_mut)]
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::error::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 {
#[allow(unused_mut)]
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 {
{
#[allow(unused_mut)]
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();
}
if let Some(var_23) = &input.access_point_arn {
object.key("AccessPointArn").string(var_23.as_str());
}
if let Some(var_24) = &input.file_system_access_role_arn {
object
.key("FileSystemAccessRoleArn")
.string(var_24.as_str());
}
if let Some(var_25) = &input.in_transit_encryption {
object.key("InTransitEncryption").string(var_25.as_str());
}
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::error::SerializationError> {
if let Some(var_26) = &input.fsx_filesystem_arn {
object.key("FsxFilesystemArn").string(var_26.as_str());
}
if let Some(var_27) = &input.security_group_arns {
let mut array_28 = object.key("SecurityGroupArns").start_array();
for item_29 in var_27 {
{
array_28.value().string(item_29.as_str());
}
}
array_28.finish();
}
if let Some(var_30) = &input.subdirectory {
object.key("Subdirectory").string(var_30.as_str());
}
if let Some(var_31) = &input.tags {
let mut array_32 = object.key("Tags").start_array();
for item_33 in var_31 {
{
#[allow(unused_mut)]
let mut object_34 = array_32.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag_list_entry(
&mut object_34,
item_33,
)?;
object_34.finish();
}
}
array_32.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_location_fsx_ontap_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateLocationFsxOntapInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_35) = &input.protocol {
#[allow(unused_mut)]
let mut object_36 = object.key("Protocol").start_object();
crate::json_ser::serialize_structure_crate_model_fsx_protocol(&mut object_36, var_35)?;
object_36.finish();
}
if let Some(var_37) = &input.security_group_arns {
let mut array_38 = object.key("SecurityGroupArns").start_array();
for item_39 in var_37 {
{
array_38.value().string(item_39.as_str());
}
}
array_38.finish();
}
if let Some(var_40) = &input.storage_virtual_machine_arn {
object
.key("StorageVirtualMachineArn")
.string(var_40.as_str());
}
if let Some(var_41) = &input.subdirectory {
object.key("Subdirectory").string(var_41.as_str());
}
if let Some(var_42) = &input.tags {
let mut array_43 = object.key("Tags").start_array();
for item_44 in var_42 {
{
#[allow(unused_mut)]
let mut object_45 = array_43.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag_list_entry(
&mut object_45,
item_44,
)?;
object_45.finish();
}
}
array_43.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::error::SerializationError> {
if let Some(var_46) = &input.fsx_filesystem_arn {
object.key("FsxFilesystemArn").string(var_46.as_str());
}
if let Some(var_47) = &input.protocol {
#[allow(unused_mut)]
let mut object_48 = object.key("Protocol").start_object();
crate::json_ser::serialize_structure_crate_model_fsx_protocol(&mut object_48, var_47)?;
object_48.finish();
}
if let Some(var_49) = &input.security_group_arns {
let mut array_50 = object.key("SecurityGroupArns").start_array();
for item_51 in var_49 {
{
array_50.value().string(item_51.as_str());
}
}
array_50.finish();
}
if let Some(var_52) = &input.subdirectory {
object.key("Subdirectory").string(var_52.as_str());
}
if let Some(var_53) = &input.tags {
let mut array_54 = object.key("Tags").start_array();
for item_55 in var_53 {
{
#[allow(unused_mut)]
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_fsx_windows_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateLocationFsxWindowsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_57) = &input.subdirectory {
object.key("Subdirectory").string(var_57.as_str());
}
if let Some(var_58) = &input.fsx_filesystem_arn {
object.key("FsxFilesystemArn").string(var_58.as_str());
}
if let Some(var_59) = &input.security_group_arns {
let mut array_60 = object.key("SecurityGroupArns").start_array();
for item_61 in var_59 {
{
array_60.value().string(item_61.as_str());
}
}
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 {
{
#[allow(unused_mut)]
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();
}
if let Some(var_66) = &input.user {
object.key("User").string(var_66.as_str());
}
if let Some(var_67) = &input.domain {
object.key("Domain").string(var_67.as_str());
}
if let Some(var_68) = &input.password {
object.key("Password").string(var_68.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::error::SerializationError> {
if let Some(var_69) = &input.subdirectory {
object.key("Subdirectory").string(var_69.as_str());
}
if let Some(var_70) = &input.name_nodes {
let mut array_71 = object.key("NameNodes").start_array();
for item_72 in var_70 {
{
#[allow(unused_mut)]
let mut object_73 = array_71.value().start_object();
crate::json_ser::serialize_structure_crate_model_hdfs_name_node(
&mut object_73,
item_72,
)?;
object_73.finish();
}
}
array_71.finish();
}
if let Some(var_74) = &input.block_size {
object.key("BlockSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_74).into()),
);
}
if let Some(var_75) = &input.replication_factor {
object.key("ReplicationFactor").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_75).into()),
);
}
if let Some(var_76) = &input.kms_key_provider_uri {
object.key("KmsKeyProviderUri").string(var_76.as_str());
}
if let Some(var_77) = &input.qop_configuration {
#[allow(unused_mut)]
let mut object_78 = object.key("QopConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_qop_configuration(&mut object_78, var_77)?;
object_78.finish();
}
if let Some(var_79) = &input.authentication_type {
object.key("AuthenticationType").string(var_79.as_str());
}
if let Some(var_80) = &input.simple_user {
object.key("SimpleUser").string(var_80.as_str());
}
if let Some(var_81) = &input.kerberos_principal {
object.key("KerberosPrincipal").string(var_81.as_str());
}
if let Some(var_82) = &input.kerberos_keytab {
object
.key("KerberosKeytab")
.string_unchecked(&aws_smithy_types::base64::encode(var_82));
}
if let Some(var_83) = &input.kerberos_krb5_conf {
object
.key("KerberosKrb5Conf")
.string_unchecked(&aws_smithy_types::base64::encode(var_83));
}
if let Some(var_84) = &input.agent_arns {
let mut array_85 = object.key("AgentArns").start_array();
for item_86 in var_84 {
{
array_85.value().string(item_86.as_str());
}
}
array_85.finish();
}
if let Some(var_87) = &input.tags {
let mut array_88 = object.key("Tags").start_array();
for item_89 in var_87 {
{
#[allow(unused_mut)]
let mut object_90 = array_88.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag_list_entry(
&mut object_90,
item_89,
)?;
object_90.finish();
}
}
array_88.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::error::SerializationError> {
if let Some(var_91) = &input.subdirectory {
object.key("Subdirectory").string(var_91.as_str());
}
if let Some(var_92) = &input.server_hostname {
object.key("ServerHostname").string(var_92.as_str());
}
if let Some(var_93) = &input.on_prem_config {
#[allow(unused_mut)]
let mut object_94 = object.key("OnPremConfig").start_object();
crate::json_ser::serialize_structure_crate_model_on_prem_config(&mut object_94, var_93)?;
object_94.finish();
}
if let Some(var_95) = &input.mount_options {
#[allow(unused_mut)]
let mut object_96 = object.key("MountOptions").start_object();
crate::json_ser::serialize_structure_crate_model_nfs_mount_options(&mut object_96, var_95)?;
object_96.finish();
}
if let Some(var_97) = &input.tags {
let mut array_98 = object.key("Tags").start_array();
for item_99 in var_97 {
{
#[allow(unused_mut)]
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_object_storage_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateLocationObjectStorageInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_101) = &input.server_hostname {
object.key("ServerHostname").string(var_101.as_str());
}
if let Some(var_102) = &input.server_port {
object.key("ServerPort").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_102).into()),
);
}
if let Some(var_103) = &input.server_protocol {
object.key("ServerProtocol").string(var_103.as_str());
}
if let Some(var_104) = &input.subdirectory {
object.key("Subdirectory").string(var_104.as_str());
}
if let Some(var_105) = &input.bucket_name {
object.key("BucketName").string(var_105.as_str());
}
if let Some(var_106) = &input.access_key {
object.key("AccessKey").string(var_106.as_str());
}
if let Some(var_107) = &input.secret_key {
object.key("SecretKey").string(var_107.as_str());
}
if let Some(var_108) = &input.agent_arns {
let mut array_109 = object.key("AgentArns").start_array();
for item_110 in var_108 {
{
array_109.value().string(item_110.as_str());
}
}
array_109.finish();
}
if let Some(var_111) = &input.tags {
let mut array_112 = object.key("Tags").start_array();
for item_113 in var_111 {
{
#[allow(unused_mut)]
let mut object_114 = array_112.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag_list_entry(
&mut object_114,
item_113,
)?;
object_114.finish();
}
}
array_112.finish();
}
if let Some(var_115) = &input.server_certificate {
object
.key("ServerCertificate")
.string_unchecked(&aws_smithy_types::base64::encode(var_115));
}
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::error::SerializationError> {
if let Some(var_116) = &input.subdirectory {
object.key("Subdirectory").string(var_116.as_str());
}
if let Some(var_117) = &input.s3_bucket_arn {
object.key("S3BucketArn").string(var_117.as_str());
}
if let Some(var_118) = &input.s3_storage_class {
object.key("S3StorageClass").string(var_118.as_str());
}
if let Some(var_119) = &input.s3_config {
#[allow(unused_mut)]
let mut object_120 = object.key("S3Config").start_object();
crate::json_ser::serialize_structure_crate_model_s3_config(&mut object_120, var_119)?;
object_120.finish();
}
if let Some(var_121) = &input.agent_arns {
let mut array_122 = object.key("AgentArns").start_array();
for item_123 in var_121 {
{
array_122.value().string(item_123.as_str());
}
}
array_122.finish();
}
if let Some(var_124) = &input.tags {
let mut array_125 = object.key("Tags").start_array();
for item_126 in var_124 {
{
#[allow(unused_mut)]
let mut object_127 = array_125.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag_list_entry(
&mut object_127,
item_126,
)?;
object_127.finish();
}
}
array_125.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::error::SerializationError> {
if let Some(var_128) = &input.subdirectory {
object.key("Subdirectory").string(var_128.as_str());
}
if let Some(var_129) = &input.server_hostname {
object.key("ServerHostname").string(var_129.as_str());
}
if let Some(var_130) = &input.user {
object.key("User").string(var_130.as_str());
}
if let Some(var_131) = &input.domain {
object.key("Domain").string(var_131.as_str());
}
if let Some(var_132) = &input.password {
object.key("Password").string(var_132.as_str());
}
if let Some(var_133) = &input.agent_arns {
let mut array_134 = object.key("AgentArns").start_array();
for item_135 in var_133 {
{
array_134.value().string(item_135.as_str());
}
}
array_134.finish();
}
if let Some(var_136) = &input.mount_options {
#[allow(unused_mut)]
let mut object_137 = object.key("MountOptions").start_object();
crate::json_ser::serialize_structure_crate_model_smb_mount_options(
&mut object_137,
var_136,
)?;
object_137.finish();
}
if let Some(var_138) = &input.tags {
let mut array_139 = object.key("Tags").start_array();
for item_140 in var_138 {
{
#[allow(unused_mut)]
let mut object_141 = array_139.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag_list_entry(
&mut object_141,
item_140,
)?;
object_141.finish();
}
}
array_139.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::error::SerializationError> {
if let Some(var_142) = &input.source_location_arn {
object.key("SourceLocationArn").string(var_142.as_str());
}
if let Some(var_143) = &input.destination_location_arn {
object
.key("DestinationLocationArn")
.string(var_143.as_str());
}
if let Some(var_144) = &input.cloud_watch_log_group_arn {
object.key("CloudWatchLogGroupArn").string(var_144.as_str());
}
if let Some(var_145) = &input.name {
object.key("Name").string(var_145.as_str());
}
if let Some(var_146) = &input.options {
#[allow(unused_mut)]
let mut object_147 = object.key("Options").start_object();
crate::json_ser::serialize_structure_crate_model_options(&mut object_147, var_146)?;
object_147.finish();
}
if let Some(var_148) = &input.excludes {
let mut array_149 = object.key("Excludes").start_array();
for item_150 in var_148 {
{
#[allow(unused_mut)]
let mut object_151 = array_149.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter_rule(
&mut object_151,
item_150,
)?;
object_151.finish();
}
}
array_149.finish();
}
if let Some(var_152) = &input.schedule {
#[allow(unused_mut)]
let mut object_153 = object.key("Schedule").start_object();
crate::json_ser::serialize_structure_crate_model_task_schedule(&mut object_153, var_152)?;
object_153.finish();
}
if let Some(var_154) = &input.tags {
let mut array_155 = object.key("Tags").start_array();
for item_156 in var_154 {
{
#[allow(unused_mut)]
let mut object_157 = array_155.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag_list_entry(
&mut object_157,
item_156,
)?;
object_157.finish();
}
}
array_155.finish();
}
if let Some(var_158) = &input.includes {
let mut array_159 = object.key("Includes").start_array();
for item_160 in var_158 {
{
#[allow(unused_mut)]
let mut object_161 = array_159.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter_rule(
&mut object_161,
item_160,
)?;
object_161.finish();
}
}
array_159.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::error::SerializationError> {
if let Some(var_162) = &input.agent_arn {
object.key("AgentArn").string(var_162.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::error::SerializationError> {
if let Some(var_163) = &input.location_arn {
object.key("LocationArn").string(var_163.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::error::SerializationError> {
if let Some(var_164) = &input.task_arn {
object.key("TaskArn").string(var_164.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::error::SerializationError> {
if let Some(var_165) = &input.agent_arn {
object.key("AgentArn").string(var_165.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::error::SerializationError> {
if let Some(var_166) = &input.location_arn {
object.key("LocationArn").string(var_166.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::error::SerializationError> {
if let Some(var_167) = &input.location_arn {
object.key("LocationArn").string(var_167.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_location_fsx_ontap_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeLocationFsxOntapInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_168) = &input.location_arn {
object.key("LocationArn").string(var_168.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::error::SerializationError> {
if let Some(var_169) = &input.location_arn {
object.key("LocationArn").string(var_169.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::error::SerializationError> {
if let Some(var_170) = &input.location_arn {
object.key("LocationArn").string(var_170.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::error::SerializationError> {
if let Some(var_171) = &input.location_arn {
object.key("LocationArn").string(var_171.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::error::SerializationError> {
if let Some(var_172) = &input.location_arn {
object.key("LocationArn").string(var_172.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::error::SerializationError> {
if let Some(var_173) = &input.location_arn {
object.key("LocationArn").string(var_173.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::error::SerializationError> {
if let Some(var_174) = &input.location_arn {
object.key("LocationArn").string(var_174.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::error::SerializationError> {
if let Some(var_175) = &input.location_arn {
object.key("LocationArn").string(var_175.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::error::SerializationError> {
if let Some(var_176) = &input.task_arn {
object.key("TaskArn").string(var_176.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::error::SerializationError> {
if let Some(var_177) = &input.task_execution_arn {
object.key("TaskExecutionArn").string(var_177.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::error::SerializationError> {
if let Some(var_178) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_178).into()),
);
}
if let Some(var_179) = &input.next_token {
object.key("NextToken").string(var_179.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::error::SerializationError> {
if let Some(var_180) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_180).into()),
);
}
if let Some(var_181) = &input.next_token {
object.key("NextToken").string(var_181.as_str());
}
if let Some(var_182) = &input.filters {
let mut array_183 = object.key("Filters").start_array();
for item_184 in var_182 {
{
#[allow(unused_mut)]
let mut object_185 = array_183.value().start_object();
crate::json_ser::serialize_structure_crate_model_location_filter(
&mut object_185,
item_184,
)?;
object_185.finish();
}
}
array_183.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::error::SerializationError> {
if let Some(var_186) = &input.resource_arn {
object.key("ResourceArn").string(var_186.as_str());
}
if let Some(var_187) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_187).into()),
);
}
if let Some(var_188) = &input.next_token {
object.key("NextToken").string(var_188.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::error::SerializationError> {
if let Some(var_189) = &input.task_arn {
object.key("TaskArn").string(var_189.as_str());
}
if let Some(var_190) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_190).into()),
);
}
if let Some(var_191) = &input.next_token {
object.key("NextToken").string(var_191.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::error::SerializationError> {
if let Some(var_192) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_192).into()),
);
}
if let Some(var_193) = &input.next_token {
object.key("NextToken").string(var_193.as_str());
}
if let Some(var_194) = &input.filters {
let mut array_195 = object.key("Filters").start_array();
for item_196 in var_194 {
{
#[allow(unused_mut)]
let mut object_197 = array_195.value().start_object();
crate::json_ser::serialize_structure_crate_model_task_filter(
&mut object_197,
item_196,
)?;
object_197.finish();
}
}
array_195.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::error::SerializationError> {
if let Some(var_198) = &input.task_arn {
object.key("TaskArn").string(var_198.as_str());
}
if let Some(var_199) = &input.override_options {
#[allow(unused_mut)]
let mut object_200 = object.key("OverrideOptions").start_object();
crate::json_ser::serialize_structure_crate_model_options(&mut object_200, var_199)?;
object_200.finish();
}
if let Some(var_201) = &input.includes {
let mut array_202 = object.key("Includes").start_array();
for item_203 in var_201 {
{
#[allow(unused_mut)]
let mut object_204 = array_202.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter_rule(
&mut object_204,
item_203,
)?;
object_204.finish();
}
}
array_202.finish();
}
if let Some(var_205) = &input.excludes {
let mut array_206 = object.key("Excludes").start_array();
for item_207 in var_205 {
{
#[allow(unused_mut)]
let mut object_208 = array_206.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter_rule(
&mut object_208,
item_207,
)?;
object_208.finish();
}
}
array_206.finish();
}
if let Some(var_209) = &input.tags {
let mut array_210 = object.key("Tags").start_array();
for item_211 in var_209 {
{
#[allow(unused_mut)]
let mut object_212 = array_210.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag_list_entry(
&mut object_212,
item_211,
)?;
object_212.finish();
}
}
array_210.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::error::SerializationError> {
if let Some(var_213) = &input.resource_arn {
object.key("ResourceArn").string(var_213.as_str());
}
if let Some(var_214) = &input.tags {
let mut array_215 = object.key("Tags").start_array();
for item_216 in var_214 {
{
#[allow(unused_mut)]
let mut object_217 = array_215.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag_list_entry(
&mut object_217,
item_216,
)?;
object_217.finish();
}
}
array_215.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::error::SerializationError> {
if let Some(var_218) = &input.resource_arn {
object.key("ResourceArn").string(var_218.as_str());
}
if let Some(var_219) = &input.keys {
let mut array_220 = object.key("Keys").start_array();
for item_221 in var_219 {
{
array_220.value().string(item_221.as_str());
}
}
array_220.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::error::SerializationError> {
if let Some(var_222) = &input.agent_arn {
object.key("AgentArn").string(var_222.as_str());
}
if let Some(var_223) = &input.name {
object.key("Name").string(var_223.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::error::SerializationError> {
if let Some(var_224) = &input.location_arn {
object.key("LocationArn").string(var_224.as_str());
}
if let Some(var_225) = &input.subdirectory {
object.key("Subdirectory").string(var_225.as_str());
}
if let Some(var_226) = &input.name_nodes {
let mut array_227 = object.key("NameNodes").start_array();
for item_228 in var_226 {
{
#[allow(unused_mut)]
let mut object_229 = array_227.value().start_object();
crate::json_ser::serialize_structure_crate_model_hdfs_name_node(
&mut object_229,
item_228,
)?;
object_229.finish();
}
}
array_227.finish();
}
if let Some(var_230) = &input.block_size {
object.key("BlockSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_230).into()),
);
}
if let Some(var_231) = &input.replication_factor {
object.key("ReplicationFactor").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_231).into()),
);
}
if let Some(var_232) = &input.kms_key_provider_uri {
object.key("KmsKeyProviderUri").string(var_232.as_str());
}
if let Some(var_233) = &input.qop_configuration {
#[allow(unused_mut)]
let mut object_234 = object.key("QopConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_qop_configuration(
&mut object_234,
var_233,
)?;
object_234.finish();
}
if let Some(var_235) = &input.authentication_type {
object.key("AuthenticationType").string(var_235.as_str());
}
if let Some(var_236) = &input.simple_user {
object.key("SimpleUser").string(var_236.as_str());
}
if let Some(var_237) = &input.kerberos_principal {
object.key("KerberosPrincipal").string(var_237.as_str());
}
if let Some(var_238) = &input.kerberos_keytab {
object
.key("KerberosKeytab")
.string_unchecked(&aws_smithy_types::base64::encode(var_238));
}
if let Some(var_239) = &input.kerberos_krb5_conf {
object
.key("KerberosKrb5Conf")
.string_unchecked(&aws_smithy_types::base64::encode(var_239));
}
if let Some(var_240) = &input.agent_arns {
let mut array_241 = object.key("AgentArns").start_array();
for item_242 in var_240 {
{
array_241.value().string(item_242.as_str());
}
}
array_241.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::error::SerializationError> {
if let Some(var_243) = &input.location_arn {
object.key("LocationArn").string(var_243.as_str());
}
if let Some(var_244) = &input.subdirectory {
object.key("Subdirectory").string(var_244.as_str());
}
if let Some(var_245) = &input.on_prem_config {
#[allow(unused_mut)]
let mut object_246 = object.key("OnPremConfig").start_object();
crate::json_ser::serialize_structure_crate_model_on_prem_config(&mut object_246, var_245)?;
object_246.finish();
}
if let Some(var_247) = &input.mount_options {
#[allow(unused_mut)]
let mut object_248 = object.key("MountOptions").start_object();
crate::json_ser::serialize_structure_crate_model_nfs_mount_options(
&mut object_248,
var_247,
)?;
object_248.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::error::SerializationError> {
if let Some(var_249) = &input.location_arn {
object.key("LocationArn").string(var_249.as_str());
}
if let Some(var_250) = &input.server_port {
object.key("ServerPort").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_250).into()),
);
}
if let Some(var_251) = &input.server_protocol {
object.key("ServerProtocol").string(var_251.as_str());
}
if let Some(var_252) = &input.subdirectory {
object.key("Subdirectory").string(var_252.as_str());
}
if let Some(var_253) = &input.access_key {
object.key("AccessKey").string(var_253.as_str());
}
if let Some(var_254) = &input.secret_key {
object.key("SecretKey").string(var_254.as_str());
}
if let Some(var_255) = &input.agent_arns {
let mut array_256 = object.key("AgentArns").start_array();
for item_257 in var_255 {
{
array_256.value().string(item_257.as_str());
}
}
array_256.finish();
}
if let Some(var_258) = &input.server_certificate {
object
.key("ServerCertificate")
.string_unchecked(&aws_smithy_types::base64::encode(var_258));
}
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::error::SerializationError> {
if let Some(var_259) = &input.location_arn {
object.key("LocationArn").string(var_259.as_str());
}
if let Some(var_260) = &input.subdirectory {
object.key("Subdirectory").string(var_260.as_str());
}
if let Some(var_261) = &input.user {
object.key("User").string(var_261.as_str());
}
if let Some(var_262) = &input.domain {
object.key("Domain").string(var_262.as_str());
}
if let Some(var_263) = &input.password {
object.key("Password").string(var_263.as_str());
}
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.as_str());
}
}
array_265.finish();
}
if let Some(var_267) = &input.mount_options {
#[allow(unused_mut)]
let mut object_268 = object.key("MountOptions").start_object();
crate::json_ser::serialize_structure_crate_model_smb_mount_options(
&mut object_268,
var_267,
)?;
object_268.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::error::SerializationError> {
if let Some(var_269) = &input.task_arn {
object.key("TaskArn").string(var_269.as_str());
}
if let Some(var_270) = &input.options {
#[allow(unused_mut)]
let mut object_271 = object.key("Options").start_object();
crate::json_ser::serialize_structure_crate_model_options(&mut object_271, var_270)?;
object_271.finish();
}
if let Some(var_272) = &input.excludes {
let mut array_273 = object.key("Excludes").start_array();
for item_274 in var_272 {
{
#[allow(unused_mut)]
let mut object_275 = array_273.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter_rule(
&mut object_275,
item_274,
)?;
object_275.finish();
}
}
array_273.finish();
}
if let Some(var_276) = &input.schedule {
#[allow(unused_mut)]
let mut object_277 = object.key("Schedule").start_object();
crate::json_ser::serialize_structure_crate_model_task_schedule(&mut object_277, var_276)?;
object_277.finish();
}
if let Some(var_278) = &input.name {
object.key("Name").string(var_278.as_str());
}
if let Some(var_279) = &input.cloud_watch_log_group_arn {
object.key("CloudWatchLogGroupArn").string(var_279.as_str());
}
if let Some(var_280) = &input.includes {
let mut array_281 = object.key("Includes").start_array();
for item_282 in var_280 {
{
#[allow(unused_mut)]
let mut object_283 = array_281.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter_rule(
&mut object_283,
item_282,
)?;
object_283.finish();
}
}
array_281.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::error::SerializationError> {
if let Some(var_284) = &input.task_execution_arn {
object.key("TaskExecutionArn").string(var_284.as_str());
}
if let Some(var_285) = &input.options {
#[allow(unused_mut)]
let mut object_286 = object.key("Options").start_object();
crate::json_ser::serialize_structure_crate_model_options(&mut object_286, var_285)?;
object_286.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::error::SerializationError> {
if let Some(var_287) = &input.key {
object.key("Key").string(var_287.as_str());
}
if let Some(var_288) = &input.value {
object.key("Value").string(var_288.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::error::SerializationError> {
if let Some(var_289) = &input.subnet_arn {
object.key("SubnetArn").string(var_289.as_str());
}
if let Some(var_290) = &input.security_group_arns {
let mut array_291 = object.key("SecurityGroupArns").start_array();
for item_292 in var_290 {
{
array_291.value().string(item_292.as_str());
}
}
array_291.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::error::SerializationError> {
if let Some(var_293) = &input.nfs {
#[allow(unused_mut)]
let mut object_294 = object.key("NFS").start_object();
crate::json_ser::serialize_structure_crate_model_fsx_protocol_nfs(
&mut object_294,
var_293,
)?;
object_294.finish();
}
if let Some(var_295) = &input.smb {
#[allow(unused_mut)]
let mut object_296 = object.key("SMB").start_object();
crate::json_ser::serialize_structure_crate_model_fsx_protocol_smb(
&mut object_296,
var_295,
)?;
object_296.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::error::SerializationError> {
if let Some(var_297) = &input.hostname {
object.key("Hostname").string(var_297.as_str());
}
if let Some(var_298) = &input.port {
object.key("Port").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_298).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::error::SerializationError> {
if let Some(var_299) = &input.rpc_protection {
object.key("RpcProtection").string(var_299.as_str());
}
if let Some(var_300) = &input.data_transfer_protection {
object
.key("DataTransferProtection")
.string(var_300.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::error::SerializationError> {
if let Some(var_301) = &input.agent_arns {
let mut array_302 = object.key("AgentArns").start_array();
for item_303 in var_301 {
{
array_302.value().string(item_303.as_str());
}
}
array_302.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::error::SerializationError> {
if let Some(var_304) = &input.version {
object.key("Version").string(var_304.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::error::SerializationError> {
if let Some(var_305) = &input.bucket_access_role_arn {
object.key("BucketAccessRoleArn").string(var_305.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::error::SerializationError> {
if let Some(var_306) = &input.version {
object.key("Version").string(var_306.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::error::SerializationError> {
if let Some(var_307) = &input.verify_mode {
object.key("VerifyMode").string(var_307.as_str());
}
if let Some(var_308) = &input.overwrite_mode {
object.key("OverwriteMode").string(var_308.as_str());
}
if let Some(var_309) = &input.atime {
object.key("Atime").string(var_309.as_str());
}
if let Some(var_310) = &input.mtime {
object.key("Mtime").string(var_310.as_str());
}
if let Some(var_311) = &input.uid {
object.key("Uid").string(var_311.as_str());
}
if let Some(var_312) = &input.gid {
object.key("Gid").string(var_312.as_str());
}
if let Some(var_313) = &input.preserve_deleted_files {
object.key("PreserveDeletedFiles").string(var_313.as_str());
}
if let Some(var_314) = &input.preserve_devices {
object.key("PreserveDevices").string(var_314.as_str());
}
if let Some(var_315) = &input.posix_permissions {
object.key("PosixPermissions").string(var_315.as_str());
}
if let Some(var_316) = &input.bytes_per_second {
object.key("BytesPerSecond").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_316).into()),
);
}
if let Some(var_317) = &input.task_queueing {
object.key("TaskQueueing").string(var_317.as_str());
}
if let Some(var_318) = &input.log_level {
object.key("LogLevel").string(var_318.as_str());
}
if let Some(var_319) = &input.transfer_mode {
object.key("TransferMode").string(var_319.as_str());
}
if let Some(var_320) = &input.security_descriptor_copy_flags {
object
.key("SecurityDescriptorCopyFlags")
.string(var_320.as_str());
}
if let Some(var_321) = &input.object_tags {
object.key("ObjectTags").string(var_321.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::error::SerializationError> {
if let Some(var_322) = &input.filter_type {
object.key("FilterType").string(var_322.as_str());
}
if let Some(var_323) = &input.value {
object.key("Value").string(var_323.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::error::SerializationError> {
if let Some(var_324) = &input.schedule_expression {
object.key("ScheduleExpression").string(var_324.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::error::SerializationError> {
if let Some(var_325) = &input.name {
object.key("Name").string(var_325.as_str());
}
if let Some(var_326) = &input.values {
let mut array_327 = object.key("Values").start_array();
for item_328 in var_326 {
{
array_327.value().string(item_328.as_str());
}
}
array_327.finish();
}
if let Some(var_329) = &input.operator {
object.key("Operator").string(var_329.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::error::SerializationError> {
if let Some(var_330) = &input.name {
object.key("Name").string(var_330.as_str());
}
if let Some(var_331) = &input.values {
let mut array_332 = object.key("Values").start_array();
for item_333 in var_331 {
{
array_332.value().string(item_333.as_str());
}
}
array_332.finish();
}
if let Some(var_334) = &input.operator {
object.key("Operator").string(var_334.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::error::SerializationError> {
if let Some(var_335) = &input.mount_options {
#[allow(unused_mut)]
let mut object_336 = object.key("MountOptions").start_object();
crate::json_ser::serialize_structure_crate_model_nfs_mount_options(
&mut object_336,
var_335,
)?;
object_336.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_fsx_protocol_smb(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FsxProtocolSmb,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_337) = &input.domain {
object.key("Domain").string(var_337.as_str());
}
if let Some(var_338) = &input.mount_options {
#[allow(unused_mut)]
let mut object_339 = object.key("MountOptions").start_object();
crate::json_ser::serialize_structure_crate_model_smb_mount_options(
&mut object_339,
var_338,
)?;
object_339.finish();
}
if let Some(var_340) = &input.password {
object.key("Password").string(var_340.as_str());
}
if let Some(var_341) = &input.user {
object.key("User").string(var_341.as_str());
}
Ok(())
}