pub fn serialize_structure_crate_input_associate_file_system_aliases_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociateFileSystemAliasesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.client_request_token {
object.key("ClientRequestToken").string(var_1.as_str());
}
if let Some(var_2) = &input.file_system_id {
object.key("FileSystemId").string(var_2.as_str());
}
if let Some(var_3) = &input.aliases {
let mut array_4 = object.key("Aliases").start_array();
for item_5 in var_3 {
{
array_4.value().string(item_5.as_str());
}
}
array_4.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_cancel_data_repository_task_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CancelDataRepositoryTaskInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_6) = &input.task_id {
object.key("TaskId").string(var_6.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_copy_backup_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CopyBackupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_7) = &input.client_request_token {
object.key("ClientRequestToken").string(var_7.as_str());
}
if let Some(var_8) = &input.source_backup_id {
object.key("SourceBackupId").string(var_8.as_str());
}
if let Some(var_9) = &input.source_region {
object.key("SourceRegion").string(var_9.as_str());
}
if let Some(var_10) = &input.kms_key_id {
object.key("KmsKeyId").string(var_10.as_str());
}
if let Some(var_11) = &input.copy_tags {
object.key("CopyTags").boolean(*var_11);
}
if let Some(var_12) = &input.tags {
let mut array_13 = object.key("Tags").start_array();
for item_14 in var_12 {
{
#[allow(unused_mut)]
let mut object_15 = array_13.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_15, item_14)?;
object_15.finish();
}
}
array_13.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_backup_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateBackupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_16) = &input.file_system_id {
object.key("FileSystemId").string(var_16.as_str());
}
if let Some(var_17) = &input.client_request_token {
object.key("ClientRequestToken").string(var_17.as_str());
}
if let Some(var_18) = &input.tags {
let mut array_19 = object.key("Tags").start_array();
for item_20 in var_18 {
{
#[allow(unused_mut)]
let mut object_21 = array_19.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_21, item_20)?;
object_21.finish();
}
}
array_19.finish();
}
if let Some(var_22) = &input.volume_id {
object.key("VolumeId").string(var_22.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_data_repository_association_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateDataRepositoryAssociationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_23) = &input.file_system_id {
object.key("FileSystemId").string(var_23.as_str());
}
if let Some(var_24) = &input.file_system_path {
object.key("FileSystemPath").string(var_24.as_str());
}
if let Some(var_25) = &input.data_repository_path {
object.key("DataRepositoryPath").string(var_25.as_str());
}
if let Some(var_26) = &input.batch_import_meta_data_on_create {
object.key("BatchImportMetaDataOnCreate").boolean(*var_26);
}
if let Some(var_27) = &input.imported_file_chunk_size {
object.key("ImportedFileChunkSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_27).into()),
);
}
if let Some(var_28) = &input.s3 {
#[allow(unused_mut)]
let mut object_29 = object.key("S3").start_object();
crate::json_ser::serialize_structure_crate_model_s3_data_repository_configuration(
&mut object_29,
var_28,
)?;
object_29.finish();
}
if let Some(var_30) = &input.client_request_token {
object.key("ClientRequestToken").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(&mut object_34, item_33)?;
object_34.finish();
}
}
array_32.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_data_repository_task_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateDataRepositoryTaskInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_35) = &input.r#type {
object.key("Type").string(var_35.as_str());
}
if let Some(var_36) = &input.paths {
let mut array_37 = object.key("Paths").start_array();
for item_38 in var_36 {
{
array_37.value().string(item_38.as_str());
}
}
array_37.finish();
}
if let Some(var_39) = &input.file_system_id {
object.key("FileSystemId").string(var_39.as_str());
}
if let Some(var_40) = &input.report {
#[allow(unused_mut)]
let mut object_41 = object.key("Report").start_object();
crate::json_ser::serialize_structure_crate_model_completion_report(&mut object_41, var_40)?;
object_41.finish();
}
if let Some(var_42) = &input.client_request_token {
object.key("ClientRequestToken").string(var_42.as_str());
}
if let Some(var_43) = &input.tags {
let mut array_44 = object.key("Tags").start_array();
for item_45 in var_43 {
{
#[allow(unused_mut)]
let mut object_46 = array_44.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_46, item_45)?;
object_46.finish();
}
}
array_44.finish();
}
if let Some(var_47) = &input.capacity_to_release {
object.key("CapacityToRelease").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_47).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_create_file_cache_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateFileCacheInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_48) = &input.client_request_token {
object.key("ClientRequestToken").string(var_48.as_str());
}
if let Some(var_49) = &input.file_cache_type {
object.key("FileCacheType").string(var_49.as_str());
}
if let Some(var_50) = &input.file_cache_type_version {
object.key("FileCacheTypeVersion").string(var_50.as_str());
}
if let Some(var_51) = &input.storage_capacity {
object.key("StorageCapacity").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_51).into()),
);
}
if let Some(var_52) = &input.subnet_ids {
let mut array_53 = object.key("SubnetIds").start_array();
for item_54 in var_52 {
{
array_53.value().string(item_54.as_str());
}
}
array_53.finish();
}
if let Some(var_55) = &input.security_group_ids {
let mut array_56 = object.key("SecurityGroupIds").start_array();
for item_57 in var_55 {
{
array_56.value().string(item_57.as_str());
}
}
array_56.finish();
}
if let Some(var_58) = &input.tags {
let mut array_59 = object.key("Tags").start_array();
for item_60 in var_58 {
{
#[allow(unused_mut)]
let mut object_61 = array_59.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_61, item_60)?;
object_61.finish();
}
}
array_59.finish();
}
if let Some(var_62) = &input.copy_tags_to_data_repository_associations {
object
.key("CopyTagsToDataRepositoryAssociations")
.boolean(*var_62);
}
if let Some(var_63) = &input.kms_key_id {
object.key("KmsKeyId").string(var_63.as_str());
}
if let Some(var_64) = &input.lustre_configuration {
#[allow(unused_mut)]
let mut object_65 = object.key("LustreConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_create_file_cache_lustre_configuration(
&mut object_65,
var_64,
)?;
object_65.finish();
}
if let Some(var_66) = &input.data_repository_associations {
let mut array_67 = object.key("DataRepositoryAssociations").start_array();
for item_68 in var_66 {
{
#[allow(unused_mut)]
let mut object_69 = array_67.value().start_object();
crate::json_ser::serialize_structure_crate_model_file_cache_data_repository_association(&mut object_69, item_68)?;
object_69.finish();
}
}
array_67.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_file_system_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateFileSystemInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_70) = &input.client_request_token {
object.key("ClientRequestToken").string(var_70.as_str());
}
if let Some(var_71) = &input.file_system_type {
object.key("FileSystemType").string(var_71.as_str());
}
if let Some(var_72) = &input.storage_capacity {
object.key("StorageCapacity").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_72).into()),
);
}
if let Some(var_73) = &input.storage_type {
object.key("StorageType").string(var_73.as_str());
}
if let Some(var_74) = &input.subnet_ids {
let mut array_75 = object.key("SubnetIds").start_array();
for item_76 in var_74 {
{
array_75.value().string(item_76.as_str());
}
}
array_75.finish();
}
if let Some(var_77) = &input.security_group_ids {
let mut array_78 = object.key("SecurityGroupIds").start_array();
for item_79 in var_77 {
{
array_78.value().string(item_79.as_str());
}
}
array_78.finish();
}
if let Some(var_80) = &input.tags {
let mut array_81 = object.key("Tags").start_array();
for item_82 in var_80 {
{
#[allow(unused_mut)]
let mut object_83 = array_81.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_83, item_82)?;
object_83.finish();
}
}
array_81.finish();
}
if let Some(var_84) = &input.kms_key_id {
object.key("KmsKeyId").string(var_84.as_str());
}
if let Some(var_85) = &input.windows_configuration {
#[allow(unused_mut)]
let mut object_86 = object.key("WindowsConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_create_file_system_windows_configuration(
&mut object_86,
var_85,
)?;
object_86.finish();
}
if let Some(var_87) = &input.lustre_configuration {
#[allow(unused_mut)]
let mut object_88 = object.key("LustreConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_create_file_system_lustre_configuration(
&mut object_88,
var_87,
)?;
object_88.finish();
}
if let Some(var_89) = &input.ontap_configuration {
#[allow(unused_mut)]
let mut object_90 = object.key("OntapConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_create_file_system_ontap_configuration(
&mut object_90,
var_89,
)?;
object_90.finish();
}
if let Some(var_91) = &input.file_system_type_version {
object.key("FileSystemTypeVersion").string(var_91.as_str());
}
if let Some(var_92) = &input.open_zfs_configuration {
#[allow(unused_mut)]
let mut object_93 = object.key("OpenZFSConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_create_file_system_open_zfs_configuration(
&mut object_93,
var_92,
)?;
object_93.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_file_system_from_backup_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateFileSystemFromBackupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_94) = &input.backup_id {
object.key("BackupId").string(var_94.as_str());
}
if let Some(var_95) = &input.client_request_token {
object.key("ClientRequestToken").string(var_95.as_str());
}
if let Some(var_96) = &input.subnet_ids {
let mut array_97 = object.key("SubnetIds").start_array();
for item_98 in var_96 {
{
array_97.value().string(item_98.as_str());
}
}
array_97.finish();
}
if let Some(var_99) = &input.security_group_ids {
let mut array_100 = object.key("SecurityGroupIds").start_array();
for item_101 in var_99 {
{
array_100.value().string(item_101.as_str());
}
}
array_100.finish();
}
if let Some(var_102) = &input.tags {
let mut array_103 = object.key("Tags").start_array();
for item_104 in var_102 {
{
#[allow(unused_mut)]
let mut object_105 = array_103.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_105, item_104)?;
object_105.finish();
}
}
array_103.finish();
}
if let Some(var_106) = &input.windows_configuration {
#[allow(unused_mut)]
let mut object_107 = object.key("WindowsConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_create_file_system_windows_configuration(
&mut object_107,
var_106,
)?;
object_107.finish();
}
if let Some(var_108) = &input.lustre_configuration {
#[allow(unused_mut)]
let mut object_109 = object.key("LustreConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_create_file_system_lustre_configuration(
&mut object_109,
var_108,
)?;
object_109.finish();
}
if let Some(var_110) = &input.storage_type {
object.key("StorageType").string(var_110.as_str());
}
if let Some(var_111) = &input.kms_key_id {
object.key("KmsKeyId").string(var_111.as_str());
}
if let Some(var_112) = &input.file_system_type_version {
object.key("FileSystemTypeVersion").string(var_112.as_str());
}
if let Some(var_113) = &input.open_zfs_configuration {
#[allow(unused_mut)]
let mut object_114 = object.key("OpenZFSConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_create_file_system_open_zfs_configuration(
&mut object_114,
var_113,
)?;
object_114.finish();
}
if let Some(var_115) = &input.storage_capacity {
object.key("StorageCapacity").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_115).into()),
);
}
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_116) = &input.client_request_token {
object.key("ClientRequestToken").string(var_116.as_str());
}
if let Some(var_117) = &input.name {
object.key("Name").string(var_117.as_str());
}
if let Some(var_118) = &input.volume_id {
object.key("VolumeId").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();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_storage_virtual_machine_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateStorageVirtualMachineInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_123) = &input.active_directory_configuration {
#[allow(unused_mut)]
let mut object_124 = object.key("ActiveDirectoryConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_create_svm_active_directory_configuration(
&mut object_124,
var_123,
)?;
object_124.finish();
}
if let Some(var_125) = &input.client_request_token {
object.key("ClientRequestToken").string(var_125.as_str());
}
if let Some(var_126) = &input.file_system_id {
object.key("FileSystemId").string(var_126.as_str());
}
if let Some(var_127) = &input.name {
object.key("Name").string(var_127.as_str());
}
if let Some(var_128) = &input.svm_admin_password {
object.key("SvmAdminPassword").string(var_128.as_str());
}
if let Some(var_129) = &input.tags {
let mut array_130 = object.key("Tags").start_array();
for item_131 in var_129 {
{
#[allow(unused_mut)]
let mut object_132 = array_130.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_132, item_131)?;
object_132.finish();
}
}
array_130.finish();
}
if let Some(var_133) = &input.root_volume_security_style {
object
.key("RootVolumeSecurityStyle")
.string(var_133.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_volume_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateVolumeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_134) = &input.client_request_token {
object.key("ClientRequestToken").string(var_134.as_str());
}
if let Some(var_135) = &input.volume_type {
object.key("VolumeType").string(var_135.as_str());
}
if let Some(var_136) = &input.name {
object.key("Name").string(var_136.as_str());
}
if let Some(var_137) = &input.ontap_configuration {
#[allow(unused_mut)]
let mut object_138 = object.key("OntapConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_create_ontap_volume_configuration(
&mut object_138,
var_137,
)?;
object_138.finish();
}
if let Some(var_139) = &input.tags {
let mut array_140 = object.key("Tags").start_array();
for item_141 in var_139 {
{
#[allow(unused_mut)]
let mut object_142 = array_140.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_142, item_141)?;
object_142.finish();
}
}
array_140.finish();
}
if let Some(var_143) = &input.open_zfs_configuration {
#[allow(unused_mut)]
let mut object_144 = object.key("OpenZFSConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_create_open_zfs_volume_configuration(
&mut object_144,
var_143,
)?;
object_144.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_volume_from_backup_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateVolumeFromBackupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_145) = &input.backup_id {
object.key("BackupId").string(var_145.as_str());
}
if let Some(var_146) = &input.client_request_token {
object.key("ClientRequestToken").string(var_146.as_str());
}
if let Some(var_147) = &input.name {
object.key("Name").string(var_147.as_str());
}
if let Some(var_148) = &input.ontap_configuration {
#[allow(unused_mut)]
let mut object_149 = object.key("OntapConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_create_ontap_volume_configuration(
&mut object_149,
var_148,
)?;
object_149.finish();
}
if let Some(var_150) = &input.tags {
let mut array_151 = object.key("Tags").start_array();
for item_152 in var_150 {
{
#[allow(unused_mut)]
let mut object_153 = array_151.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_153, item_152)?;
object_153.finish();
}
}
array_151.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_backup_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteBackupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_154) = &input.backup_id {
object.key("BackupId").string(var_154.as_str());
}
if let Some(var_155) = &input.client_request_token {
object.key("ClientRequestToken").string(var_155.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_data_repository_association_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteDataRepositoryAssociationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_156) = &input.association_id {
object.key("AssociationId").string(var_156.as_str());
}
if let Some(var_157) = &input.client_request_token {
object.key("ClientRequestToken").string(var_157.as_str());
}
if let Some(var_158) = &input.delete_data_in_file_system {
object.key("DeleteDataInFileSystem").boolean(*var_158);
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_file_cache_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteFileCacheInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_159) = &input.file_cache_id {
object.key("FileCacheId").string(var_159.as_str());
}
if let Some(var_160) = &input.client_request_token {
object.key("ClientRequestToken").string(var_160.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_file_system_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteFileSystemInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_161) = &input.file_system_id {
object.key("FileSystemId").string(var_161.as_str());
}
if let Some(var_162) = &input.client_request_token {
object.key("ClientRequestToken").string(var_162.as_str());
}
if let Some(var_163) = &input.windows_configuration {
#[allow(unused_mut)]
let mut object_164 = object.key("WindowsConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_delete_file_system_windows_configuration(
&mut object_164,
var_163,
)?;
object_164.finish();
}
if let Some(var_165) = &input.lustre_configuration {
#[allow(unused_mut)]
let mut object_166 = object.key("LustreConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_delete_file_system_lustre_configuration(
&mut object_166,
var_165,
)?;
object_166.finish();
}
if let Some(var_167) = &input.open_zfs_configuration {
#[allow(unused_mut)]
let mut object_168 = object.key("OpenZFSConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_delete_file_system_open_zfs_configuration(
&mut object_168,
var_167,
)?;
object_168.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_snapshot_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteSnapshotInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_169) = &input.client_request_token {
object.key("ClientRequestToken").string(var_169.as_str());
}
if let Some(var_170) = &input.snapshot_id {
object.key("SnapshotId").string(var_170.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_storage_virtual_machine_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteStorageVirtualMachineInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_171) = &input.client_request_token {
object.key("ClientRequestToken").string(var_171.as_str());
}
if let Some(var_172) = &input.storage_virtual_machine_id {
object
.key("StorageVirtualMachineId")
.string(var_172.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_173) = &input.client_request_token {
object.key("ClientRequestToken").string(var_173.as_str());
}
if let Some(var_174) = &input.volume_id {
object.key("VolumeId").string(var_174.as_str());
}
if let Some(var_175) = &input.ontap_configuration {
#[allow(unused_mut)]
let mut object_176 = object.key("OntapConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_delete_volume_ontap_configuration(
&mut object_176,
var_175,
)?;
object_176.finish();
}
if let Some(var_177) = &input.open_zfs_configuration {
#[allow(unused_mut)]
let mut object_178 = object.key("OpenZFSConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_delete_volume_open_zfs_configuration(
&mut object_178,
var_177,
)?;
object_178.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_backups_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeBackupsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_179) = &input.backup_ids {
let mut array_180 = object.key("BackupIds").start_array();
for item_181 in var_179 {
{
array_180.value().string(item_181.as_str());
}
}
array_180.finish();
}
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_filter(&mut object_185, item_184)?;
object_185.finish();
}
}
array_183.finish();
}
if let Some(var_186) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_186).into()),
);
}
if let Some(var_187) = &input.next_token {
object.key("NextToken").string(var_187.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_data_repository_associations_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeDataRepositoryAssociationsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_188) = &input.association_ids {
let mut array_189 = object.key("AssociationIds").start_array();
for item_190 in var_188 {
{
array_189.value().string(item_190.as_str());
}
}
array_189.finish();
}
if let Some(var_191) = &input.filters {
let mut array_192 = object.key("Filters").start_array();
for item_193 in var_191 {
{
#[allow(unused_mut)]
let mut object_194 = array_192.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_194, item_193)?;
object_194.finish();
}
}
array_192.finish();
}
if let Some(var_195) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_195).into()),
);
}
if let Some(var_196) = &input.next_token {
object.key("NextToken").string(var_196.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_data_repository_tasks_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeDataRepositoryTasksInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_197) = &input.task_ids {
let mut array_198 = object.key("TaskIds").start_array();
for item_199 in var_197 {
{
array_198.value().string(item_199.as_str());
}
}
array_198.finish();
}
if let Some(var_200) = &input.filters {
let mut array_201 = object.key("Filters").start_array();
for item_202 in var_200 {
{
#[allow(unused_mut)]
let mut object_203 = array_201.value().start_object();
crate::json_ser::serialize_structure_crate_model_data_repository_task_filter(
&mut object_203,
item_202,
)?;
object_203.finish();
}
}
array_201.finish();
}
if let Some(var_204) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_204).into()),
);
}
if let Some(var_205) = &input.next_token {
object.key("NextToken").string(var_205.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_file_caches_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeFileCachesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_206) = &input.file_cache_ids {
let mut array_207 = object.key("FileCacheIds").start_array();
for item_208 in var_206 {
{
array_207.value().string(item_208.as_str());
}
}
array_207.finish();
}
if let Some(var_209) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_209).into()),
);
}
if let Some(var_210) = &input.next_token {
object.key("NextToken").string(var_210.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_file_system_aliases_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeFileSystemAliasesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_211) = &input.client_request_token {
object.key("ClientRequestToken").string(var_211.as_str());
}
if let Some(var_212) = &input.file_system_id {
object.key("FileSystemId").string(var_212.as_str());
}
if let Some(var_213) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_213).into()),
);
}
if let Some(var_214) = &input.next_token {
object.key("NextToken").string(var_214.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_file_systems_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeFileSystemsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_215) = &input.file_system_ids {
let mut array_216 = object.key("FileSystemIds").start_array();
for item_217 in var_215 {
{
array_216.value().string(item_217.as_str());
}
}
array_216.finish();
}
if let Some(var_218) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_218).into()),
);
}
if let Some(var_219) = &input.next_token {
object.key("NextToken").string(var_219.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_snapshots_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeSnapshotsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_220) = &input.snapshot_ids {
let mut array_221 = object.key("SnapshotIds").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.filters {
let mut array_224 = object.key("Filters").start_array();
for item_225 in var_223 {
{
#[allow(unused_mut)]
let mut object_226 = array_224.value().start_object();
crate::json_ser::serialize_structure_crate_model_snapshot_filter(
&mut object_226,
item_225,
)?;
object_226.finish();
}
}
array_224.finish();
}
if let Some(var_227) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_227).into()),
);
}
if let Some(var_228) = &input.next_token {
object.key("NextToken").string(var_228.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_storage_virtual_machines_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeStorageVirtualMachinesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_229) = &input.storage_virtual_machine_ids {
let mut array_230 = object.key("StorageVirtualMachineIds").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.filters {
let mut array_233 = object.key("Filters").start_array();
for item_234 in var_232 {
{
#[allow(unused_mut)]
let mut object_235 = array_233.value().start_object();
crate::json_ser::serialize_structure_crate_model_storage_virtual_machine_filter(
&mut object_235,
item_234,
)?;
object_235.finish();
}
}
array_233.finish();
}
if let Some(var_236) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_236).into()),
);
}
if let Some(var_237) = &input.next_token {
object.key("NextToken").string(var_237.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_volumes_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeVolumesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_238) = &input.volume_ids {
let mut array_239 = object.key("VolumeIds").start_array();
for item_240 in var_238 {
{
array_239.value().string(item_240.as_str());
}
}
array_239.finish();
}
if let Some(var_241) = &input.filters {
let mut array_242 = object.key("Filters").start_array();
for item_243 in var_241 {
{
#[allow(unused_mut)]
let mut object_244 = array_242.value().start_object();
crate::json_ser::serialize_structure_crate_model_volume_filter(
&mut object_244,
item_243,
)?;
object_244.finish();
}
}
array_242.finish();
}
if let Some(var_245) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_245).into()),
);
}
if let Some(var_246) = &input.next_token {
object.key("NextToken").string(var_246.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_disassociate_file_system_aliases_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DisassociateFileSystemAliasesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_247) = &input.client_request_token {
object.key("ClientRequestToken").string(var_247.as_str());
}
if let Some(var_248) = &input.file_system_id {
object.key("FileSystemId").string(var_248.as_str());
}
if let Some(var_249) = &input.aliases {
let mut array_250 = object.key("Aliases").start_array();
for item_251 in var_249 {
{
array_250.value().string(item_251.as_str());
}
}
array_250.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_252) = &input.resource_arn {
object.key("ResourceARN").string(var_252.as_str());
}
if let Some(var_253) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_253).into()),
);
}
if let Some(var_254) = &input.next_token {
object.key("NextToken").string(var_254.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_release_file_system_nfs_v3_locks_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ReleaseFileSystemNfsV3LocksInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_255) = &input.file_system_id {
object.key("FileSystemId").string(var_255.as_str());
}
if let Some(var_256) = &input.client_request_token {
object.key("ClientRequestToken").string(var_256.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_restore_volume_from_snapshot_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RestoreVolumeFromSnapshotInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_257) = &input.client_request_token {
object.key("ClientRequestToken").string(var_257.as_str());
}
if let Some(var_258) = &input.volume_id {
object.key("VolumeId").string(var_258.as_str());
}
if let Some(var_259) = &input.snapshot_id {
object.key("SnapshotId").string(var_259.as_str());
}
if let Some(var_260) = &input.options {
let mut array_261 = object.key("Options").start_array();
for item_262 in var_260 {
{
array_261.value().string(item_262.as_str());
}
}
array_261.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_263) = &input.resource_arn {
object.key("ResourceARN").string(var_263.as_str());
}
if let Some(var_264) = &input.tags {
let mut array_265 = object.key("Tags").start_array();
for item_266 in var_264 {
{
#[allow(unused_mut)]
let mut object_267 = array_265.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_267, item_266)?;
object_267.finish();
}
}
array_265.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_268) = &input.resource_arn {
object.key("ResourceARN").string(var_268.as_str());
}
if let Some(var_269) = &input.tag_keys {
let mut array_270 = object.key("TagKeys").start_array();
for item_271 in var_269 {
{
array_270.value().string(item_271.as_str());
}
}
array_270.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_data_repository_association_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateDataRepositoryAssociationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_272) = &input.association_id {
object.key("AssociationId").string(var_272.as_str());
}
if let Some(var_273) = &input.client_request_token {
object.key("ClientRequestToken").string(var_273.as_str());
}
if let Some(var_274) = &input.imported_file_chunk_size {
object.key("ImportedFileChunkSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_274).into()),
);
}
if let Some(var_275) = &input.s3 {
#[allow(unused_mut)]
let mut object_276 = object.key("S3").start_object();
crate::json_ser::serialize_structure_crate_model_s3_data_repository_configuration(
&mut object_276,
var_275,
)?;
object_276.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_file_cache_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateFileCacheInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_277) = &input.file_cache_id {
object.key("FileCacheId").string(var_277.as_str());
}
if let Some(var_278) = &input.client_request_token {
object.key("ClientRequestToken").string(var_278.as_str());
}
if let Some(var_279) = &input.lustre_configuration {
#[allow(unused_mut)]
let mut object_280 = object.key("LustreConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_update_file_cache_lustre_configuration(
&mut object_280,
var_279,
)?;
object_280.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_file_system_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateFileSystemInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_281) = &input.file_system_id {
object.key("FileSystemId").string(var_281.as_str());
}
if let Some(var_282) = &input.client_request_token {
object.key("ClientRequestToken").string(var_282.as_str());
}
if let Some(var_283) = &input.storage_capacity {
object.key("StorageCapacity").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_283).into()),
);
}
if let Some(var_284) = &input.windows_configuration {
#[allow(unused_mut)]
let mut object_285 = object.key("WindowsConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_update_file_system_windows_configuration(
&mut object_285,
var_284,
)?;
object_285.finish();
}
if let Some(var_286) = &input.lustre_configuration {
#[allow(unused_mut)]
let mut object_287 = object.key("LustreConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_update_file_system_lustre_configuration(
&mut object_287,
var_286,
)?;
object_287.finish();
}
if let Some(var_288) = &input.ontap_configuration {
#[allow(unused_mut)]
let mut object_289 = object.key("OntapConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_update_file_system_ontap_configuration(
&mut object_289,
var_288,
)?;
object_289.finish();
}
if let Some(var_290) = &input.open_zfs_configuration {
#[allow(unused_mut)]
let mut object_291 = object.key("OpenZFSConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_update_file_system_open_zfs_configuration(
&mut object_291,
var_290,
)?;
object_291.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_snapshot_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateSnapshotInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_292) = &input.client_request_token {
object.key("ClientRequestToken").string(var_292.as_str());
}
if let Some(var_293) = &input.name {
object.key("Name").string(var_293.as_str());
}
if let Some(var_294) = &input.snapshot_id {
object.key("SnapshotId").string(var_294.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_storage_virtual_machine_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateStorageVirtualMachineInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_295) = &input.active_directory_configuration {
#[allow(unused_mut)]
let mut object_296 = object.key("ActiveDirectoryConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_update_svm_active_directory_configuration(
&mut object_296,
var_295,
)?;
object_296.finish();
}
if let Some(var_297) = &input.client_request_token {
object.key("ClientRequestToken").string(var_297.as_str());
}
if let Some(var_298) = &input.storage_virtual_machine_id {
object
.key("StorageVirtualMachineId")
.string(var_298.as_str());
}
if let Some(var_299) = &input.svm_admin_password {
object.key("SvmAdminPassword").string(var_299.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_volume_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateVolumeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_300) = &input.client_request_token {
object.key("ClientRequestToken").string(var_300.as_str());
}
if let Some(var_301) = &input.volume_id {
object.key("VolumeId").string(var_301.as_str());
}
if let Some(var_302) = &input.ontap_configuration {
#[allow(unused_mut)]
let mut object_303 = object.key("OntapConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_update_ontap_volume_configuration(
&mut object_303,
var_302,
)?;
object_303.finish();
}
if let Some(var_304) = &input.name {
object.key("Name").string(var_304.as_str());
}
if let Some(var_305) = &input.open_zfs_configuration {
#[allow(unused_mut)]
let mut object_306 = object.key("OpenZFSConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_update_open_zfs_volume_configuration(
&mut object_306,
var_305,
)?;
object_306.finish();
}
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_307) = &input.key {
object.key("Key").string(var_307.as_str());
}
if let Some(var_308) = &input.value {
object.key("Value").string(var_308.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_s3_data_repository_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::S3DataRepositoryConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_309) = &input.auto_import_policy {
#[allow(unused_mut)]
let mut object_310 = object.key("AutoImportPolicy").start_object();
crate::json_ser::serialize_structure_crate_model_auto_import_policy(
&mut object_310,
var_309,
)?;
object_310.finish();
}
if let Some(var_311) = &input.auto_export_policy {
#[allow(unused_mut)]
let mut object_312 = object.key("AutoExportPolicy").start_object();
crate::json_ser::serialize_structure_crate_model_auto_export_policy(
&mut object_312,
var_311,
)?;
object_312.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_completion_report(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CompletionReport,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_313) = &input.enabled {
object.key("Enabled").boolean(*var_313);
}
if let Some(var_314) = &input.path {
object.key("Path").string(var_314.as_str());
}
if let Some(var_315) = &input.format {
object.key("Format").string(var_315.as_str());
}
if let Some(var_316) = &input.scope {
object.key("Scope").string(var_316.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_create_file_cache_lustre_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CreateFileCacheLustreConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_317) = &input.per_unit_storage_throughput {
object.key("PerUnitStorageThroughput").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_317).into()),
);
}
if let Some(var_318) = &input.deployment_type {
object.key("DeploymentType").string(var_318.as_str());
}
if let Some(var_319) = &input.weekly_maintenance_start_time {
object
.key("WeeklyMaintenanceStartTime")
.string(var_319.as_str());
}
if let Some(var_320) = &input.metadata_configuration {
#[allow(unused_mut)]
let mut object_321 = object.key("MetadataConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_file_cache_lustre_metadata_configuration(
&mut object_321,
var_320,
)?;
object_321.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_file_cache_data_repository_association(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FileCacheDataRepositoryAssociation,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_322) = &input.file_cache_path {
object.key("FileCachePath").string(var_322.as_str());
}
if let Some(var_323) = &input.data_repository_path {
object.key("DataRepositoryPath").string(var_323.as_str());
}
if let Some(var_324) = &input.data_repository_subdirectories {
let mut array_325 = object.key("DataRepositorySubdirectories").start_array();
for item_326 in var_324 {
{
array_325.value().string(item_326.as_str());
}
}
array_325.finish();
}
if let Some(var_327) = &input.nfs {
#[allow(unused_mut)]
let mut object_328 = object.key("NFS").start_object();
crate::json_ser::serialize_structure_crate_model_file_cache_nfs_configuration(
&mut object_328,
var_327,
)?;
object_328.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_create_file_system_windows_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CreateFileSystemWindowsConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_329) = &input.active_directory_id {
object.key("ActiveDirectoryId").string(var_329.as_str());
}
if let Some(var_330) = &input.self_managed_active_directory_configuration {
#[allow(unused_mut)]
let mut object_331 = object
.key("SelfManagedActiveDirectoryConfiguration")
.start_object();
crate::json_ser::serialize_structure_crate_model_self_managed_active_directory_configuration(&mut object_331, var_330)?;
object_331.finish();
}
if let Some(var_332) = &input.deployment_type {
object.key("DeploymentType").string(var_332.as_str());
}
if let Some(var_333) = &input.preferred_subnet_id {
object.key("PreferredSubnetId").string(var_333.as_str());
}
if let Some(var_334) = &input.throughput_capacity {
object.key("ThroughputCapacity").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_334).into()),
);
}
if let Some(var_335) = &input.weekly_maintenance_start_time {
object
.key("WeeklyMaintenanceStartTime")
.string(var_335.as_str());
}
if let Some(var_336) = &input.daily_automatic_backup_start_time {
object
.key("DailyAutomaticBackupStartTime")
.string(var_336.as_str());
}
if let Some(var_337) = &input.automatic_backup_retention_days {
object.key("AutomaticBackupRetentionDays").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_337).into()),
);
}
if let Some(var_338) = &input.copy_tags_to_backups {
object.key("CopyTagsToBackups").boolean(*var_338);
}
if let Some(var_339) = &input.aliases {
let mut array_340 = object.key("Aliases").start_array();
for item_341 in var_339 {
{
array_340.value().string(item_341.as_str());
}
}
array_340.finish();
}
if let Some(var_342) = &input.audit_log_configuration {
#[allow(unused_mut)]
let mut object_343 = object.key("AuditLogConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_windows_audit_log_create_configuration(
&mut object_343,
var_342,
)?;
object_343.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_create_file_system_lustre_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CreateFileSystemLustreConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_344) = &input.weekly_maintenance_start_time {
object
.key("WeeklyMaintenanceStartTime")
.string(var_344.as_str());
}
if let Some(var_345) = &input.import_path {
object.key("ImportPath").string(var_345.as_str());
}
if let Some(var_346) = &input.export_path {
object.key("ExportPath").string(var_346.as_str());
}
if let Some(var_347) = &input.imported_file_chunk_size {
object.key("ImportedFileChunkSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_347).into()),
);
}
if let Some(var_348) = &input.deployment_type {
object.key("DeploymentType").string(var_348.as_str());
}
if let Some(var_349) = &input.auto_import_policy {
object.key("AutoImportPolicy").string(var_349.as_str());
}
if let Some(var_350) = &input.per_unit_storage_throughput {
object.key("PerUnitStorageThroughput").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_350).into()),
);
}
if let Some(var_351) = &input.daily_automatic_backup_start_time {
object
.key("DailyAutomaticBackupStartTime")
.string(var_351.as_str());
}
if let Some(var_352) = &input.automatic_backup_retention_days {
object.key("AutomaticBackupRetentionDays").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_352).into()),
);
}
if let Some(var_353) = &input.copy_tags_to_backups {
object.key("CopyTagsToBackups").boolean(*var_353);
}
if let Some(var_354) = &input.drive_cache_type {
object.key("DriveCacheType").string(var_354.as_str());
}
if let Some(var_355) = &input.data_compression_type {
object.key("DataCompressionType").string(var_355.as_str());
}
if let Some(var_356) = &input.log_configuration {
#[allow(unused_mut)]
let mut object_357 = object.key("LogConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_lustre_log_create_configuration(
&mut object_357,
var_356,
)?;
object_357.finish();
}
if let Some(var_358) = &input.root_squash_configuration {
#[allow(unused_mut)]
let mut object_359 = object.key("RootSquashConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_lustre_root_squash_configuration(
&mut object_359,
var_358,
)?;
object_359.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_create_file_system_ontap_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CreateFileSystemOntapConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_360) = &input.automatic_backup_retention_days {
object.key("AutomaticBackupRetentionDays").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_360).into()),
);
}
if let Some(var_361) = &input.daily_automatic_backup_start_time {
object
.key("DailyAutomaticBackupStartTime")
.string(var_361.as_str());
}
if let Some(var_362) = &input.deployment_type {
object.key("DeploymentType").string(var_362.as_str());
}
if let Some(var_363) = &input.endpoint_ip_address_range {
object
.key("EndpointIpAddressRange")
.string(var_363.as_str());
}
if let Some(var_364) = &input.fsx_admin_password {
object.key("FsxAdminPassword").string(var_364.as_str());
}
if let Some(var_365) = &input.disk_iops_configuration {
#[allow(unused_mut)]
let mut object_366 = object.key("DiskIopsConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_disk_iops_configuration(
&mut object_366,
var_365,
)?;
object_366.finish();
}
if let Some(var_367) = &input.preferred_subnet_id {
object.key("PreferredSubnetId").string(var_367.as_str());
}
if let Some(var_368) = &input.route_table_ids {
let mut array_369 = object.key("RouteTableIds").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.throughput_capacity {
object.key("ThroughputCapacity").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_371).into()),
);
}
if let Some(var_372) = &input.weekly_maintenance_start_time {
object
.key("WeeklyMaintenanceStartTime")
.string(var_372.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_create_file_system_open_zfs_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CreateFileSystemOpenZfsConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_373) = &input.automatic_backup_retention_days {
object.key("AutomaticBackupRetentionDays").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_373).into()),
);
}
if let Some(var_374) = &input.copy_tags_to_backups {
object.key("CopyTagsToBackups").boolean(*var_374);
}
if let Some(var_375) = &input.copy_tags_to_volumes {
object.key("CopyTagsToVolumes").boolean(*var_375);
}
if let Some(var_376) = &input.daily_automatic_backup_start_time {
object
.key("DailyAutomaticBackupStartTime")
.string(var_376.as_str());
}
if let Some(var_377) = &input.deployment_type {
object.key("DeploymentType").string(var_377.as_str());
}
if let Some(var_378) = &input.throughput_capacity {
object.key("ThroughputCapacity").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_378).into()),
);
}
if let Some(var_379) = &input.weekly_maintenance_start_time {
object
.key("WeeklyMaintenanceStartTime")
.string(var_379.as_str());
}
if let Some(var_380) = &input.disk_iops_configuration {
#[allow(unused_mut)]
let mut object_381 = object.key("DiskIopsConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_disk_iops_configuration(
&mut object_381,
var_380,
)?;
object_381.finish();
}
if let Some(var_382) = &input.root_volume_configuration {
#[allow(unused_mut)]
let mut object_383 = object.key("RootVolumeConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_open_zfs_create_root_volume_configuration(
&mut object_383,
var_382,
)?;
object_383.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_create_svm_active_directory_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CreateSvmActiveDirectoryConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_384) = &input.net_bios_name {
object.key("NetBiosName").string(var_384.as_str());
}
if let Some(var_385) = &input.self_managed_active_directory_configuration {
#[allow(unused_mut)]
let mut object_386 = object
.key("SelfManagedActiveDirectoryConfiguration")
.start_object();
crate::json_ser::serialize_structure_crate_model_self_managed_active_directory_configuration(&mut object_386, var_385)?;
object_386.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_create_ontap_volume_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CreateOntapVolumeConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_387) = &input.junction_path {
object.key("JunctionPath").string(var_387.as_str());
}
if let Some(var_388) = &input.security_style {
object.key("SecurityStyle").string(var_388.as_str());
}
if let Some(var_389) = &input.size_in_megabytes {
object.key("SizeInMegabytes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_389).into()),
);
}
if let Some(var_390) = &input.storage_efficiency_enabled {
object.key("StorageEfficiencyEnabled").boolean(*var_390);
}
if let Some(var_391) = &input.storage_virtual_machine_id {
object
.key("StorageVirtualMachineId")
.string(var_391.as_str());
}
if let Some(var_392) = &input.tiering_policy {
#[allow(unused_mut)]
let mut object_393 = object.key("TieringPolicy").start_object();
crate::json_ser::serialize_structure_crate_model_tiering_policy(&mut object_393, var_392)?;
object_393.finish();
}
if let Some(var_394) = &input.ontap_volume_type {
object.key("OntapVolumeType").string(var_394.as_str());
}
if let Some(var_395) = &input.snapshot_policy {
object.key("SnapshotPolicy").string(var_395.as_str());
}
if let Some(var_396) = &input.copy_tags_to_backups {
object.key("CopyTagsToBackups").boolean(*var_396);
}
Ok(())
}
pub fn serialize_structure_crate_model_create_open_zfs_volume_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CreateOpenZfsVolumeConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_397) = &input.parent_volume_id {
object.key("ParentVolumeId").string(var_397.as_str());
}
if let Some(var_398) = &input.storage_capacity_reservation_gi_b {
object.key("StorageCapacityReservationGiB").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_398).into()),
);
}
if let Some(var_399) = &input.storage_capacity_quota_gi_b {
object.key("StorageCapacityQuotaGiB").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_399).into()),
);
}
if let Some(var_400) = &input.record_size_ki_b {
object.key("RecordSizeKiB").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_400).into()),
);
}
if let Some(var_401) = &input.data_compression_type {
object.key("DataCompressionType").string(var_401.as_str());
}
if let Some(var_402) = &input.copy_tags_to_snapshots {
object.key("CopyTagsToSnapshots").boolean(*var_402);
}
if let Some(var_403) = &input.origin_snapshot {
#[allow(unused_mut)]
let mut object_404 = object.key("OriginSnapshot").start_object();
crate::json_ser::serialize_structure_crate_model_create_open_zfs_origin_snapshot_configuration(&mut object_404, var_403)?;
object_404.finish();
}
if let Some(var_405) = &input.read_only {
object.key("ReadOnly").boolean(*var_405);
}
if let Some(var_406) = &input.nfs_exports {
let mut array_407 = object.key("NfsExports").start_array();
for item_408 in var_406 {
{
#[allow(unused_mut)]
let mut object_409 = array_407.value().start_object();
crate::json_ser::serialize_structure_crate_model_open_zfs_nfs_export(
&mut object_409,
item_408,
)?;
object_409.finish();
}
}
array_407.finish();
}
if let Some(var_410) = &input.user_and_group_quotas {
let mut array_411 = object.key("UserAndGroupQuotas").start_array();
for item_412 in var_410 {
{
#[allow(unused_mut)]
let mut object_413 = array_411.value().start_object();
crate::json_ser::serialize_structure_crate_model_open_zfs_user_or_group_quota(
&mut object_413,
item_412,
)?;
object_413.finish();
}
}
array_411.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_delete_file_system_windows_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DeleteFileSystemWindowsConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_414) = &input.skip_final_backup {
object.key("SkipFinalBackup").boolean(*var_414);
}
if let Some(var_415) = &input.final_backup_tags {
let mut array_416 = object.key("FinalBackupTags").start_array();
for item_417 in var_415 {
{
#[allow(unused_mut)]
let mut object_418 = array_416.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_418, item_417)?;
object_418.finish();
}
}
array_416.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_delete_file_system_lustre_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DeleteFileSystemLustreConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_419) = &input.skip_final_backup {
object.key("SkipFinalBackup").boolean(*var_419);
}
if let Some(var_420) = &input.final_backup_tags {
let mut array_421 = object.key("FinalBackupTags").start_array();
for item_422 in var_420 {
{
#[allow(unused_mut)]
let mut object_423 = array_421.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_423, item_422)?;
object_423.finish();
}
}
array_421.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_delete_file_system_open_zfs_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DeleteFileSystemOpenZfsConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_424) = &input.skip_final_backup {
object.key("SkipFinalBackup").boolean(*var_424);
}
if let Some(var_425) = &input.final_backup_tags {
let mut array_426 = object.key("FinalBackupTags").start_array();
for item_427 in var_425 {
{
#[allow(unused_mut)]
let mut object_428 = array_426.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_428, item_427)?;
object_428.finish();
}
}
array_426.finish();
}
if let Some(var_429) = &input.options {
let mut array_430 = object.key("Options").start_array();
for item_431 in var_429 {
{
array_430.value().string(item_431.as_str());
}
}
array_430.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_delete_volume_ontap_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DeleteVolumeOntapConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_432) = &input.skip_final_backup {
object.key("SkipFinalBackup").boolean(*var_432);
}
if let Some(var_433) = &input.final_backup_tags {
let mut array_434 = object.key("FinalBackupTags").start_array();
for item_435 in var_433 {
{
#[allow(unused_mut)]
let mut object_436 = array_434.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_436, item_435)?;
object_436.finish();
}
}
array_434.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_delete_volume_open_zfs_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DeleteVolumeOpenZfsConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_437) = &input.options {
let mut array_438 = object.key("Options").start_array();
for item_439 in var_437 {
{
array_438.value().string(item_439.as_str());
}
}
array_438.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Filter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_440) = &input.name {
object.key("Name").string(var_440.as_str());
}
if let Some(var_441) = &input.values {
let mut array_442 = object.key("Values").start_array();
for item_443 in var_441 {
{
array_442.value().string(item_443.as_str());
}
}
array_442.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_data_repository_task_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DataRepositoryTaskFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_444) = &input.name {
object.key("Name").string(var_444.as_str());
}
if let Some(var_445) = &input.values {
let mut array_446 = object.key("Values").start_array();
for item_447 in var_445 {
{
array_446.value().string(item_447.as_str());
}
}
array_446.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_snapshot_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SnapshotFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_448) = &input.name {
object.key("Name").string(var_448.as_str());
}
if let Some(var_449) = &input.values {
let mut array_450 = object.key("Values").start_array();
for item_451 in var_449 {
{
array_450.value().string(item_451.as_str());
}
}
array_450.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_storage_virtual_machine_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StorageVirtualMachineFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_452) = &input.name {
object.key("Name").string(var_452.as_str());
}
if let Some(var_453) = &input.values {
let mut array_454 = object.key("Values").start_array();
for item_455 in var_453 {
{
array_454.value().string(item_455.as_str());
}
}
array_454.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_volume_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::VolumeFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_456) = &input.name {
object.key("Name").string(var_456.as_str());
}
if let Some(var_457) = &input.values {
let mut array_458 = object.key("Values").start_array();
for item_459 in var_457 {
{
array_458.value().string(item_459.as_str());
}
}
array_458.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_update_file_cache_lustre_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpdateFileCacheLustreConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_460) = &input.weekly_maintenance_start_time {
object
.key("WeeklyMaintenanceStartTime")
.string(var_460.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_update_file_system_windows_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpdateFileSystemWindowsConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_461) = &input.weekly_maintenance_start_time {
object
.key("WeeklyMaintenanceStartTime")
.string(var_461.as_str());
}
if let Some(var_462) = &input.daily_automatic_backup_start_time {
object
.key("DailyAutomaticBackupStartTime")
.string(var_462.as_str());
}
if let Some(var_463) = &input.automatic_backup_retention_days {
object.key("AutomaticBackupRetentionDays").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_463).into()),
);
}
if let Some(var_464) = &input.throughput_capacity {
object.key("ThroughputCapacity").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_464).into()),
);
}
if let Some(var_465) = &input.self_managed_active_directory_configuration {
#[allow(unused_mut)]
let mut object_466 = object
.key("SelfManagedActiveDirectoryConfiguration")
.start_object();
crate::json_ser::serialize_structure_crate_model_self_managed_active_directory_configuration_updates(&mut object_466, var_465)?;
object_466.finish();
}
if let Some(var_467) = &input.audit_log_configuration {
#[allow(unused_mut)]
let mut object_468 = object.key("AuditLogConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_windows_audit_log_create_configuration(
&mut object_468,
var_467,
)?;
object_468.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_update_file_system_lustre_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpdateFileSystemLustreConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_469) = &input.weekly_maintenance_start_time {
object
.key("WeeklyMaintenanceStartTime")
.string(var_469.as_str());
}
if let Some(var_470) = &input.daily_automatic_backup_start_time {
object
.key("DailyAutomaticBackupStartTime")
.string(var_470.as_str());
}
if let Some(var_471) = &input.automatic_backup_retention_days {
object.key("AutomaticBackupRetentionDays").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_471).into()),
);
}
if let Some(var_472) = &input.auto_import_policy {
object.key("AutoImportPolicy").string(var_472.as_str());
}
if let Some(var_473) = &input.data_compression_type {
object.key("DataCompressionType").string(var_473.as_str());
}
if let Some(var_474) = &input.log_configuration {
#[allow(unused_mut)]
let mut object_475 = object.key("LogConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_lustre_log_create_configuration(
&mut object_475,
var_474,
)?;
object_475.finish();
}
if let Some(var_476) = &input.root_squash_configuration {
#[allow(unused_mut)]
let mut object_477 = object.key("RootSquashConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_lustre_root_squash_configuration(
&mut object_477,
var_476,
)?;
object_477.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_update_file_system_ontap_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpdateFileSystemOntapConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_478) = &input.automatic_backup_retention_days {
object.key("AutomaticBackupRetentionDays").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_478).into()),
);
}
if let Some(var_479) = &input.daily_automatic_backup_start_time {
object
.key("DailyAutomaticBackupStartTime")
.string(var_479.as_str());
}
if let Some(var_480) = &input.fsx_admin_password {
object.key("FsxAdminPassword").string(var_480.as_str());
}
if let Some(var_481) = &input.weekly_maintenance_start_time {
object
.key("WeeklyMaintenanceStartTime")
.string(var_481.as_str());
}
if let Some(var_482) = &input.disk_iops_configuration {
#[allow(unused_mut)]
let mut object_483 = object.key("DiskIopsConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_disk_iops_configuration(
&mut object_483,
var_482,
)?;
object_483.finish();
}
if let Some(var_484) = &input.throughput_capacity {
object.key("ThroughputCapacity").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_484).into()),
);
}
if let Some(var_485) = &input.add_route_table_ids {
let mut array_486 = object.key("AddRouteTableIds").start_array();
for item_487 in var_485 {
{
array_486.value().string(item_487.as_str());
}
}
array_486.finish();
}
if let Some(var_488) = &input.remove_route_table_ids {
let mut array_489 = object.key("RemoveRouteTableIds").start_array();
for item_490 in var_488 {
{
array_489.value().string(item_490.as_str());
}
}
array_489.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_update_file_system_open_zfs_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpdateFileSystemOpenZfsConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_491) = &input.automatic_backup_retention_days {
object.key("AutomaticBackupRetentionDays").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_491).into()),
);
}
if let Some(var_492) = &input.copy_tags_to_backups {
object.key("CopyTagsToBackups").boolean(*var_492);
}
if let Some(var_493) = &input.copy_tags_to_volumes {
object.key("CopyTagsToVolumes").boolean(*var_493);
}
if let Some(var_494) = &input.daily_automatic_backup_start_time {
object
.key("DailyAutomaticBackupStartTime")
.string(var_494.as_str());
}
if let Some(var_495) = &input.throughput_capacity {
object.key("ThroughputCapacity").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_495).into()),
);
}
if let Some(var_496) = &input.weekly_maintenance_start_time {
object
.key("WeeklyMaintenanceStartTime")
.string(var_496.as_str());
}
if let Some(var_497) = &input.disk_iops_configuration {
#[allow(unused_mut)]
let mut object_498 = object.key("DiskIopsConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_disk_iops_configuration(
&mut object_498,
var_497,
)?;
object_498.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_update_svm_active_directory_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpdateSvmActiveDirectoryConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_499) = &input.self_managed_active_directory_configuration {
#[allow(unused_mut)]
let mut object_500 = object
.key("SelfManagedActiveDirectoryConfiguration")
.start_object();
crate::json_ser::serialize_structure_crate_model_self_managed_active_directory_configuration_updates(&mut object_500, var_499)?;
object_500.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_update_ontap_volume_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpdateOntapVolumeConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_501) = &input.junction_path {
object.key("JunctionPath").string(var_501.as_str());
}
if let Some(var_502) = &input.security_style {
object.key("SecurityStyle").string(var_502.as_str());
}
if let Some(var_503) = &input.size_in_megabytes {
object.key("SizeInMegabytes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_503).into()),
);
}
if let Some(var_504) = &input.storage_efficiency_enabled {
object.key("StorageEfficiencyEnabled").boolean(*var_504);
}
if let Some(var_505) = &input.tiering_policy {
#[allow(unused_mut)]
let mut object_506 = object.key("TieringPolicy").start_object();
crate::json_ser::serialize_structure_crate_model_tiering_policy(&mut object_506, var_505)?;
object_506.finish();
}
if let Some(var_507) = &input.snapshot_policy {
object.key("SnapshotPolicy").string(var_507.as_str());
}
if let Some(var_508) = &input.copy_tags_to_backups {
object.key("CopyTagsToBackups").boolean(*var_508);
}
Ok(())
}
pub fn serialize_structure_crate_model_update_open_zfs_volume_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UpdateOpenZfsVolumeConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_509) = &input.storage_capacity_reservation_gi_b {
object.key("StorageCapacityReservationGiB").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_509).into()),
);
}
if let Some(var_510) = &input.storage_capacity_quota_gi_b {
object.key("StorageCapacityQuotaGiB").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_510).into()),
);
}
if let Some(var_511) = &input.record_size_ki_b {
object.key("RecordSizeKiB").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_511).into()),
);
}
if let Some(var_512) = &input.data_compression_type {
object.key("DataCompressionType").string(var_512.as_str());
}
if let Some(var_513) = &input.nfs_exports {
let mut array_514 = object.key("NfsExports").start_array();
for item_515 in var_513 {
{
#[allow(unused_mut)]
let mut object_516 = array_514.value().start_object();
crate::json_ser::serialize_structure_crate_model_open_zfs_nfs_export(
&mut object_516,
item_515,
)?;
object_516.finish();
}
}
array_514.finish();
}
if let Some(var_517) = &input.user_and_group_quotas {
let mut array_518 = object.key("UserAndGroupQuotas").start_array();
for item_519 in var_517 {
{
#[allow(unused_mut)]
let mut object_520 = array_518.value().start_object();
crate::json_ser::serialize_structure_crate_model_open_zfs_user_or_group_quota(
&mut object_520,
item_519,
)?;
object_520.finish();
}
}
array_518.finish();
}
if let Some(var_521) = &input.read_only {
object.key("ReadOnly").boolean(*var_521);
}
Ok(())
}
pub fn serialize_structure_crate_model_auto_import_policy(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AutoImportPolicy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_522) = &input.events {
let mut array_523 = object.key("Events").start_array();
for item_524 in var_522 {
{
array_523.value().string(item_524.as_str());
}
}
array_523.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_auto_export_policy(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AutoExportPolicy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_525) = &input.events {
let mut array_526 = object.key("Events").start_array();
for item_527 in var_525 {
{
array_526.value().string(item_527.as_str());
}
}
array_526.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_file_cache_lustre_metadata_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FileCacheLustreMetadataConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_528) = &input.storage_capacity {
object.key("StorageCapacity").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_528).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_file_cache_nfs_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FileCacheNfsConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_529) = &input.version {
object.key("Version").string(var_529.as_str());
}
if let Some(var_530) = &input.dns_ips {
let mut array_531 = object.key("DnsIps").start_array();
for item_532 in var_530 {
{
array_531.value().string(item_532.as_str());
}
}
array_531.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_self_managed_active_directory_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SelfManagedActiveDirectoryConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_533) = &input.domain_name {
object.key("DomainName").string(var_533.as_str());
}
if let Some(var_534) = &input.organizational_unit_distinguished_name {
object
.key("OrganizationalUnitDistinguishedName")
.string(var_534.as_str());
}
if let Some(var_535) = &input.file_system_administrators_group {
object
.key("FileSystemAdministratorsGroup")
.string(var_535.as_str());
}
if let Some(var_536) = &input.user_name {
object.key("UserName").string(var_536.as_str());
}
if let Some(var_537) = &input.password {
object.key("Password").string(var_537.as_str());
}
if let Some(var_538) = &input.dns_ips {
let mut array_539 = object.key("DnsIps").start_array();
for item_540 in var_538 {
{
array_539.value().string(item_540.as_str());
}
}
array_539.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_windows_audit_log_create_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::WindowsAuditLogCreateConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_541) = &input.file_access_audit_log_level {
object
.key("FileAccessAuditLogLevel")
.string(var_541.as_str());
}
if let Some(var_542) = &input.file_share_access_audit_log_level {
object
.key("FileShareAccessAuditLogLevel")
.string(var_542.as_str());
}
if let Some(var_543) = &input.audit_log_destination {
object.key("AuditLogDestination").string(var_543.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_lustre_log_create_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LustreLogCreateConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_544) = &input.level {
object.key("Level").string(var_544.as_str());
}
if let Some(var_545) = &input.destination {
object.key("Destination").string(var_545.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_lustre_root_squash_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LustreRootSquashConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_546) = &input.root_squash {
object.key("RootSquash").string(var_546.as_str());
}
if let Some(var_547) = &input.no_squash_nids {
let mut array_548 = object.key("NoSquashNids").start_array();
for item_549 in var_547 {
{
array_548.value().string(item_549.as_str());
}
}
array_548.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_disk_iops_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DiskIopsConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_550) = &input.mode {
object.key("Mode").string(var_550.as_str());
}
if let Some(var_551) = &input.iops {
object.key("Iops").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_551).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_open_zfs_create_root_volume_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OpenZfsCreateRootVolumeConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_552) = &input.record_size_ki_b {
object.key("RecordSizeKiB").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_552).into()),
);
}
if let Some(var_553) = &input.data_compression_type {
object.key("DataCompressionType").string(var_553.as_str());
}
if let Some(var_554) = &input.nfs_exports {
let mut array_555 = object.key("NfsExports").start_array();
for item_556 in var_554 {
{
#[allow(unused_mut)]
let mut object_557 = array_555.value().start_object();
crate::json_ser::serialize_structure_crate_model_open_zfs_nfs_export(
&mut object_557,
item_556,
)?;
object_557.finish();
}
}
array_555.finish();
}
if let Some(var_558) = &input.user_and_group_quotas {
let mut array_559 = object.key("UserAndGroupQuotas").start_array();
for item_560 in var_558 {
{
#[allow(unused_mut)]
let mut object_561 = array_559.value().start_object();
crate::json_ser::serialize_structure_crate_model_open_zfs_user_or_group_quota(
&mut object_561,
item_560,
)?;
object_561.finish();
}
}
array_559.finish();
}
if let Some(var_562) = &input.copy_tags_to_snapshots {
object.key("CopyTagsToSnapshots").boolean(*var_562);
}
if let Some(var_563) = &input.read_only {
object.key("ReadOnly").boolean(*var_563);
}
Ok(())
}
pub fn serialize_structure_crate_model_tiering_policy(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TieringPolicy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_564) = &input.cooling_period {
object.key("CoolingPeriod").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_564).into()),
);
}
if let Some(var_565) = &input.name {
object.key("Name").string(var_565.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_create_open_zfs_origin_snapshot_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CreateOpenZfsOriginSnapshotConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_566) = &input.snapshot_arn {
object.key("SnapshotARN").string(var_566.as_str());
}
if let Some(var_567) = &input.copy_strategy {
object.key("CopyStrategy").string(var_567.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_open_zfs_nfs_export(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OpenZfsNfsExport,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_568) = &input.client_configurations {
let mut array_569 = object.key("ClientConfigurations").start_array();
for item_570 in var_568 {
{
#[allow(unused_mut)]
let mut object_571 = array_569.value().start_object();
crate::json_ser::serialize_structure_crate_model_open_zfs_client_configuration(
&mut object_571,
item_570,
)?;
object_571.finish();
}
}
array_569.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_open_zfs_user_or_group_quota(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OpenZfsUserOrGroupQuota,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_572) = &input.r#type {
object.key("Type").string(var_572.as_str());
}
if let Some(var_573) = &input.id {
object.key("Id").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_573).into()),
);
}
if let Some(var_574) = &input.storage_capacity_quota_gi_b {
object.key("StorageCapacityQuotaGiB").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_574).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_self_managed_active_directory_configuration_updates(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SelfManagedActiveDirectoryConfigurationUpdates,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_575) = &input.user_name {
object.key("UserName").string(var_575.as_str());
}
if let Some(var_576) = &input.password {
object.key("Password").string(var_576.as_str());
}
if let Some(var_577) = &input.dns_ips {
let mut array_578 = object.key("DnsIps").start_array();
for item_579 in var_577 {
{
array_578.value().string(item_579.as_str());
}
}
array_578.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_open_zfs_client_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OpenZfsClientConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_580) = &input.clients {
object.key("Clients").string(var_580.as_str());
}
if let Some(var_581) = &input.options {
let mut array_582 = object.key("Options").start_array();
for item_583 in var_581 {
{
array_582.value().string(item_583.as_str());
}
}
array_582.finish();
}
Ok(())
}