pub fn serialize_structure_crate_input_create_extended_source_server_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateExtendedSourceServerInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.source_server_arn {
object.key("sourceServerArn").string(var_1.as_str());
}
if let Some(var_2) = &input.tags {
#[allow(unused_mut)]
let mut object_3 = object.key("tags").start_object();
for (key_4, value_5) in var_2 {
{
object_3.key(key_4.as_str()).string(value_5.as_str());
}
}
object_3.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_replication_configuration_template_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateReplicationConfigurationTemplateInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_6) = &input.associate_default_security_group {
object.key("associateDefaultSecurityGroup").boolean(*var_6);
}
{
object.key("bandwidthThrottling").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.bandwidth_throttling).into()),
);
}
if let Some(var_7) = &input.create_public_ip {
object.key("createPublicIP").boolean(*var_7);
}
if let Some(var_8) = &input.data_plane_routing {
object.key("dataPlaneRouting").string(var_8.as_str());
}
if let Some(var_9) = &input.default_large_staging_disk_type {
object
.key("defaultLargeStagingDiskType")
.string(var_9.as_str());
}
if let Some(var_10) = &input.ebs_encryption {
object.key("ebsEncryption").string(var_10.as_str());
}
if let Some(var_11) = &input.ebs_encryption_key_arn {
object.key("ebsEncryptionKeyArn").string(var_11.as_str());
}
if let Some(var_12) = &input.pit_policy {
let mut array_13 = object.key("pitPolicy").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_pit_policy_rule(
&mut object_15,
item_14,
)?;
object_15.finish();
}
}
array_13.finish();
}
if let Some(var_16) = &input.replication_server_instance_type {
object
.key("replicationServerInstanceType")
.string(var_16.as_str());
}
if let Some(var_17) = &input.replication_servers_security_groups_i_ds {
let mut array_18 = object
.key("replicationServersSecurityGroupsIDs")
.start_array();
for item_19 in var_17 {
{
array_18.value().string(item_19.as_str());
}
}
array_18.finish();
}
if let Some(var_20) = &input.staging_area_subnet_id {
object.key("stagingAreaSubnetId").string(var_20.as_str());
}
if let Some(var_21) = &input.staging_area_tags {
#[allow(unused_mut)]
let mut object_22 = object.key("stagingAreaTags").start_object();
for (key_23, value_24) in var_21 {
{
object_22.key(key_23.as_str()).string(value_24.as_str());
}
}
object_22.finish();
}
if let Some(var_25) = &input.tags {
#[allow(unused_mut)]
let mut object_26 = object.key("tags").start_object();
for (key_27, value_28) in var_25 {
{
object_26.key(key_27.as_str()).string(value_28.as_str());
}
}
object_26.finish();
}
if let Some(var_29) = &input.use_dedicated_replication_server {
object.key("useDedicatedReplicationServer").boolean(*var_29);
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_30) = &input.job_id {
object.key("jobID").string(var_30.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_recovery_instance_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteRecoveryInstanceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_31) = &input.recovery_instance_id {
object.key("recoveryInstanceID").string(var_31.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_replication_configuration_template_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteReplicationConfigurationTemplateInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_32) = &input.replication_configuration_template_id {
object
.key("replicationConfigurationTemplateID")
.string(var_32.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_source_server_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteSourceServerInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_33) = &input.source_server_id {
object.key("sourceServerID").string(var_33.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_job_log_items_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeJobLogItemsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_34) = &input.job_id {
object.key("jobID").string(var_34.as_str());
}
if input.max_results != 0 {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max_results).into()),
);
}
if let Some(var_35) = &input.next_token {
object.key("nextToken").string(var_35.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_jobs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeJobsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_36) = &input.filters {
#[allow(unused_mut)]
let mut object_37 = object.key("filters").start_object();
crate::json_ser::serialize_structure_crate_model_describe_jobs_request_filters(
&mut object_37,
var_36,
)?;
object_37.finish();
}
if input.max_results != 0 {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max_results).into()),
);
}
if let Some(var_38) = &input.next_token {
object.key("nextToken").string(var_38.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_recovery_instances_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeRecoveryInstancesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_39) = &input.filters {
#[allow(unused_mut)]
let mut object_40 = object.key("filters").start_object();
crate::json_ser::serialize_structure_crate_model_describe_recovery_instances_request_filters(&mut object_40, var_39)?;
object_40.finish();
}
if input.max_results != 0 {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max_results).into()),
);
}
if let Some(var_41) = &input.next_token {
object.key("nextToken").string(var_41.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_recovery_snapshots_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeRecoverySnapshotsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_42) = &input.filters {
#[allow(unused_mut)]
let mut object_43 = object.key("filters").start_object();
crate::json_ser::serialize_structure_crate_model_describe_recovery_snapshots_request_filters(&mut object_43, var_42)?;
object_43.finish();
}
if input.max_results != 0 {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max_results).into()),
);
}
if let Some(var_44) = &input.next_token {
object.key("nextToken").string(var_44.as_str());
}
if let Some(var_45) = &input.order {
object.key("order").string(var_45.as_str());
}
if let Some(var_46) = &input.source_server_id {
object.key("sourceServerID").string(var_46.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_replication_configuration_templates_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeReplicationConfigurationTemplatesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.max_results != 0 {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max_results).into()),
);
}
if let Some(var_47) = &input.next_token {
object.key("nextToken").string(var_47.as_str());
}
if let Some(var_48) = &input.replication_configuration_template_i_ds {
let mut array_49 = object
.key("replicationConfigurationTemplateIDs")
.start_array();
for item_50 in var_48 {
{
array_49.value().string(item_50.as_str());
}
}
array_49.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_source_servers_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeSourceServersInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_51) = &input.filters {
#[allow(unused_mut)]
let mut object_52 = object.key("filters").start_object();
crate::json_ser::serialize_structure_crate_model_describe_source_servers_request_filters(
&mut object_52,
var_51,
)?;
object_52.finish();
}
if input.max_results != 0 {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max_results).into()),
);
}
if let Some(var_53) = &input.next_token {
object.key("nextToken").string(var_53.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_disconnect_recovery_instance_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DisconnectRecoveryInstanceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_54) = &input.recovery_instance_id {
object.key("recoveryInstanceID").string(var_54.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_disconnect_source_server_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DisconnectSourceServerInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_55) = &input.source_server_id {
object.key("sourceServerID").string(var_55.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_failback_replication_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetFailbackReplicationConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_56) = &input.recovery_instance_id {
object.key("recoveryInstanceID").string(var_56.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_launch_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetLaunchConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_57) = &input.source_server_id {
object.key("sourceServerID").string(var_57.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_replication_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetReplicationConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_58) = &input.source_server_id {
object.key("sourceServerID").string(var_58.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_extensible_source_servers_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListExtensibleSourceServersInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.max_results != 0 {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max_results).into()),
);
}
if let Some(var_59) = &input.next_token {
object.key("nextToken").string(var_59.as_str());
}
if let Some(var_60) = &input.staging_account_id {
object.key("stagingAccountID").string(var_60.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_retry_data_replication_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RetryDataReplicationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_61) = &input.source_server_id {
object.key("sourceServerID").string(var_61.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_reverse_replication_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ReverseReplicationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_62) = &input.recovery_instance_id {
object.key("recoveryInstanceID").string(var_62.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_start_failback_launch_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartFailbackLaunchInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_63) = &input.recovery_instance_i_ds {
let mut array_64 = object.key("recoveryInstanceIDs").start_array();
for item_65 in var_63 {
{
array_64.value().string(item_65.as_str());
}
}
array_64.finish();
}
if let Some(var_66) = &input.tags {
#[allow(unused_mut)]
let mut object_67 = object.key("tags").start_object();
for (key_68, value_69) in var_66 {
{
object_67.key(key_68.as_str()).string(value_69.as_str());
}
}
object_67.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_start_recovery_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartRecoveryInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_70) = &input.is_drill {
object.key("isDrill").boolean(*var_70);
}
if let Some(var_71) = &input.source_servers {
let mut array_72 = object.key("sourceServers").start_array();
for item_73 in var_71 {
{
#[allow(unused_mut)]
let mut object_74 = array_72.value().start_object();
crate::json_ser::serialize_structure_crate_model_start_recovery_request_source_server(&mut object_74, item_73)?;
object_74.finish();
}
}
array_72.finish();
}
if let Some(var_75) = &input.tags {
#[allow(unused_mut)]
let mut object_76 = object.key("tags").start_object();
for (key_77, value_78) in var_75 {
{
object_76.key(key_77.as_str()).string(value_78.as_str());
}
}
object_76.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_start_replication_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartReplicationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_79) = &input.source_server_id {
object.key("sourceServerID").string(var_79.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_stop_failback_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StopFailbackInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_80) = &input.recovery_instance_id {
object.key("recoveryInstanceID").string(var_80.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_stop_replication_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StopReplicationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_81) = &input.source_server_id {
object.key("sourceServerID").string(var_81.as_str());
}
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_82) = &input.tags {
#[allow(unused_mut)]
let mut object_83 = object.key("tags").start_object();
for (key_84, value_85) in var_82 {
{
object_83.key(key_84.as_str()).string(value_85.as_str());
}
}
object_83.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_terminate_recovery_instances_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::TerminateRecoveryInstancesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_86) = &input.recovery_instance_i_ds {
let mut array_87 = object.key("recoveryInstanceIDs").start_array();
for item_88 in var_86 {
{
array_87.value().string(item_88.as_str());
}
}
array_87.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_failback_replication_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateFailbackReplicationConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.bandwidth_throttling != 0 {
object.key("bandwidthThrottling").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.bandwidth_throttling).into()),
);
}
if let Some(var_89) = &input.name {
object.key("name").string(var_89.as_str());
}
if let Some(var_90) = &input.recovery_instance_id {
object.key("recoveryInstanceID").string(var_90.as_str());
}
if let Some(var_91) = &input.use_private_ip {
object.key("usePrivateIP").boolean(*var_91);
}
Ok(())
}
pub fn serialize_structure_crate_input_update_launch_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateLaunchConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_92) = &input.copy_private_ip {
object.key("copyPrivateIp").boolean(*var_92);
}
if let Some(var_93) = &input.copy_tags {
object.key("copyTags").boolean(*var_93);
}
if let Some(var_94) = &input.launch_disposition {
object.key("launchDisposition").string(var_94.as_str());
}
if let Some(var_95) = &input.licensing {
#[allow(unused_mut)]
let mut object_96 = object.key("licensing").start_object();
crate::json_ser::serialize_structure_crate_model_licensing(&mut object_96, var_95)?;
object_96.finish();
}
if let Some(var_97) = &input.name {
object.key("name").string(var_97.as_str());
}
if let Some(var_98) = &input.source_server_id {
object.key("sourceServerID").string(var_98.as_str());
}
if let Some(var_99) = &input.target_instance_type_right_sizing_method {
object
.key("targetInstanceTypeRightSizingMethod")
.string(var_99.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_replication_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateReplicationConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_100) = &input.associate_default_security_group {
object
.key("associateDefaultSecurityGroup")
.boolean(*var_100);
}
if input.bandwidth_throttling != 0 {
object.key("bandwidthThrottling").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.bandwidth_throttling).into()),
);
}
if let Some(var_101) = &input.create_public_ip {
object.key("createPublicIP").boolean(*var_101);
}
if let Some(var_102) = &input.data_plane_routing {
object.key("dataPlaneRouting").string(var_102.as_str());
}
if let Some(var_103) = &input.default_large_staging_disk_type {
object
.key("defaultLargeStagingDiskType")
.string(var_103.as_str());
}
if let Some(var_104) = &input.ebs_encryption {
object.key("ebsEncryption").string(var_104.as_str());
}
if let Some(var_105) = &input.ebs_encryption_key_arn {
object.key("ebsEncryptionKeyArn").string(var_105.as_str());
}
if let Some(var_106) = &input.name {
object.key("name").string(var_106.as_str());
}
if let Some(var_107) = &input.pit_policy {
let mut array_108 = object.key("pitPolicy").start_array();
for item_109 in var_107 {
{
#[allow(unused_mut)]
let mut object_110 = array_108.value().start_object();
crate::json_ser::serialize_structure_crate_model_pit_policy_rule(
&mut object_110,
item_109,
)?;
object_110.finish();
}
}
array_108.finish();
}
if let Some(var_111) = &input.replicated_disks {
let mut array_112 = object.key("replicatedDisks").start_array();
for item_113 in var_111 {
{
#[allow(unused_mut)]
let mut object_114 = array_112.value().start_object();
crate::json_ser::serialize_structure_crate_model_replication_configuration_replicated_disk(&mut object_114, item_113)?;
object_114.finish();
}
}
array_112.finish();
}
if let Some(var_115) = &input.replication_server_instance_type {
object
.key("replicationServerInstanceType")
.string(var_115.as_str());
}
if let Some(var_116) = &input.replication_servers_security_groups_i_ds {
let mut array_117 = object
.key("replicationServersSecurityGroupsIDs")
.start_array();
for item_118 in var_116 {
{
array_117.value().string(item_118.as_str());
}
}
array_117.finish();
}
if let Some(var_119) = &input.source_server_id {
object.key("sourceServerID").string(var_119.as_str());
}
if let Some(var_120) = &input.staging_area_subnet_id {
object.key("stagingAreaSubnetId").string(var_120.as_str());
}
if let Some(var_121) = &input.staging_area_tags {
#[allow(unused_mut)]
let mut object_122 = object.key("stagingAreaTags").start_object();
for (key_123, value_124) in var_121 {
{
object_122.key(key_123.as_str()).string(value_124.as_str());
}
}
object_122.finish();
}
if let Some(var_125) = &input.use_dedicated_replication_server {
object
.key("useDedicatedReplicationServer")
.boolean(*var_125);
}
Ok(())
}
pub fn serialize_structure_crate_input_update_replication_configuration_template_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateReplicationConfigurationTemplateInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_126) = &input.arn {
object.key("arn").string(var_126.as_str());
}
if let Some(var_127) = &input.associate_default_security_group {
object
.key("associateDefaultSecurityGroup")
.boolean(*var_127);
}
if input.bandwidth_throttling != 0 {
object.key("bandwidthThrottling").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.bandwidth_throttling).into()),
);
}
if let Some(var_128) = &input.create_public_ip {
object.key("createPublicIP").boolean(*var_128);
}
if let Some(var_129) = &input.data_plane_routing {
object.key("dataPlaneRouting").string(var_129.as_str());
}
if let Some(var_130) = &input.default_large_staging_disk_type {
object
.key("defaultLargeStagingDiskType")
.string(var_130.as_str());
}
if let Some(var_131) = &input.ebs_encryption {
object.key("ebsEncryption").string(var_131.as_str());
}
if let Some(var_132) = &input.ebs_encryption_key_arn {
object.key("ebsEncryptionKeyArn").string(var_132.as_str());
}
if let Some(var_133) = &input.pit_policy {
let mut array_134 = object.key("pitPolicy").start_array();
for item_135 in var_133 {
{
#[allow(unused_mut)]
let mut object_136 = array_134.value().start_object();
crate::json_ser::serialize_structure_crate_model_pit_policy_rule(
&mut object_136,
item_135,
)?;
object_136.finish();
}
}
array_134.finish();
}
if let Some(var_137) = &input.replication_configuration_template_id {
object
.key("replicationConfigurationTemplateID")
.string(var_137.as_str());
}
if let Some(var_138) = &input.replication_server_instance_type {
object
.key("replicationServerInstanceType")
.string(var_138.as_str());
}
if let Some(var_139) = &input.replication_servers_security_groups_i_ds {
let mut array_140 = object
.key("replicationServersSecurityGroupsIDs")
.start_array();
for item_141 in var_139 {
{
array_140.value().string(item_141.as_str());
}
}
array_140.finish();
}
if let Some(var_142) = &input.staging_area_subnet_id {
object.key("stagingAreaSubnetId").string(var_142.as_str());
}
if let Some(var_143) = &input.staging_area_tags {
#[allow(unused_mut)]
let mut object_144 = object.key("stagingAreaTags").start_object();
for (key_145, value_146) in var_143 {
{
object_144.key(key_145.as_str()).string(value_146.as_str());
}
}
object_144.finish();
}
if let Some(var_147) = &input.use_dedicated_replication_server {
object
.key("useDedicatedReplicationServer")
.boolean(*var_147);
}
Ok(())
}
pub fn serialize_structure_crate_model_pit_policy_rule(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PitPolicyRule,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.rule_id != 0 {
object.key("ruleID").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.rule_id).into()),
);
}
if let Some(var_148) = &input.units {
object.key("units").string(var_148.as_str());
}
{
object.key("interval").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.interval).into()),
);
}
{
object.key("retentionDuration").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.retention_duration).into()),
);
}
if let Some(var_149) = &input.enabled {
object.key("enabled").boolean(*var_149);
}
Ok(())
}
pub fn serialize_structure_crate_model_describe_jobs_request_filters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DescribeJobsRequestFilters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_150) = &input.job_i_ds {
let mut array_151 = object.key("jobIDs").start_array();
for item_152 in var_150 {
{
array_151.value().string(item_152.as_str());
}
}
array_151.finish();
}
if let Some(var_153) = &input.from_date {
object.key("fromDate").string(var_153.as_str());
}
if let Some(var_154) = &input.to_date {
object.key("toDate").string(var_154.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_describe_recovery_instances_request_filters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DescribeRecoveryInstancesRequestFilters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_155) = &input.recovery_instance_i_ds {
let mut array_156 = object.key("recoveryInstanceIDs").start_array();
for item_157 in var_155 {
{
array_156.value().string(item_157.as_str());
}
}
array_156.finish();
}
if let Some(var_158) = &input.source_server_i_ds {
let mut array_159 = object.key("sourceServerIDs").start_array();
for item_160 in var_158 {
{
array_159.value().string(item_160.as_str());
}
}
array_159.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_describe_recovery_snapshots_request_filters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DescribeRecoverySnapshotsRequestFilters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_161) = &input.from_date_time {
object.key("fromDateTime").string(var_161.as_str());
}
if let Some(var_162) = &input.to_date_time {
object.key("toDateTime").string(var_162.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_describe_source_servers_request_filters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DescribeSourceServersRequestFilters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_163) = &input.source_server_i_ds {
let mut array_164 = object.key("sourceServerIDs").start_array();
for item_165 in var_163 {
{
array_164.value().string(item_165.as_str());
}
}
array_164.finish();
}
if let Some(var_166) = &input.hardware_id {
object.key("hardwareId").string(var_166.as_str());
}
if let Some(var_167) = &input.staging_account_i_ds {
let mut array_168 = object.key("stagingAccountIDs").start_array();
for item_169 in var_167 {
{
array_168.value().string(item_169.as_str());
}
}
array_168.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_start_recovery_request_source_server(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StartRecoveryRequestSourceServer,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_170) = &input.source_server_id {
object.key("sourceServerID").string(var_170.as_str());
}
if let Some(var_171) = &input.recovery_snapshot_id {
object.key("recoverySnapshotID").string(var_171.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_licensing(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Licensing,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_172) = &input.os_byol {
object.key("osByol").boolean(*var_172);
}
Ok(())
}
pub fn serialize_structure_crate_model_replication_configuration_replicated_disk(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ReplicationConfigurationReplicatedDisk,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_173) = &input.device_name {
object.key("deviceName").string(var_173.as_str());
}
if let Some(var_174) = &input.is_boot_disk {
object.key("isBootDisk").boolean(*var_174);
}
if let Some(var_175) = &input.staging_disk_type {
object.key("stagingDiskType").string(var_175.as_str());
}
if input.iops != 0 {
object.key("iops").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.iops).into()),
);
}
if input.throughput != 0 {
object.key("throughput").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.throughput).into()),
);
}
if let Some(var_176) = &input.optimized_staging_disk_type {
object
.key("optimizedStagingDiskType")
.string(var_176.as_str());
}
Ok(())
}