pub fn serialize_structure_crate_input_activate_gateway_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ActivateGatewayInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.activation_key {
object.key("ActivationKey").string(var_1.as_str());
}
if let Some(var_2) = &input.gateway_name {
object.key("GatewayName").string(var_2.as_str());
}
if let Some(var_3) = &input.gateway_timezone {
object.key("GatewayTimezone").string(var_3.as_str());
}
if let Some(var_4) = &input.gateway_region {
object.key("GatewayRegion").string(var_4.as_str());
}
if let Some(var_5) = &input.gateway_type {
object.key("GatewayType").string(var_5.as_str());
}
if let Some(var_6) = &input.tape_drive_type {
object.key("TapeDriveType").string(var_6.as_str());
}
if let Some(var_7) = &input.medium_changer_type {
object.key("MediumChangerType").string(var_7.as_str());
}
if let Some(var_8) = &input.tags {
let mut array_9 = object.key("Tags").start_array();
for item_10 in var_8 {
{
#[allow(unused_mut)]
let mut object_11 = array_9.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_11, item_10)?;
object_11.finish();
}
}
array_9.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_add_cache_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AddCacheInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_12) = &input.gateway_arn {
object.key("GatewayARN").string(var_12.as_str());
}
if let Some(var_13) = &input.disk_ids {
let mut array_14 = object.key("DiskIds").start_array();
for item_15 in var_13 {
{
array_14.value().string(item_15.as_str());
}
}
array_14.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_add_tags_to_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AddTagsToResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_16) = &input.resource_arn {
object.key("ResourceARN").string(var_16.as_str());
}
if let Some(var_17) = &input.tags {
let mut array_18 = object.key("Tags").start_array();
for item_19 in var_17 {
{
#[allow(unused_mut)]
let mut object_20 = array_18.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_20, item_19)?;
object_20.finish();
}
}
array_18.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_add_upload_buffer_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AddUploadBufferInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_21) = &input.gateway_arn {
object.key("GatewayARN").string(var_21.as_str());
}
if let Some(var_22) = &input.disk_ids {
let mut array_23 = object.key("DiskIds").start_array();
for item_24 in var_22 {
{
array_23.value().string(item_24.as_str());
}
}
array_23.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_add_working_storage_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AddWorkingStorageInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_25) = &input.gateway_arn {
object.key("GatewayARN").string(var_25.as_str());
}
if let Some(var_26) = &input.disk_ids {
let mut array_27 = object.key("DiskIds").start_array();
for item_28 in var_26 {
{
array_27.value().string(item_28.as_str());
}
}
array_27.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_assign_tape_pool_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssignTapePoolInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_29) = &input.tape_arn {
object.key("TapeARN").string(var_29.as_str());
}
if let Some(var_30) = &input.pool_id {
object.key("PoolId").string(var_30.as_str());
}
if input.bypass_governance_retention {
object
.key("BypassGovernanceRetention")
.boolean(input.bypass_governance_retention);
}
Ok(())
}
pub fn serialize_structure_crate_input_associate_file_system_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociateFileSystemInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_31) = &input.user_name {
object.key("UserName").string(var_31.as_str());
}
if let Some(var_32) = &input.password {
object.key("Password").string(var_32.as_str());
}
if let Some(var_33) = &input.client_token {
object.key("ClientToken").string(var_33.as_str());
}
if let Some(var_34) = &input.gateway_arn {
object.key("GatewayARN").string(var_34.as_str());
}
if let Some(var_35) = &input.location_arn {
object.key("LocationARN").string(var_35.as_str());
}
if let Some(var_36) = &input.tags {
let mut array_37 = object.key("Tags").start_array();
for item_38 in var_36 {
{
#[allow(unused_mut)]
let mut object_39 = array_37.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_39, item_38)?;
object_39.finish();
}
}
array_37.finish();
}
if let Some(var_40) = &input.audit_destination_arn {
object.key("AuditDestinationARN").string(var_40.as_str());
}
if let Some(var_41) = &input.cache_attributes {
#[allow(unused_mut)]
let mut object_42 = object.key("CacheAttributes").start_object();
crate::json_ser::serialize_structure_crate_model_cache_attributes(&mut object_42, var_41)?;
object_42.finish();
}
if let Some(var_43) = &input.endpoint_network_configuration {
#[allow(unused_mut)]
let mut object_44 = object.key("EndpointNetworkConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_endpoint_network_configuration(
&mut object_44,
var_43,
)?;
object_44.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_attach_volume_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AttachVolumeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_45) = &input.gateway_arn {
object.key("GatewayARN").string(var_45.as_str());
}
if let Some(var_46) = &input.target_name {
object.key("TargetName").string(var_46.as_str());
}
if let Some(var_47) = &input.volume_arn {
object.key("VolumeARN").string(var_47.as_str());
}
if let Some(var_48) = &input.network_interface_id {
object.key("NetworkInterfaceId").string(var_48.as_str());
}
if let Some(var_49) = &input.disk_id {
object.key("DiskId").string(var_49.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_cancel_archival_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CancelArchivalInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_50) = &input.gateway_arn {
object.key("GatewayARN").string(var_50.as_str());
}
if let Some(var_51) = &input.tape_arn {
object.key("TapeARN").string(var_51.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_cancel_retrieval_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CancelRetrievalInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_52) = &input.gateway_arn {
object.key("GatewayARN").string(var_52.as_str());
}
if let Some(var_53) = &input.tape_arn {
object.key("TapeARN").string(var_53.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_cachedi_scsi_volume_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateCachediScsiVolumeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_54) = &input.gateway_arn {
object.key("GatewayARN").string(var_54.as_str());
}
{
object.key("VolumeSizeInBytes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.volume_size_in_bytes).into()),
);
}
if let Some(var_55) = &input.snapshot_id {
object.key("SnapshotId").string(var_55.as_str());
}
if let Some(var_56) = &input.target_name {
object.key("TargetName").string(var_56.as_str());
}
if let Some(var_57) = &input.source_volume_arn {
object.key("SourceVolumeARN").string(var_57.as_str());
}
if let Some(var_58) = &input.network_interface_id {
object.key("NetworkInterfaceId").string(var_58.as_str());
}
if let Some(var_59) = &input.client_token {
object.key("ClientToken").string(var_59.as_str());
}
if let Some(var_60) = &input.kms_encrypted {
object.key("KMSEncrypted").boolean(*var_60);
}
if let Some(var_61) = &input.kms_key {
object.key("KMSKey").string(var_61.as_str());
}
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(&mut object_65, item_64)?;
object_65.finish();
}
}
array_63.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_nfs_file_share_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateNfsFileShareInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_66) = &input.client_token {
object.key("ClientToken").string(var_66.as_str());
}
if let Some(var_67) = &input.nfs_file_share_defaults {
#[allow(unused_mut)]
let mut object_68 = object.key("NFSFileShareDefaults").start_object();
crate::json_ser::serialize_structure_crate_model_nfs_file_share_defaults(
&mut object_68,
var_67,
)?;
object_68.finish();
}
if let Some(var_69) = &input.gateway_arn {
object.key("GatewayARN").string(var_69.as_str());
}
if let Some(var_70) = &input.kms_encrypted {
object.key("KMSEncrypted").boolean(*var_70);
}
if let Some(var_71) = &input.kms_key {
object.key("KMSKey").string(var_71.as_str());
}
if let Some(var_72) = &input.role {
object.key("Role").string(var_72.as_str());
}
if let Some(var_73) = &input.location_arn {
object.key("LocationARN").string(var_73.as_str());
}
if let Some(var_74) = &input.default_storage_class {
object.key("DefaultStorageClass").string(var_74.as_str());
}
if let Some(var_75) = &input.object_acl {
object.key("ObjectACL").string(var_75.as_str());
}
if let Some(var_76) = &input.client_list {
let mut array_77 = object.key("ClientList").start_array();
for item_78 in var_76 {
{
array_77.value().string(item_78.as_str());
}
}
array_77.finish();
}
if let Some(var_79) = &input.squash {
object.key("Squash").string(var_79.as_str());
}
if let Some(var_80) = &input.read_only {
object.key("ReadOnly").boolean(*var_80);
}
if let Some(var_81) = &input.guess_mime_type_enabled {
object.key("GuessMIMETypeEnabled").boolean(*var_81);
}
if let Some(var_82) = &input.requester_pays {
object.key("RequesterPays").boolean(*var_82);
}
if let Some(var_83) = &input.tags {
let mut array_84 = object.key("Tags").start_array();
for item_85 in var_83 {
{
#[allow(unused_mut)]
let mut object_86 = array_84.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_86, item_85)?;
object_86.finish();
}
}
array_84.finish();
}
if let Some(var_87) = &input.file_share_name {
object.key("FileShareName").string(var_87.as_str());
}
if let Some(var_88) = &input.cache_attributes {
#[allow(unused_mut)]
let mut object_89 = object.key("CacheAttributes").start_object();
crate::json_ser::serialize_structure_crate_model_cache_attributes(&mut object_89, var_88)?;
object_89.finish();
}
if let Some(var_90) = &input.notification_policy {
object.key("NotificationPolicy").string(var_90.as_str());
}
if let Some(var_91) = &input.vpc_endpoint_dns_name {
object.key("VPCEndpointDNSName").string(var_91.as_str());
}
if let Some(var_92) = &input.bucket_region {
object.key("BucketRegion").string(var_92.as_str());
}
if let Some(var_93) = &input.audit_destination_arn {
object.key("AuditDestinationARN").string(var_93.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_smb_file_share_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateSmbFileShareInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_94) = &input.client_token {
object.key("ClientToken").string(var_94.as_str());
}
if let Some(var_95) = &input.gateway_arn {
object.key("GatewayARN").string(var_95.as_str());
}
if let Some(var_96) = &input.kms_encrypted {
object.key("KMSEncrypted").boolean(*var_96);
}
if let Some(var_97) = &input.kms_key {
object.key("KMSKey").string(var_97.as_str());
}
if let Some(var_98) = &input.role {
object.key("Role").string(var_98.as_str());
}
if let Some(var_99) = &input.location_arn {
object.key("LocationARN").string(var_99.as_str());
}
if let Some(var_100) = &input.default_storage_class {
object.key("DefaultStorageClass").string(var_100.as_str());
}
if let Some(var_101) = &input.object_acl {
object.key("ObjectACL").string(var_101.as_str());
}
if let Some(var_102) = &input.read_only {
object.key("ReadOnly").boolean(*var_102);
}
if let Some(var_103) = &input.guess_mime_type_enabled {
object.key("GuessMIMETypeEnabled").boolean(*var_103);
}
if let Some(var_104) = &input.requester_pays {
object.key("RequesterPays").boolean(*var_104);
}
if let Some(var_105) = &input.smbacl_enabled {
object.key("SMBACLEnabled").boolean(*var_105);
}
if let Some(var_106) = &input.access_based_enumeration {
object.key("AccessBasedEnumeration").boolean(*var_106);
}
if let Some(var_107) = &input.admin_user_list {
let mut array_108 = object.key("AdminUserList").start_array();
for item_109 in var_107 {
{
array_108.value().string(item_109.as_str());
}
}
array_108.finish();
}
if let Some(var_110) = &input.valid_user_list {
let mut array_111 = object.key("ValidUserList").start_array();
for item_112 in var_110 {
{
array_111.value().string(item_112.as_str());
}
}
array_111.finish();
}
if let Some(var_113) = &input.invalid_user_list {
let mut array_114 = object.key("InvalidUserList").start_array();
for item_115 in var_113 {
{
array_114.value().string(item_115.as_str());
}
}
array_114.finish();
}
if let Some(var_116) = &input.audit_destination_arn {
object.key("AuditDestinationARN").string(var_116.as_str());
}
if let Some(var_117) = &input.authentication {
object.key("Authentication").string(var_117.as_str());
}
if let Some(var_118) = &input.case_sensitivity {
object.key("CaseSensitivity").string(var_118.as_str());
}
if let Some(var_119) = &input.tags {
let mut array_120 = object.key("Tags").start_array();
for item_121 in var_119 {
{
#[allow(unused_mut)]
let mut object_122 = array_120.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_122, item_121)?;
object_122.finish();
}
}
array_120.finish();
}
if let Some(var_123) = &input.file_share_name {
object.key("FileShareName").string(var_123.as_str());
}
if let Some(var_124) = &input.cache_attributes {
#[allow(unused_mut)]
let mut object_125 = object.key("CacheAttributes").start_object();
crate::json_ser::serialize_structure_crate_model_cache_attributes(
&mut object_125,
var_124,
)?;
object_125.finish();
}
if let Some(var_126) = &input.notification_policy {
object.key("NotificationPolicy").string(var_126.as_str());
}
if let Some(var_127) = &input.vpc_endpoint_dns_name {
object.key("VPCEndpointDNSName").string(var_127.as_str());
}
if let Some(var_128) = &input.bucket_region {
object.key("BucketRegion").string(var_128.as_str());
}
if let Some(var_129) = &input.oplocks_enabled {
object.key("OplocksEnabled").boolean(*var_129);
}
Ok(())
}
pub fn serialize_structure_crate_input_create_snapshot_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateSnapshotInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_130) = &input.volume_arn {
object.key("VolumeARN").string(var_130.as_str());
}
if let Some(var_131) = &input.snapshot_description {
object.key("SnapshotDescription").string(var_131.as_str());
}
if let Some(var_132) = &input.tags {
let mut array_133 = object.key("Tags").start_array();
for item_134 in var_132 {
{
#[allow(unused_mut)]
let mut object_135 = array_133.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_135, item_134)?;
object_135.finish();
}
}
array_133.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_snapshot_from_volume_recovery_point_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateSnapshotFromVolumeRecoveryPointInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_136) = &input.volume_arn {
object.key("VolumeARN").string(var_136.as_str());
}
if let Some(var_137) = &input.snapshot_description {
object.key("SnapshotDescription").string(var_137.as_str());
}
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(&mut object_141, item_140)?;
object_141.finish();
}
}
array_139.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_storedi_scsi_volume_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateStorediScsiVolumeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_142) = &input.gateway_arn {
object.key("GatewayARN").string(var_142.as_str());
}
if let Some(var_143) = &input.disk_id {
object.key("DiskId").string(var_143.as_str());
}
if let Some(var_144) = &input.snapshot_id {
object.key("SnapshotId").string(var_144.as_str());
}
{
object
.key("PreserveExistingData")
.boolean(input.preserve_existing_data);
}
if let Some(var_145) = &input.target_name {
object.key("TargetName").string(var_145.as_str());
}
if let Some(var_146) = &input.network_interface_id {
object.key("NetworkInterfaceId").string(var_146.as_str());
}
if let Some(var_147) = &input.kms_encrypted {
object.key("KMSEncrypted").boolean(*var_147);
}
if let Some(var_148) = &input.kms_key {
object.key("KMSKey").string(var_148.as_str());
}
if let Some(var_149) = &input.tags {
let mut array_150 = object.key("Tags").start_array();
for item_151 in var_149 {
{
#[allow(unused_mut)]
let mut object_152 = array_150.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_152, item_151)?;
object_152.finish();
}
}
array_150.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_tape_pool_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateTapePoolInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_153) = &input.pool_name {
object.key("PoolName").string(var_153.as_str());
}
if let Some(var_154) = &input.storage_class {
object.key("StorageClass").string(var_154.as_str());
}
if let Some(var_155) = &input.retention_lock_type {
object.key("RetentionLockType").string(var_155.as_str());
}
if let Some(var_156) = &input.retention_lock_time_in_days {
object.key("RetentionLockTimeInDays").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_156).into()),
);
}
if let Some(var_157) = &input.tags {
let mut array_158 = object.key("Tags").start_array();
for item_159 in var_157 {
{
#[allow(unused_mut)]
let mut object_160 = array_158.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_160, item_159)?;
object_160.finish();
}
}
array_158.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_tapes_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateTapesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_161) = &input.gateway_arn {
object.key("GatewayARN").string(var_161.as_str());
}
if let Some(var_162) = &input.tape_size_in_bytes {
object.key("TapeSizeInBytes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_162).into()),
);
}
if let Some(var_163) = &input.client_token {
object.key("ClientToken").string(var_163.as_str());
}
if let Some(var_164) = &input.num_tapes_to_create {
object.key("NumTapesToCreate").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_164).into()),
);
}
if let Some(var_165) = &input.tape_barcode_prefix {
object.key("TapeBarcodePrefix").string(var_165.as_str());
}
if let Some(var_166) = &input.kms_encrypted {
object.key("KMSEncrypted").boolean(*var_166);
}
if let Some(var_167) = &input.kms_key {
object.key("KMSKey").string(var_167.as_str());
}
if let Some(var_168) = &input.pool_id {
object.key("PoolId").string(var_168.as_str());
}
if input.worm {
object.key("Worm").boolean(input.worm);
}
if let Some(var_169) = &input.tags {
let mut array_170 = object.key("Tags").start_array();
for item_171 in var_169 {
{
#[allow(unused_mut)]
let mut object_172 = array_170.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_172, item_171)?;
object_172.finish();
}
}
array_170.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_tape_with_barcode_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateTapeWithBarcodeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_173) = &input.gateway_arn {
object.key("GatewayARN").string(var_173.as_str());
}
if let Some(var_174) = &input.tape_size_in_bytes {
object.key("TapeSizeInBytes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_174).into()),
);
}
if let Some(var_175) = &input.tape_barcode {
object.key("TapeBarcode").string(var_175.as_str());
}
if let Some(var_176) = &input.kms_encrypted {
object.key("KMSEncrypted").boolean(*var_176);
}
if let Some(var_177) = &input.kms_key {
object.key("KMSKey").string(var_177.as_str());
}
if let Some(var_178) = &input.pool_id {
object.key("PoolId").string(var_178.as_str());
}
if input.worm {
object.key("Worm").boolean(input.worm);
}
if let Some(var_179) = &input.tags {
let mut array_180 = object.key("Tags").start_array();
for item_181 in var_179 {
{
#[allow(unused_mut)]
let mut object_182 = array_180.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_182, item_181)?;
object_182.finish();
}
}
array_180.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_automatic_tape_creation_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteAutomaticTapeCreationPolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_183) = &input.gateway_arn {
object.key("GatewayARN").string(var_183.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_bandwidth_rate_limit_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteBandwidthRateLimitInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_184) = &input.gateway_arn {
object.key("GatewayARN").string(var_184.as_str());
}
if let Some(var_185) = &input.bandwidth_type {
object.key("BandwidthType").string(var_185.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_chap_credentials_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteChapCredentialsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_186) = &input.target_arn {
object.key("TargetARN").string(var_186.as_str());
}
if let Some(var_187) = &input.initiator_name {
object.key("InitiatorName").string(var_187.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_file_share_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteFileShareInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_188) = &input.file_share_arn {
object.key("FileShareARN").string(var_188.as_str());
}
if input.force_delete {
object.key("ForceDelete").boolean(input.force_delete);
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_gateway_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteGatewayInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_189) = &input.gateway_arn {
object.key("GatewayARN").string(var_189.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_snapshot_schedule_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteSnapshotScheduleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_190) = &input.volume_arn {
object.key("VolumeARN").string(var_190.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_tape_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteTapeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_191) = &input.gateway_arn {
object.key("GatewayARN").string(var_191.as_str());
}
if let Some(var_192) = &input.tape_arn {
object.key("TapeARN").string(var_192.as_str());
}
if input.bypass_governance_retention {
object
.key("BypassGovernanceRetention")
.boolean(input.bypass_governance_retention);
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_tape_archive_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteTapeArchiveInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_193) = &input.tape_arn {
object.key("TapeARN").string(var_193.as_str());
}
if input.bypass_governance_retention {
object
.key("BypassGovernanceRetention")
.boolean(input.bypass_governance_retention);
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_tape_pool_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteTapePoolInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_194) = &input.pool_arn {
object.key("PoolARN").string(var_194.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_volume_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteVolumeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_195) = &input.volume_arn {
object.key("VolumeARN").string(var_195.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_availability_monitor_test_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeAvailabilityMonitorTestInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_196) = &input.gateway_arn {
object.key("GatewayARN").string(var_196.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_bandwidth_rate_limit_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeBandwidthRateLimitInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_197) = &input.gateway_arn {
object.key("GatewayARN").string(var_197.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_bandwidth_rate_limit_schedule_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeBandwidthRateLimitScheduleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_198) = &input.gateway_arn {
object.key("GatewayARN").string(var_198.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_cache_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeCacheInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_199) = &input.gateway_arn {
object.key("GatewayARN").string(var_199.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_cachedi_scsi_volumes_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeCachediScsiVolumesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_200) = &input.volume_ar_ns {
let mut array_201 = object.key("VolumeARNs").start_array();
for item_202 in var_200 {
{
array_201.value().string(item_202.as_str());
}
}
array_201.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_chap_credentials_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeChapCredentialsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_203) = &input.target_arn {
object.key("TargetARN").string(var_203.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_file_system_associations_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeFileSystemAssociationsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_204) = &input.file_system_association_arn_list {
let mut array_205 = object.key("FileSystemAssociationARNList").start_array();
for item_206 in var_204 {
{
array_205.value().string(item_206.as_str());
}
}
array_205.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_gateway_information_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeGatewayInformationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_207) = &input.gateway_arn {
object.key("GatewayARN").string(var_207.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_maintenance_start_time_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeMaintenanceStartTimeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_208) = &input.gateway_arn {
object.key("GatewayARN").string(var_208.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_nfs_file_shares_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeNfsFileSharesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_209) = &input.file_share_arn_list {
let mut array_210 = object.key("FileShareARNList").start_array();
for item_211 in var_209 {
{
array_210.value().string(item_211.as_str());
}
}
array_210.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_smb_file_shares_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeSmbFileSharesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_212) = &input.file_share_arn_list {
let mut array_213 = object.key("FileShareARNList").start_array();
for item_214 in var_212 {
{
array_213.value().string(item_214.as_str());
}
}
array_213.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_smb_settings_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeSmbSettingsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_215) = &input.gateway_arn {
object.key("GatewayARN").string(var_215.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_snapshot_schedule_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeSnapshotScheduleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_216) = &input.volume_arn {
object.key("VolumeARN").string(var_216.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_storedi_scsi_volumes_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeStorediScsiVolumesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_217) = &input.volume_ar_ns {
let mut array_218 = object.key("VolumeARNs").start_array();
for item_219 in var_217 {
{
array_218.value().string(item_219.as_str());
}
}
array_218.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_tape_archives_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeTapeArchivesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_220) = &input.tape_ar_ns {
let mut array_221 = object.key("TapeARNs").start_array();
for item_222 in var_220 {
{
array_221.value().string(item_222.as_str());
}
}
array_221.finish();
}
if let Some(var_223) = &input.marker {
object.key("Marker").string(var_223.as_str());
}
if let Some(var_224) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_224).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_tape_recovery_points_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeTapeRecoveryPointsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_225) = &input.gateway_arn {
object.key("GatewayARN").string(var_225.as_str());
}
if let Some(var_226) = &input.marker {
object.key("Marker").string(var_226.as_str());
}
if let Some(var_227) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_227).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_tapes_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeTapesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_228) = &input.gateway_arn {
object.key("GatewayARN").string(var_228.as_str());
}
if let Some(var_229) = &input.tape_ar_ns {
let mut array_230 = object.key("TapeARNs").start_array();
for item_231 in var_229 {
{
array_230.value().string(item_231.as_str());
}
}
array_230.finish();
}
if let Some(var_232) = &input.marker {
object.key("Marker").string(var_232.as_str());
}
if let Some(var_233) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_233).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_upload_buffer_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeUploadBufferInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_234) = &input.gateway_arn {
object.key("GatewayARN").string(var_234.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_vtl_devices_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeVtlDevicesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_235) = &input.gateway_arn {
object.key("GatewayARN").string(var_235.as_str());
}
if let Some(var_236) = &input.vtl_device_ar_ns {
let mut array_237 = object.key("VTLDeviceARNs").start_array();
for item_238 in var_236 {
{
array_237.value().string(item_238.as_str());
}
}
array_237.finish();
}
if let Some(var_239) = &input.marker {
object.key("Marker").string(var_239.as_str());
}
if let Some(var_240) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_240).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_working_storage_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeWorkingStorageInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_241) = &input.gateway_arn {
object.key("GatewayARN").string(var_241.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_detach_volume_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DetachVolumeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_242) = &input.volume_arn {
object.key("VolumeARN").string(var_242.as_str());
}
if let Some(var_243) = &input.force_detach {
object.key("ForceDetach").boolean(*var_243);
}
Ok(())
}
pub fn serialize_structure_crate_input_disable_gateway_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DisableGatewayInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_244) = &input.gateway_arn {
object.key("GatewayARN").string(var_244.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_disassociate_file_system_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DisassociateFileSystemInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_245) = &input.file_system_association_arn {
object
.key("FileSystemAssociationARN")
.string(var_245.as_str());
}
if input.force_delete {
object.key("ForceDelete").boolean(input.force_delete);
}
Ok(())
}
pub fn serialize_structure_crate_input_join_domain_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::JoinDomainInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_246) = &input.gateway_arn {
object.key("GatewayARN").string(var_246.as_str());
}
if let Some(var_247) = &input.domain_name {
object.key("DomainName").string(var_247.as_str());
}
if let Some(var_248) = &input.organizational_unit {
object.key("OrganizationalUnit").string(var_248.as_str());
}
if let Some(var_249) = &input.domain_controllers {
let mut array_250 = object.key("DomainControllers").start_array();
for item_251 in var_249 {
{
array_250.value().string(item_251.as_str());
}
}
array_250.finish();
}
if let Some(var_252) = &input.timeout_in_seconds {
object.key("TimeoutInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_252).into()),
);
}
if let Some(var_253) = &input.user_name {
object.key("UserName").string(var_253.as_str());
}
if let Some(var_254) = &input.password {
object.key("Password").string(var_254.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_automatic_tape_creation_policies_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListAutomaticTapeCreationPoliciesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_255) = &input.gateway_arn {
object.key("GatewayARN").string(var_255.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_file_shares_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListFileSharesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_256) = &input.gateway_arn {
object.key("GatewayARN").string(var_256.as_str());
}
if let Some(var_257) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_257).into()),
);
}
if let Some(var_258) = &input.marker {
object.key("Marker").string(var_258.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_file_system_associations_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListFileSystemAssociationsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_259) = &input.gateway_arn {
object.key("GatewayARN").string(var_259.as_str());
}
if let Some(var_260) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_260).into()),
);
}
if let Some(var_261) = &input.marker {
object.key("Marker").string(var_261.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_gateways_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListGatewaysInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_262) = &input.marker {
object.key("Marker").string(var_262.as_str());
}
if let Some(var_263) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_263).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_local_disks_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListLocalDisksInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_264) = &input.gateway_arn {
object.key("GatewayARN").string(var_264.as_str());
}
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_265) = &input.resource_arn {
object.key("ResourceARN").string(var_265.as_str());
}
if let Some(var_266) = &input.marker {
object.key("Marker").string(var_266.as_str());
}
if let Some(var_267) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_267).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_tape_pools_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListTapePoolsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_268) = &input.pool_ar_ns {
let mut array_269 = object.key("PoolARNs").start_array();
for item_270 in var_268 {
{
array_269.value().string(item_270.as_str());
}
}
array_269.finish();
}
if let Some(var_271) = &input.marker {
object.key("Marker").string(var_271.as_str());
}
if let Some(var_272) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_272).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_tapes_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListTapesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_273) = &input.tape_ar_ns {
let mut array_274 = object.key("TapeARNs").start_array();
for item_275 in var_273 {
{
array_274.value().string(item_275.as_str());
}
}
array_274.finish();
}
if let Some(var_276) = &input.marker {
object.key("Marker").string(var_276.as_str());
}
if let Some(var_277) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_277).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_volume_initiators_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListVolumeInitiatorsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_278) = &input.volume_arn {
object.key("VolumeARN").string(var_278.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_volume_recovery_points_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListVolumeRecoveryPointsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_279) = &input.gateway_arn {
object.key("GatewayARN").string(var_279.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_volumes_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListVolumesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_280) = &input.gateway_arn {
object.key("GatewayARN").string(var_280.as_str());
}
if let Some(var_281) = &input.marker {
object.key("Marker").string(var_281.as_str());
}
if let Some(var_282) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_282).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_notify_when_uploaded_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::NotifyWhenUploadedInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_283) = &input.file_share_arn {
object.key("FileShareARN").string(var_283.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_refresh_cache_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RefreshCacheInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_284) = &input.file_share_arn {
object.key("FileShareARN").string(var_284.as_str());
}
if let Some(var_285) = &input.folder_list {
let mut array_286 = object.key("FolderList").start_array();
for item_287 in var_285 {
{
array_286.value().string(item_287.as_str());
}
}
array_286.finish();
}
if let Some(var_288) = &input.recursive {
object.key("Recursive").boolean(*var_288);
}
Ok(())
}
pub fn serialize_structure_crate_input_remove_tags_from_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RemoveTagsFromResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_289) = &input.resource_arn {
object.key("ResourceARN").string(var_289.as_str());
}
if let Some(var_290) = &input.tag_keys {
let mut array_291 = object.key("TagKeys").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_input_reset_cache_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ResetCacheInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_293) = &input.gateway_arn {
object.key("GatewayARN").string(var_293.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_retrieve_tape_archive_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RetrieveTapeArchiveInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_294) = &input.tape_arn {
object.key("TapeARN").string(var_294.as_str());
}
if let Some(var_295) = &input.gateway_arn {
object.key("GatewayARN").string(var_295.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_retrieve_tape_recovery_point_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RetrieveTapeRecoveryPointInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_296) = &input.tape_arn {
object.key("TapeARN").string(var_296.as_str());
}
if let Some(var_297) = &input.gateway_arn {
object.key("GatewayARN").string(var_297.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_set_local_console_password_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::SetLocalConsolePasswordInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_298) = &input.gateway_arn {
object.key("GatewayARN").string(var_298.as_str());
}
if let Some(var_299) = &input.local_console_password {
object.key("LocalConsolePassword").string(var_299.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_set_smb_guest_password_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::SetSmbGuestPasswordInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_300) = &input.gateway_arn {
object.key("GatewayARN").string(var_300.as_str());
}
if let Some(var_301) = &input.password {
object.key("Password").string(var_301.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_shutdown_gateway_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ShutdownGatewayInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_302) = &input.gateway_arn {
object.key("GatewayARN").string(var_302.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_start_availability_monitor_test_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartAvailabilityMonitorTestInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_303) = &input.gateway_arn {
object.key("GatewayARN").string(var_303.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_start_gateway_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartGatewayInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_304) = &input.gateway_arn {
object.key("GatewayARN").string(var_304.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_automatic_tape_creation_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateAutomaticTapeCreationPolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_305) = &input.automatic_tape_creation_rules {
let mut array_306 = object.key("AutomaticTapeCreationRules").start_array();
for item_307 in var_305 {
{
#[allow(unused_mut)]
let mut object_308 = array_306.value().start_object();
crate::json_ser::serialize_structure_crate_model_automatic_tape_creation_rule(
&mut object_308,
item_307,
)?;
object_308.finish();
}
}
array_306.finish();
}
if let Some(var_309) = &input.gateway_arn {
object.key("GatewayARN").string(var_309.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_bandwidth_rate_limit_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateBandwidthRateLimitInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_310) = &input.gateway_arn {
object.key("GatewayARN").string(var_310.as_str());
}
if let Some(var_311) = &input.average_upload_rate_limit_in_bits_per_sec {
object.key("AverageUploadRateLimitInBitsPerSec").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_311).into()),
);
}
if let Some(var_312) = &input.average_download_rate_limit_in_bits_per_sec {
object.key("AverageDownloadRateLimitInBitsPerSec").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_312).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_update_bandwidth_rate_limit_schedule_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateBandwidthRateLimitScheduleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_313) = &input.gateway_arn {
object.key("GatewayARN").string(var_313.as_str());
}
if let Some(var_314) = &input.bandwidth_rate_limit_intervals {
let mut array_315 = object.key("BandwidthRateLimitIntervals").start_array();
for item_316 in var_314 {
{
#[allow(unused_mut)]
let mut object_317 = array_315.value().start_object();
crate::json_ser::serialize_structure_crate_model_bandwidth_rate_limit_interval(
&mut object_317,
item_316,
)?;
object_317.finish();
}
}
array_315.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_chap_credentials_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateChapCredentialsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_318) = &input.target_arn {
object.key("TargetARN").string(var_318.as_str());
}
if let Some(var_319) = &input.secret_to_authenticate_initiator {
object
.key("SecretToAuthenticateInitiator")
.string(var_319.as_str());
}
if let Some(var_320) = &input.initiator_name {
object.key("InitiatorName").string(var_320.as_str());
}
if let Some(var_321) = &input.secret_to_authenticate_target {
object
.key("SecretToAuthenticateTarget")
.string(var_321.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_file_system_association_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateFileSystemAssociationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_322) = &input.file_system_association_arn {
object
.key("FileSystemAssociationARN")
.string(var_322.as_str());
}
if let Some(var_323) = &input.user_name {
object.key("UserName").string(var_323.as_str());
}
if let Some(var_324) = &input.password {
object.key("Password").string(var_324.as_str());
}
if let Some(var_325) = &input.audit_destination_arn {
object.key("AuditDestinationARN").string(var_325.as_str());
}
if let Some(var_326) = &input.cache_attributes {
#[allow(unused_mut)]
let mut object_327 = object.key("CacheAttributes").start_object();
crate::json_ser::serialize_structure_crate_model_cache_attributes(
&mut object_327,
var_326,
)?;
object_327.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_gateway_information_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateGatewayInformationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_328) = &input.gateway_arn {
object.key("GatewayARN").string(var_328.as_str());
}
if let Some(var_329) = &input.gateway_name {
object.key("GatewayName").string(var_329.as_str());
}
if let Some(var_330) = &input.gateway_timezone {
object.key("GatewayTimezone").string(var_330.as_str());
}
if let Some(var_331) = &input.cloud_watch_log_group_arn {
object.key("CloudWatchLogGroupARN").string(var_331.as_str());
}
if let Some(var_332) = &input.gateway_capacity {
object.key("GatewayCapacity").string(var_332.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_gateway_software_now_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateGatewaySoftwareNowInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_333) = &input.gateway_arn {
object.key("GatewayARN").string(var_333.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_maintenance_start_time_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateMaintenanceStartTimeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_334) = &input.gateway_arn {
object.key("GatewayARN").string(var_334.as_str());
}
if let Some(var_335) = &input.hour_of_day {
object.key("HourOfDay").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_335).into()),
);
}
if let Some(var_336) = &input.minute_of_hour {
object.key("MinuteOfHour").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_336).into()),
);
}
if let Some(var_337) = &input.day_of_week {
object.key("DayOfWeek").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_337).into()),
);
}
if let Some(var_338) = &input.day_of_month {
object.key("DayOfMonth").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_338).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_update_nfs_file_share_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateNfsFileShareInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_339) = &input.file_share_arn {
object.key("FileShareARN").string(var_339.as_str());
}
if let Some(var_340) = &input.kms_encrypted {
object.key("KMSEncrypted").boolean(*var_340);
}
if let Some(var_341) = &input.kms_key {
object.key("KMSKey").string(var_341.as_str());
}
if let Some(var_342) = &input.nfs_file_share_defaults {
#[allow(unused_mut)]
let mut object_343 = object.key("NFSFileShareDefaults").start_object();
crate::json_ser::serialize_structure_crate_model_nfs_file_share_defaults(
&mut object_343,
var_342,
)?;
object_343.finish();
}
if let Some(var_344) = &input.default_storage_class {
object.key("DefaultStorageClass").string(var_344.as_str());
}
if let Some(var_345) = &input.object_acl {
object.key("ObjectACL").string(var_345.as_str());
}
if let Some(var_346) = &input.client_list {
let mut array_347 = object.key("ClientList").start_array();
for item_348 in var_346 {
{
array_347.value().string(item_348.as_str());
}
}
array_347.finish();
}
if let Some(var_349) = &input.squash {
object.key("Squash").string(var_349.as_str());
}
if let Some(var_350) = &input.read_only {
object.key("ReadOnly").boolean(*var_350);
}
if let Some(var_351) = &input.guess_mime_type_enabled {
object.key("GuessMIMETypeEnabled").boolean(*var_351);
}
if let Some(var_352) = &input.requester_pays {
object.key("RequesterPays").boolean(*var_352);
}
if let Some(var_353) = &input.file_share_name {
object.key("FileShareName").string(var_353.as_str());
}
if let Some(var_354) = &input.cache_attributes {
#[allow(unused_mut)]
let mut object_355 = object.key("CacheAttributes").start_object();
crate::json_ser::serialize_structure_crate_model_cache_attributes(
&mut object_355,
var_354,
)?;
object_355.finish();
}
if let Some(var_356) = &input.notification_policy {
object.key("NotificationPolicy").string(var_356.as_str());
}
if let Some(var_357) = &input.audit_destination_arn {
object.key("AuditDestinationARN").string(var_357.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_smb_file_share_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateSmbFileShareInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_358) = &input.file_share_arn {
object.key("FileShareARN").string(var_358.as_str());
}
if let Some(var_359) = &input.kms_encrypted {
object.key("KMSEncrypted").boolean(*var_359);
}
if let Some(var_360) = &input.kms_key {
object.key("KMSKey").string(var_360.as_str());
}
if let Some(var_361) = &input.default_storage_class {
object.key("DefaultStorageClass").string(var_361.as_str());
}
if let Some(var_362) = &input.object_acl {
object.key("ObjectACL").string(var_362.as_str());
}
if let Some(var_363) = &input.read_only {
object.key("ReadOnly").boolean(*var_363);
}
if let Some(var_364) = &input.guess_mime_type_enabled {
object.key("GuessMIMETypeEnabled").boolean(*var_364);
}
if let Some(var_365) = &input.requester_pays {
object.key("RequesterPays").boolean(*var_365);
}
if let Some(var_366) = &input.smbacl_enabled {
object.key("SMBACLEnabled").boolean(*var_366);
}
if let Some(var_367) = &input.access_based_enumeration {
object.key("AccessBasedEnumeration").boolean(*var_367);
}
if let Some(var_368) = &input.admin_user_list {
let mut array_369 = object.key("AdminUserList").start_array();
for item_370 in var_368 {
{
array_369.value().string(item_370.as_str());
}
}
array_369.finish();
}
if let Some(var_371) = &input.valid_user_list {
let mut array_372 = object.key("ValidUserList").start_array();
for item_373 in var_371 {
{
array_372.value().string(item_373.as_str());
}
}
array_372.finish();
}
if let Some(var_374) = &input.invalid_user_list {
let mut array_375 = object.key("InvalidUserList").start_array();
for item_376 in var_374 {
{
array_375.value().string(item_376.as_str());
}
}
array_375.finish();
}
if let Some(var_377) = &input.audit_destination_arn {
object.key("AuditDestinationARN").string(var_377.as_str());
}
if let Some(var_378) = &input.case_sensitivity {
object.key("CaseSensitivity").string(var_378.as_str());
}
if let Some(var_379) = &input.file_share_name {
object.key("FileShareName").string(var_379.as_str());
}
if let Some(var_380) = &input.cache_attributes {
#[allow(unused_mut)]
let mut object_381 = object.key("CacheAttributes").start_object();
crate::json_ser::serialize_structure_crate_model_cache_attributes(
&mut object_381,
var_380,
)?;
object_381.finish();
}
if let Some(var_382) = &input.notification_policy {
object.key("NotificationPolicy").string(var_382.as_str());
}
if let Some(var_383) = &input.oplocks_enabled {
object.key("OplocksEnabled").boolean(*var_383);
}
Ok(())
}
pub fn serialize_structure_crate_input_update_smb_file_share_visibility_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateSmbFileShareVisibilityInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_384) = &input.gateway_arn {
object.key("GatewayARN").string(var_384.as_str());
}
if let Some(var_385) = &input.file_shares_visible {
object.key("FileSharesVisible").boolean(*var_385);
}
Ok(())
}
pub fn serialize_structure_crate_input_update_smb_local_groups_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateSmbLocalGroupsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_386) = &input.gateway_arn {
object.key("GatewayARN").string(var_386.as_str());
}
if let Some(var_387) = &input.smb_local_groups {
#[allow(unused_mut)]
let mut object_388 = object.key("SMBLocalGroups").start_object();
crate::json_ser::serialize_structure_crate_model_smb_local_groups(
&mut object_388,
var_387,
)?;
object_388.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_smb_security_strategy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateSmbSecurityStrategyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_389) = &input.gateway_arn {
object.key("GatewayARN").string(var_389.as_str());
}
if let Some(var_390) = &input.smb_security_strategy {
object.key("SMBSecurityStrategy").string(var_390.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_snapshot_schedule_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateSnapshotScheduleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_391) = &input.volume_arn {
object.key("VolumeARN").string(var_391.as_str());
}
if let Some(var_392) = &input.start_at {
object.key("StartAt").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_392).into()),
);
}
if let Some(var_393) = &input.recurrence_in_hours {
object.key("RecurrenceInHours").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_393).into()),
);
}
if let Some(var_394) = &input.description {
object.key("Description").string(var_394.as_str());
}
if let Some(var_395) = &input.tags {
let mut array_396 = object.key("Tags").start_array();
for item_397 in var_395 {
{
#[allow(unused_mut)]
let mut object_398 = array_396.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_398, item_397)?;
object_398.finish();
}
}
array_396.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_vtl_device_type_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateVtlDeviceTypeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_399) = &input.vtl_device_arn {
object.key("VTLDeviceARN").string(var_399.as_str());
}
if let Some(var_400) = &input.device_type {
object.key("DeviceType").string(var_400.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_tag(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Tag,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_401) = &input.key {
object.key("Key").string(var_401.as_str());
}
if let Some(var_402) = &input.value {
object.key("Value").string(var_402.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_cache_attributes(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CacheAttributes,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_403) = &input.cache_stale_timeout_in_seconds {
object.key("CacheStaleTimeoutInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_403).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_endpoint_network_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EndpointNetworkConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_404) = &input.ip_addresses {
let mut array_405 = object.key("IpAddresses").start_array();
for item_406 in var_404 {
{
array_405.value().string(item_406.as_str());
}
}
array_405.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_nfs_file_share_defaults(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::NfsFileShareDefaults,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_407) = &input.file_mode {
object.key("FileMode").string(var_407.as_str());
}
if let Some(var_408) = &input.directory_mode {
object.key("DirectoryMode").string(var_408.as_str());
}
if let Some(var_409) = &input.group_id {
object.key("GroupId").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_409).into()),
);
}
if let Some(var_410) = &input.owner_id {
object.key("OwnerId").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_410).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_automatic_tape_creation_rule(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AutomaticTapeCreationRule,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_411) = &input.tape_barcode_prefix {
object.key("TapeBarcodePrefix").string(var_411.as_str());
}
if let Some(var_412) = &input.pool_id {
object.key("PoolId").string(var_412.as_str());
}
if let Some(var_413) = &input.tape_size_in_bytes {
object.key("TapeSizeInBytes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_413).into()),
);
}
if let Some(var_414) = &input.minimum_num_tapes {
object.key("MinimumNumTapes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_414).into()),
);
}
if input.worm {
object.key("Worm").boolean(input.worm);
}
Ok(())
}
pub fn serialize_structure_crate_model_bandwidth_rate_limit_interval(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BandwidthRateLimitInterval,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_415) = &input.start_hour_of_day {
object.key("StartHourOfDay").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_415).into()),
);
}
if let Some(var_416) = &input.start_minute_of_hour {
object.key("StartMinuteOfHour").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_416).into()),
);
}
if let Some(var_417) = &input.end_hour_of_day {
object.key("EndHourOfDay").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_417).into()),
);
}
if let Some(var_418) = &input.end_minute_of_hour {
object.key("EndMinuteOfHour").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_418).into()),
);
}
if let Some(var_419) = &input.days_of_week {
let mut array_420 = object.key("DaysOfWeek").start_array();
for item_421 in var_419 {
{
array_420.value().number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*item_421).into()),
);
}
}
array_420.finish();
}
if let Some(var_422) = &input.average_upload_rate_limit_in_bits_per_sec {
object.key("AverageUploadRateLimitInBitsPerSec").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_422).into()),
);
}
if let Some(var_423) = &input.average_download_rate_limit_in_bits_per_sec {
object.key("AverageDownloadRateLimitInBitsPerSec").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_423).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_smb_local_groups(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SmbLocalGroups,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_424) = &input.gateway_admins {
let mut array_425 = object.key("GatewayAdmins").start_array();
for item_426 in var_424 {
{
array_425.value().string(item_426.as_str());
}
}
array_425.finish();
}
Ok(())
}