pub fn serialize_structure_crate_input_archive_application_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ArchiveApplicationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.application_id {
object.key("applicationID").string(var_1.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_archive_wave_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ArchiveWaveInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2) = &input.wave_id {
object.key("waveID").string(var_2.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_associate_applications_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociateApplicationsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3) = &input.application_i_ds {
let mut array_4 = object.key("applicationIDs").start_array();
for item_5 in var_3 {
{
array_4.value().string(item_5.as_str());
}
}
array_4.finish();
}
if let Some(var_6) = &input.wave_id {
object.key("waveID").string(var_6.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_associate_source_servers_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociateSourceServersInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_7) = &input.application_id {
object.key("applicationID").string(var_7.as_str());
}
if let Some(var_8) = &input.source_server_i_ds {
let mut array_9 = object.key("sourceServerIDs").start_array();
for item_10 in var_8 {
{
array_9.value().string(item_10.as_str());
}
}
array_9.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_change_server_life_cycle_state_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ChangeServerLifeCycleStateInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_11) = &input.life_cycle {
#[allow(unused_mut)]
let mut object_12 = object.key("lifeCycle").start_object();
crate::json_ser::serialize_structure_crate_model_change_server_life_cycle_state_source_server_lifecycle(&mut object_12, var_11)?;
object_12.finish();
}
if let Some(var_13) = &input.source_server_id {
object.key("sourceServerID").string(var_13.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_application_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateApplicationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_14) = &input.description {
object.key("description").string(var_14.as_str());
}
if let Some(var_15) = &input.name {
object.key("name").string(var_15.as_str());
}
if let Some(var_16) = &input.tags {
#[allow(unused_mut)]
let mut object_17 = object.key("tags").start_object();
for (key_18, value_19) in var_16 {
{
object_17.key(key_18.as_str()).string(value_19.as_str());
}
}
object_17.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_launch_configuration_template_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateLaunchConfigurationTemplateInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_20) = &input.associate_public_ip_address {
object.key("associatePublicIpAddress").boolean(*var_20);
}
if let Some(var_21) = &input.boot_mode {
object.key("bootMode").string(var_21.as_str());
}
if let Some(var_22) = &input.copy_private_ip {
object.key("copyPrivateIp").boolean(*var_22);
}
if let Some(var_23) = &input.copy_tags {
object.key("copyTags").boolean(*var_23);
}
if let Some(var_24) = &input.enable_map_auto_tagging {
object.key("enableMapAutoTagging").boolean(*var_24);
}
if let Some(var_25) = &input.large_volume_conf {
#[allow(unused_mut)]
let mut object_26 = object.key("largeVolumeConf").start_object();
crate::json_ser::serialize_structure_crate_model_launch_template_disk_conf(
&mut object_26,
var_25,
)?;
object_26.finish();
}
if let Some(var_27) = &input.launch_disposition {
object.key("launchDisposition").string(var_27.as_str());
}
if let Some(var_28) = &input.licensing {
#[allow(unused_mut)]
let mut object_29 = object.key("licensing").start_object();
crate::json_ser::serialize_structure_crate_model_licensing(&mut object_29, var_28)?;
object_29.finish();
}
if let Some(var_30) = &input.map_auto_tagging_mpe_id {
object.key("mapAutoTaggingMpeID").string(var_30.as_str());
}
if let Some(var_31) = &input.post_launch_actions {
#[allow(unused_mut)]
let mut object_32 = object.key("postLaunchActions").start_object();
crate::json_ser::serialize_structure_crate_model_post_launch_actions(
&mut object_32,
var_31,
)?;
object_32.finish();
}
if let Some(var_33) = &input.small_volume_conf {
#[allow(unused_mut)]
let mut object_34 = object.key("smallVolumeConf").start_object();
crate::json_ser::serialize_structure_crate_model_launch_template_disk_conf(
&mut object_34,
var_33,
)?;
object_34.finish();
}
if input.small_volume_max_size != 0 {
object.key("smallVolumeMaxSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.small_volume_max_size).into()),
);
}
if let Some(var_35) = &input.tags {
#[allow(unused_mut)]
let mut object_36 = object.key("tags").start_object();
for (key_37, value_38) in var_35 {
{
object_36.key(key_37.as_str()).string(value_38.as_str());
}
}
object_36.finish();
}
if let Some(var_39) = &input.target_instance_type_right_sizing_method {
object
.key("targetInstanceTypeRightSizingMethod")
.string(var_39.as_str());
}
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_40) = &input.associate_default_security_group {
object.key("associateDefaultSecurityGroup").boolean(*var_40);
}
{
object.key("bandwidthThrottling").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.bandwidth_throttling).into()),
);
}
if let Some(var_41) = &input.create_public_ip {
object.key("createPublicIP").boolean(*var_41);
}
if let Some(var_42) = &input.data_plane_routing {
object.key("dataPlaneRouting").string(var_42.as_str());
}
if let Some(var_43) = &input.default_large_staging_disk_type {
object
.key("defaultLargeStagingDiskType")
.string(var_43.as_str());
}
if let Some(var_44) = &input.ebs_encryption {
object.key("ebsEncryption").string(var_44.as_str());
}
if let Some(var_45) = &input.ebs_encryption_key_arn {
object.key("ebsEncryptionKeyArn").string(var_45.as_str());
}
if let Some(var_46) = &input.replication_server_instance_type {
object
.key("replicationServerInstanceType")
.string(var_46.as_str());
}
if let Some(var_47) = &input.replication_servers_security_groups_i_ds {
let mut array_48 = object
.key("replicationServersSecurityGroupsIDs")
.start_array();
for item_49 in var_47 {
{
array_48.value().string(item_49.as_str());
}
}
array_48.finish();
}
if let Some(var_50) = &input.staging_area_subnet_id {
object.key("stagingAreaSubnetId").string(var_50.as_str());
}
if let Some(var_51) = &input.staging_area_tags {
#[allow(unused_mut)]
let mut object_52 = object.key("stagingAreaTags").start_object();
for (key_53, value_54) in var_51 {
{
object_52.key(key_53.as_str()).string(value_54.as_str());
}
}
object_52.finish();
}
if let Some(var_55) = &input.tags {
#[allow(unused_mut)]
let mut object_56 = object.key("tags").start_object();
for (key_57, value_58) in var_55 {
{
object_56.key(key_57.as_str()).string(value_58.as_str());
}
}
object_56.finish();
}
if let Some(var_59) = &input.use_dedicated_replication_server {
object.key("useDedicatedReplicationServer").boolean(*var_59);
}
Ok(())
}
pub fn serialize_structure_crate_input_create_wave_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateWaveInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_60) = &input.description {
object.key("description").string(var_60.as_str());
}
if let Some(var_61) = &input.name {
object.key("name").string(var_61.as_str());
}
if let Some(var_62) = &input.tags {
#[allow(unused_mut)]
let mut object_63 = object.key("tags").start_object();
for (key_64, value_65) in var_62 {
{
object_63.key(key_64.as_str()).string(value_65.as_str());
}
}
object_63.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_application_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteApplicationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_66) = &input.application_id {
object.key("applicationID").string(var_66.as_str());
}
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_67) = &input.job_id {
object.key("jobID").string(var_67.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_launch_configuration_template_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteLaunchConfigurationTemplateInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_68) = &input.launch_configuration_template_id {
object
.key("launchConfigurationTemplateID")
.string(var_68.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_69) = &input.replication_configuration_template_id {
object
.key("replicationConfigurationTemplateID")
.string(var_69.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_70) = &input.source_server_id {
object.key("sourceServerID").string(var_70.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_vcenter_client_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteVcenterClientInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_71) = &input.vcenter_client_id {
object.key("vcenterClientID").string(var_71.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_wave_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteWaveInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_72) = &input.wave_id {
object.key("waveID").string(var_72.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_73) = &input.job_id {
object.key("jobID").string(var_73.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_74) = &input.next_token {
object.key("nextToken").string(var_74.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_75) = &input.filters {
#[allow(unused_mut)]
let mut object_76 = object.key("filters").start_object();
crate::json_ser::serialize_structure_crate_model_describe_jobs_request_filters(
&mut object_76,
var_75,
)?;
object_76.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_77) = &input.next_token {
object.key("nextToken").string(var_77.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_launch_configuration_templates_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeLaunchConfigurationTemplatesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_78) = &input.launch_configuration_template_i_ds {
let mut array_79 = object.key("launchConfigurationTemplateIDs").start_array();
for item_80 in var_78 {
{
array_79.value().string(item_80.as_str());
}
}
array_79.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_81) = &input.next_token {
object.key("nextToken").string(var_81.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_82) = &input.next_token {
object.key("nextToken").string(var_82.as_str());
}
if let Some(var_83) = &input.replication_configuration_template_i_ds {
let mut array_84 = object
.key("replicationConfigurationTemplateIDs")
.start_array();
for item_85 in var_83 {
{
array_84.value().string(item_85.as_str());
}
}
array_84.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_86) = &input.filters {
#[allow(unused_mut)]
let mut object_87 = object.key("filters").start_object();
crate::json_ser::serialize_structure_crate_model_describe_source_servers_request_filters(
&mut object_87,
var_86,
)?;
object_87.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_88) = &input.next_token {
object.key("nextToken").string(var_88.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_disassociate_applications_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DisassociateApplicationsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_89) = &input.application_i_ds {
let mut array_90 = object.key("applicationIDs").start_array();
for item_91 in var_89 {
{
array_90.value().string(item_91.as_str());
}
}
array_90.finish();
}
if let Some(var_92) = &input.wave_id {
object.key("waveID").string(var_92.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_disassociate_source_servers_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DisassociateSourceServersInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_93) = &input.application_id {
object.key("applicationID").string(var_93.as_str());
}
if let Some(var_94) = &input.source_server_i_ds {
let mut array_95 = object.key("sourceServerIDs").start_array();
for item_96 in var_94 {
{
array_95.value().string(item_96.as_str());
}
}
array_95.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_disconnect_from_service_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DisconnectFromServiceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_97) = &input.source_server_id {
object.key("sourceServerID").string(var_97.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_finalize_cutover_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::FinalizeCutoverInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_98) = &input.source_server_id {
object.key("sourceServerID").string(var_98.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_99) = &input.source_server_id {
object.key("sourceServerID").string(var_99.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_100) = &input.source_server_id {
object.key("sourceServerID").string(var_100.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_applications_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListApplicationsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_101) = &input.filters {
#[allow(unused_mut)]
let mut object_102 = object.key("filters").start_object();
crate::json_ser::serialize_structure_crate_model_list_applications_request_filters(
&mut object_102,
var_101,
)?;
object_102.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_103) = &input.next_token {
object.key("nextToken").string(var_103.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_source_server_actions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListSourceServerActionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_104) = &input.filters {
#[allow(unused_mut)]
let mut object_105 = object.key("filters").start_object();
crate::json_ser::serialize_structure_crate_model_source_server_actions_request_filters(
&mut object_105,
var_104,
)?;
object_105.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_106) = &input.next_token {
object.key("nextToken").string(var_106.as_str());
}
if let Some(var_107) = &input.source_server_id {
object.key("sourceServerID").string(var_107.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_template_actions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListTemplateActionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_108) = &input.filters {
#[allow(unused_mut)]
let mut object_109 = object.key("filters").start_object();
crate::json_ser::serialize_structure_crate_model_template_actions_request_filters(
&mut object_109,
var_108,
)?;
object_109.finish();
}
if let Some(var_110) = &input.launch_configuration_template_id {
object
.key("launchConfigurationTemplateID")
.string(var_110.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_111) = &input.next_token {
object.key("nextToken").string(var_111.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_waves_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListWavesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_112) = &input.filters {
#[allow(unused_mut)]
let mut object_113 = object.key("filters").start_object();
crate::json_ser::serialize_structure_crate_model_list_waves_request_filters(
&mut object_113,
var_112,
)?;
object_113.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_114) = &input.next_token {
object.key("nextToken").string(var_114.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_mark_as_archived_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::MarkAsArchivedInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_115) = &input.source_server_id {
object.key("sourceServerID").string(var_115.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_put_source_server_action_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutSourceServerActionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_116) = &input.action_id {
object.key("actionID").string(var_116.as_str());
}
if let Some(var_117) = &input.action_name {
object.key("actionName").string(var_117.as_str());
}
if let Some(var_118) = &input.active {
object.key("active").boolean(*var_118);
}
if let Some(var_119) = &input.document_identifier {
object.key("documentIdentifier").string(var_119.as_str());
}
if let Some(var_120) = &input.document_version {
object.key("documentVersion").string(var_120.as_str());
}
if let Some(var_121) = &input.must_succeed_for_cutover {
object.key("mustSucceedForCutover").boolean(*var_121);
}
{
object.key("order").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.order).into()),
);
}
if let Some(var_122) = &input.parameters {
#[allow(unused_mut)]
let mut object_123 = object.key("parameters").start_object();
for (key_124, value_125) in var_122 {
{
let mut array_126 = object_123.key(key_124.as_str()).start_array();
for item_127 in value_125 {
{
#[allow(unused_mut)]
let mut object_128 = array_126.value().start_object();
crate::json_ser::serialize_structure_crate_model_ssm_parameter_store_parameter(&mut object_128, item_127)?;
object_128.finish();
}
}
array_126.finish();
}
}
object_123.finish();
}
if let Some(var_129) = &input.source_server_id {
object.key("sourceServerID").string(var_129.as_str());
}
if input.timeout_seconds != 0 {
object.key("timeoutSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.timeout_seconds).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_put_template_action_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutTemplateActionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_130) = &input.action_id {
object.key("actionID").string(var_130.as_str());
}
if let Some(var_131) = &input.action_name {
object.key("actionName").string(var_131.as_str());
}
if let Some(var_132) = &input.active {
object.key("active").boolean(*var_132);
}
if let Some(var_133) = &input.document_identifier {
object.key("documentIdentifier").string(var_133.as_str());
}
if let Some(var_134) = &input.document_version {
object.key("documentVersion").string(var_134.as_str());
}
if let Some(var_135) = &input.launch_configuration_template_id {
object
.key("launchConfigurationTemplateID")
.string(var_135.as_str());
}
if let Some(var_136) = &input.must_succeed_for_cutover {
object.key("mustSucceedForCutover").boolean(*var_136);
}
if let Some(var_137) = &input.operating_system {
object.key("operatingSystem").string(var_137.as_str());
}
{
object.key("order").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.order).into()),
);
}
if let Some(var_138) = &input.parameters {
#[allow(unused_mut)]
let mut object_139 = object.key("parameters").start_object();
for (key_140, value_141) in var_138 {
{
let mut array_142 = object_139.key(key_140.as_str()).start_array();
for item_143 in value_141 {
{
#[allow(unused_mut)]
let mut object_144 = array_142.value().start_object();
crate::json_ser::serialize_structure_crate_model_ssm_parameter_store_parameter(&mut object_144, item_143)?;
object_144.finish();
}
}
array_142.finish();
}
}
object_139.finish();
}
if input.timeout_seconds != 0 {
object.key("timeoutSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.timeout_seconds).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_remove_source_server_action_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RemoveSourceServerActionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_145) = &input.action_id {
object.key("actionID").string(var_145.as_str());
}
if let Some(var_146) = &input.source_server_id {
object.key("sourceServerID").string(var_146.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_remove_template_action_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RemoveTemplateActionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_147) = &input.action_id {
object.key("actionID").string(var_147.as_str());
}
if let Some(var_148) = &input.launch_configuration_template_id {
object
.key("launchConfigurationTemplateID")
.string(var_148.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_149) = &input.source_server_id {
object.key("sourceServerID").string(var_149.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_start_cutover_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartCutoverInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_150) = &input.source_server_i_ds {
let mut array_151 = object.key("sourceServerIDs").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.tags {
#[allow(unused_mut)]
let mut object_154 = object.key("tags").start_object();
for (key_155, value_156) in var_153 {
{
object_154.key(key_155.as_str()).string(value_156.as_str());
}
}
object_154.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_157) = &input.source_server_id {
object.key("sourceServerID").string(var_157.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_start_test_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartTestInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
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();
}
if let Some(var_161) = &input.tags {
#[allow(unused_mut)]
let mut object_162 = object.key("tags").start_object();
for (key_163, value_164) in var_161 {
{
object_162.key(key_163.as_str()).string(value_164.as_str());
}
}
object_162.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_165) = &input.tags {
#[allow(unused_mut)]
let mut object_166 = object.key("tags").start_object();
for (key_167, value_168) in var_165 {
{
object_166.key(key_167.as_str()).string(value_168.as_str());
}
}
object_166.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_terminate_target_instances_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::TerminateTargetInstancesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_169) = &input.source_server_i_ds {
let mut array_170 = object.key("sourceServerIDs").start_array();
for item_171 in var_169 {
{
array_170.value().string(item_171.as_str());
}
}
array_170.finish();
}
if let Some(var_172) = &input.tags {
#[allow(unused_mut)]
let mut object_173 = object.key("tags").start_object();
for (key_174, value_175) in var_172 {
{
object_173.key(key_174.as_str()).string(value_175.as_str());
}
}
object_173.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_unarchive_application_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UnarchiveApplicationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_176) = &input.application_id {
object.key("applicationID").string(var_176.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_unarchive_wave_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UnarchiveWaveInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_177) = &input.wave_id {
object.key("waveID").string(var_177.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_application_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateApplicationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_178) = &input.application_id {
object.key("applicationID").string(var_178.as_str());
}
if let Some(var_179) = &input.description {
object.key("description").string(var_179.as_str());
}
if let Some(var_180) = &input.name {
object.key("name").string(var_180.as_str());
}
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_181) = &input.boot_mode {
object.key("bootMode").string(var_181.as_str());
}
if let Some(var_182) = &input.copy_private_ip {
object.key("copyPrivateIp").boolean(*var_182);
}
if let Some(var_183) = &input.copy_tags {
object.key("copyTags").boolean(*var_183);
}
if let Some(var_184) = &input.enable_map_auto_tagging {
object.key("enableMapAutoTagging").boolean(*var_184);
}
if let Some(var_185) = &input.launch_disposition {
object.key("launchDisposition").string(var_185.as_str());
}
if let Some(var_186) = &input.licensing {
#[allow(unused_mut)]
let mut object_187 = object.key("licensing").start_object();
crate::json_ser::serialize_structure_crate_model_licensing(&mut object_187, var_186)?;
object_187.finish();
}
if let Some(var_188) = &input.map_auto_tagging_mpe_id {
object.key("mapAutoTaggingMpeID").string(var_188.as_str());
}
if let Some(var_189) = &input.name {
object.key("name").string(var_189.as_str());
}
if let Some(var_190) = &input.post_launch_actions {
#[allow(unused_mut)]
let mut object_191 = object.key("postLaunchActions").start_object();
crate::json_ser::serialize_structure_crate_model_post_launch_actions(
&mut object_191,
var_190,
)?;
object_191.finish();
}
if let Some(var_192) = &input.source_server_id {
object.key("sourceServerID").string(var_192.as_str());
}
if let Some(var_193) = &input.target_instance_type_right_sizing_method {
object
.key("targetInstanceTypeRightSizingMethod")
.string(var_193.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_launch_configuration_template_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateLaunchConfigurationTemplateInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_194) = &input.associate_public_ip_address {
object.key("associatePublicIpAddress").boolean(*var_194);
}
if let Some(var_195) = &input.boot_mode {
object.key("bootMode").string(var_195.as_str());
}
if let Some(var_196) = &input.copy_private_ip {
object.key("copyPrivateIp").boolean(*var_196);
}
if let Some(var_197) = &input.copy_tags {
object.key("copyTags").boolean(*var_197);
}
if let Some(var_198) = &input.enable_map_auto_tagging {
object.key("enableMapAutoTagging").boolean(*var_198);
}
if let Some(var_199) = &input.large_volume_conf {
#[allow(unused_mut)]
let mut object_200 = object.key("largeVolumeConf").start_object();
crate::json_ser::serialize_structure_crate_model_launch_template_disk_conf(
&mut object_200,
var_199,
)?;
object_200.finish();
}
if let Some(var_201) = &input.launch_configuration_template_id {
object
.key("launchConfigurationTemplateID")
.string(var_201.as_str());
}
if let Some(var_202) = &input.launch_disposition {
object.key("launchDisposition").string(var_202.as_str());
}
if let Some(var_203) = &input.licensing {
#[allow(unused_mut)]
let mut object_204 = object.key("licensing").start_object();
crate::json_ser::serialize_structure_crate_model_licensing(&mut object_204, var_203)?;
object_204.finish();
}
if let Some(var_205) = &input.map_auto_tagging_mpe_id {
object.key("mapAutoTaggingMpeID").string(var_205.as_str());
}
if let Some(var_206) = &input.post_launch_actions {
#[allow(unused_mut)]
let mut object_207 = object.key("postLaunchActions").start_object();
crate::json_ser::serialize_structure_crate_model_post_launch_actions(
&mut object_207,
var_206,
)?;
object_207.finish();
}
if let Some(var_208) = &input.small_volume_conf {
#[allow(unused_mut)]
let mut object_209 = object.key("smallVolumeConf").start_object();
crate::json_ser::serialize_structure_crate_model_launch_template_disk_conf(
&mut object_209,
var_208,
)?;
object_209.finish();
}
if input.small_volume_max_size != 0 {
object.key("smallVolumeMaxSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.small_volume_max_size).into()),
);
}
if let Some(var_210) = &input.target_instance_type_right_sizing_method {
object
.key("targetInstanceTypeRightSizingMethod")
.string(var_210.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_211) = &input.associate_default_security_group {
object
.key("associateDefaultSecurityGroup")
.boolean(*var_211);
}
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_212) = &input.create_public_ip {
object.key("createPublicIP").boolean(*var_212);
}
if let Some(var_213) = &input.data_plane_routing {
object.key("dataPlaneRouting").string(var_213.as_str());
}
if let Some(var_214) = &input.default_large_staging_disk_type {
object
.key("defaultLargeStagingDiskType")
.string(var_214.as_str());
}
if let Some(var_215) = &input.ebs_encryption {
object.key("ebsEncryption").string(var_215.as_str());
}
if let Some(var_216) = &input.ebs_encryption_key_arn {
object.key("ebsEncryptionKeyArn").string(var_216.as_str());
}
if let Some(var_217) = &input.name {
object.key("name").string(var_217.as_str());
}
if let Some(var_218) = &input.replicated_disks {
let mut array_219 = object.key("replicatedDisks").start_array();
for item_220 in var_218 {
{
#[allow(unused_mut)]
let mut object_221 = array_219.value().start_object();
crate::json_ser::serialize_structure_crate_model_replication_configuration_replicated_disk(&mut object_221, item_220)?;
object_221.finish();
}
}
array_219.finish();
}
if let Some(var_222) = &input.replication_server_instance_type {
object
.key("replicationServerInstanceType")
.string(var_222.as_str());
}
if let Some(var_223) = &input.replication_servers_security_groups_i_ds {
let mut array_224 = object
.key("replicationServersSecurityGroupsIDs")
.start_array();
for item_225 in var_223 {
{
array_224.value().string(item_225.as_str());
}
}
array_224.finish();
}
if let Some(var_226) = &input.source_server_id {
object.key("sourceServerID").string(var_226.as_str());
}
if let Some(var_227) = &input.staging_area_subnet_id {
object.key("stagingAreaSubnetId").string(var_227.as_str());
}
if let Some(var_228) = &input.staging_area_tags {
#[allow(unused_mut)]
let mut object_229 = object.key("stagingAreaTags").start_object();
for (key_230, value_231) in var_228 {
{
object_229.key(key_230.as_str()).string(value_231.as_str());
}
}
object_229.finish();
}
if let Some(var_232) = &input.use_dedicated_replication_server {
object
.key("useDedicatedReplicationServer")
.boolean(*var_232);
}
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_233) = &input.arn {
object.key("arn").string(var_233.as_str());
}
if let Some(var_234) = &input.associate_default_security_group {
object
.key("associateDefaultSecurityGroup")
.boolean(*var_234);
}
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_235) = &input.create_public_ip {
object.key("createPublicIP").boolean(*var_235);
}
if let Some(var_236) = &input.data_plane_routing {
object.key("dataPlaneRouting").string(var_236.as_str());
}
if let Some(var_237) = &input.default_large_staging_disk_type {
object
.key("defaultLargeStagingDiskType")
.string(var_237.as_str());
}
if let Some(var_238) = &input.ebs_encryption {
object.key("ebsEncryption").string(var_238.as_str());
}
if let Some(var_239) = &input.ebs_encryption_key_arn {
object.key("ebsEncryptionKeyArn").string(var_239.as_str());
}
if let Some(var_240) = &input.replication_configuration_template_id {
object
.key("replicationConfigurationTemplateID")
.string(var_240.as_str());
}
if let Some(var_241) = &input.replication_server_instance_type {
object
.key("replicationServerInstanceType")
.string(var_241.as_str());
}
if let Some(var_242) = &input.replication_servers_security_groups_i_ds {
let mut array_243 = object
.key("replicationServersSecurityGroupsIDs")
.start_array();
for item_244 in var_242 {
{
array_243.value().string(item_244.as_str());
}
}
array_243.finish();
}
if let Some(var_245) = &input.staging_area_subnet_id {
object.key("stagingAreaSubnetId").string(var_245.as_str());
}
if let Some(var_246) = &input.staging_area_tags {
#[allow(unused_mut)]
let mut object_247 = object.key("stagingAreaTags").start_object();
for (key_248, value_249) in var_246 {
{
object_247.key(key_248.as_str()).string(value_249.as_str());
}
}
object_247.finish();
}
if let Some(var_250) = &input.use_dedicated_replication_server {
object
.key("useDedicatedReplicationServer")
.boolean(*var_250);
}
Ok(())
}
pub fn serialize_structure_crate_input_update_source_server_replication_type_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateSourceServerReplicationTypeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_251) = &input.replication_type {
object.key("replicationType").string(var_251.as_str());
}
if let Some(var_252) = &input.source_server_id {
object.key("sourceServerID").string(var_252.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_wave_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateWaveInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_253) = &input.description {
object.key("description").string(var_253.as_str());
}
if let Some(var_254) = &input.name {
object.key("name").string(var_254.as_str());
}
if let Some(var_255) = &input.wave_id {
object.key("waveID").string(var_255.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_change_server_life_cycle_state_source_server_lifecycle(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ChangeServerLifeCycleStateSourceServerLifecycle,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_256) = &input.state {
object.key("state").string(var_256.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_launch_template_disk_conf(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LaunchTemplateDiskConf,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_257) = &input.volume_type {
object.key("volumeType").string(var_257.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()),
);
}
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_258) = &input.os_byol {
object.key("osByol").boolean(*var_258);
}
Ok(())
}
pub fn serialize_structure_crate_model_post_launch_actions(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PostLaunchActions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_259) = &input.deployment {
object.key("deployment").string(var_259.as_str());
}
if let Some(var_260) = &input.s3_log_bucket {
object.key("s3LogBucket").string(var_260.as_str());
}
if let Some(var_261) = &input.s3_output_key_prefix {
object.key("s3OutputKeyPrefix").string(var_261.as_str());
}
if let Some(var_262) = &input.cloud_watch_log_group_name {
object
.key("cloudWatchLogGroupName")
.string(var_262.as_str());
}
if let Some(var_263) = &input.ssm_documents {
let mut array_264 = object.key("ssmDocuments").start_array();
for item_265 in var_263 {
{
#[allow(unused_mut)]
let mut object_266 = array_264.value().start_object();
crate::json_ser::serialize_structure_crate_model_ssm_document(
&mut object_266,
item_265,
)?;
object_266.finish();
}
}
array_264.finish();
}
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_267) = &input.job_i_ds {
let mut array_268 = object.key("jobIDs").start_array();
for item_269 in var_267 {
{
array_268.value().string(item_269.as_str());
}
}
array_268.finish();
}
if let Some(var_270) = &input.from_date {
object.key("fromDate").string(var_270.as_str());
}
if let Some(var_271) = &input.to_date {
object.key("toDate").string(var_271.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_272) = &input.source_server_i_ds {
let mut array_273 = object.key("sourceServerIDs").start_array();
for item_274 in var_272 {
{
array_273.value().string(item_274.as_str());
}
}
array_273.finish();
}
if let Some(var_275) = &input.is_archived {
object.key("isArchived").boolean(*var_275);
}
if let Some(var_276) = &input.replication_types {
let mut array_277 = object.key("replicationTypes").start_array();
for item_278 in var_276 {
{
array_277.value().string(item_278.as_str());
}
}
array_277.finish();
}
if let Some(var_279) = &input.life_cycle_states {
let mut array_280 = object.key("lifeCycleStates").start_array();
for item_281 in var_279 {
{
array_280.value().string(item_281.as_str());
}
}
array_280.finish();
}
if let Some(var_282) = &input.application_i_ds {
let mut array_283 = object.key("applicationIDs").start_array();
for item_284 in var_282 {
{
array_283.value().string(item_284.as_str());
}
}
array_283.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_list_applications_request_filters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ListApplicationsRequestFilters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_285) = &input.application_i_ds {
let mut array_286 = object.key("applicationIDs").start_array();
for item_287 in var_285 {
{
array_286.value().string(item_287.as_str());
}
}
array_286.finish();
}
if let Some(var_288) = &input.is_archived {
object.key("isArchived").boolean(*var_288);
}
if let Some(var_289) = &input.wave_i_ds {
let mut array_290 = object.key("waveIDs").start_array();
for item_291 in var_289 {
{
array_290.value().string(item_291.as_str());
}
}
array_290.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_source_server_actions_request_filters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SourceServerActionsRequestFilters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_292) = &input.action_i_ds {
let mut array_293 = object.key("actionIDs").start_array();
for item_294 in var_292 {
{
array_293.value().string(item_294.as_str());
}
}
array_293.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_template_actions_request_filters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TemplateActionsRequestFilters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_295) = &input.action_i_ds {
let mut array_296 = object.key("actionIDs").start_array();
for item_297 in var_295 {
{
array_296.value().string(item_297.as_str());
}
}
array_296.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_list_waves_request_filters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ListWavesRequestFilters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_298) = &input.wave_i_ds {
let mut array_299 = object.key("waveIDs").start_array();
for item_300 in var_298 {
{
array_299.value().string(item_300.as_str());
}
}
array_299.finish();
}
if let Some(var_301) = &input.is_archived {
object.key("isArchived").boolean(*var_301);
}
Ok(())
}
pub fn serialize_structure_crate_model_ssm_parameter_store_parameter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SsmParameterStoreParameter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_302) = &input.parameter_type {
object.key("parameterType").string(var_302.as_str());
}
if let Some(var_303) = &input.parameter_name {
object.key("parameterName").string(var_303.as_str());
}
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_304) = &input.device_name {
object.key("deviceName").string(var_304.as_str());
}
if let Some(var_305) = &input.is_boot_disk {
object.key("isBootDisk").boolean(*var_305);
}
if let Some(var_306) = &input.staging_disk_type {
object.key("stagingDiskType").string(var_306.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()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_ssm_document(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SsmDocument,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_307) = &input.action_name {
object.key("actionName").string(var_307.as_str());
}
if let Some(var_308) = &input.ssm_document_name {
object.key("ssmDocumentName").string(var_308.as_str());
}
if input.timeout_seconds != 0 {
object.key("timeoutSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.timeout_seconds).into()),
);
}
if let Some(var_309) = &input.must_succeed_for_cutover {
object.key("mustSucceedForCutover").boolean(*var_309);
}
if let Some(var_310) = &input.parameters {
#[allow(unused_mut)]
let mut object_311 = object.key("parameters").start_object();
for (key_312, value_313) in var_310 {
{
let mut array_314 = object_311.key(key_312.as_str()).start_array();
for item_315 in value_313 {
{
#[allow(unused_mut)]
let mut object_316 = array_314.value().start_object();
crate::json_ser::serialize_structure_crate_model_ssm_parameter_store_parameter(&mut object_316, item_315)?;
object_316.finish();
}
}
array_314.finish();
}
}
object_311.finish();
}
Ok(())
}