pub fn serialize_structure_crate_input_create_app_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateAppInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.name {
object.key("name").string(var_1.as_str());
}
if let Some(var_2) = &input.description {
object.key("description").string(var_2.as_str());
}
if let Some(var_3) = &input.role_name {
object.key("roleName").string(var_3.as_str());
}
if let Some(var_4) = &input.client_token {
object.key("clientToken").string(var_4.as_str());
}
if let Some(var_5) = &input.server_groups {
let mut array_6 = object.key("serverGroups").start_array();
for item_7 in var_5 {
{
#[allow(unused_mut)]
let mut object_8 = array_6.value().start_object();
crate::json_ser::serialize_structure_crate_model_server_group(
&mut object_8,
item_7,
)?;
object_8.finish();
}
}
array_6.finish();
}
if let Some(var_9) = &input.tags {
let mut array_10 = object.key("tags").start_array();
for item_11 in var_9 {
{
#[allow(unused_mut)]
let mut object_12 = array_10.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_12, item_11)?;
object_12.finish();
}
}
array_10.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_replication_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateReplicationJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_13) = &input.server_id {
object.key("serverId").string(var_13.as_str());
}
if let Some(var_14) = &input.seed_replication_time {
object
.key("seedReplicationTime")
.date_time(var_14, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_15) = &input.frequency {
object.key("frequency").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_15).into()),
);
}
if let Some(var_16) = &input.run_once {
object.key("runOnce").boolean(*var_16);
}
if let Some(var_17) = &input.license_type {
object.key("licenseType").string(var_17.as_str());
}
if let Some(var_18) = &input.role_name {
object.key("roleName").string(var_18.as_str());
}
if let Some(var_19) = &input.description {
object.key("description").string(var_19.as_str());
}
if let Some(var_20) = &input.number_of_recent_amis_to_keep {
object.key("numberOfRecentAmisToKeep").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_20).into()),
);
}
if let Some(var_21) = &input.encrypted {
object.key("encrypted").boolean(*var_21);
}
if let Some(var_22) = &input.kms_key_id {
object.key("kmsKeyId").string(var_22.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_app_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteAppInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_23) = &input.app_id {
object.key("appId").string(var_23.as_str());
}
if let Some(var_24) = &input.force_stop_app_replication {
object.key("forceStopAppReplication").boolean(*var_24);
}
if let Some(var_25) = &input.force_terminate_app {
object.key("forceTerminateApp").boolean(*var_25);
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_app_launch_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteAppLaunchConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_26) = &input.app_id {
object.key("appId").string(var_26.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_app_replication_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteAppReplicationConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_27) = &input.app_id {
object.key("appId").string(var_27.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_app_validation_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteAppValidationConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_28) = &input.app_id {
object.key("appId").string(var_28.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_replication_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteReplicationJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_29) = &input.replication_job_id {
object.key("replicationJobId").string(var_29.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_disassociate_connector_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DisassociateConnectorInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_30) = &input.connector_id {
object.key("connectorId").string(var_30.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_generate_change_set_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GenerateChangeSetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_31) = &input.app_id {
object.key("appId").string(var_31.as_str());
}
if let Some(var_32) = &input.changeset_format {
object.key("changesetFormat").string(var_32.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_generate_template_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GenerateTemplateInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_33) = &input.app_id {
object.key("appId").string(var_33.as_str());
}
if let Some(var_34) = &input.template_format {
object.key("templateFormat").string(var_34.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_app_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetAppInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_35) = &input.app_id {
object.key("appId").string(var_35.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_app_launch_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetAppLaunchConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_36) = &input.app_id {
object.key("appId").string(var_36.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_app_replication_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetAppReplicationConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_37) = &input.app_id {
object.key("appId").string(var_37.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_app_validation_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetAppValidationConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_38) = &input.app_id {
object.key("appId").string(var_38.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_app_validation_output_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetAppValidationOutputInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_39) = &input.app_id {
object.key("appId").string(var_39.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_connectors_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetConnectorsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_40) = &input.next_token {
object.key("nextToken").string(var_40.as_str());
}
if let Some(var_41) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_41).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_get_replication_jobs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetReplicationJobsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_42) = &input.replication_job_id {
object.key("replicationJobId").string(var_42.as_str());
}
if let Some(var_43) = &input.next_token {
object.key("nextToken").string(var_43.as_str());
}
if let Some(var_44) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_44).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_get_replication_runs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetReplicationRunsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_45) = &input.replication_job_id {
object.key("replicationJobId").string(var_45.as_str());
}
if let Some(var_46) = &input.next_token {
object.key("nextToken").string(var_46.as_str());
}
if let Some(var_47) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_47).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_get_servers_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetServersInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_48) = &input.next_token {
object.key("nextToken").string(var_48.as_str());
}
if let Some(var_49) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_49).into()),
);
}
if let Some(var_50) = &input.vm_server_address_list {
let mut array_51 = object.key("vmServerAddressList").start_array();
for item_52 in var_50 {
{
#[allow(unused_mut)]
let mut object_53 = array_51.value().start_object();
crate::json_ser::serialize_structure_crate_model_vm_server_address(
&mut object_53,
item_52,
)?;
object_53.finish();
}
}
array_51.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_import_app_catalog_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ImportAppCatalogInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_54) = &input.role_name {
object.key("roleName").string(var_54.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_launch_app_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::LaunchAppInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_55) = &input.app_id {
object.key("appId").string(var_55.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_apps_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListAppsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_56) = &input.app_ids {
let mut array_57 = object.key("appIds").start_array();
for item_58 in var_56 {
{
array_57.value().string(item_58.as_str());
}
}
array_57.finish();
}
if let Some(var_59) = &input.next_token {
object.key("nextToken").string(var_59.as_str());
}
if let Some(var_60) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_60).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_notify_app_validation_output_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::NotifyAppValidationOutputInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_61) = &input.app_id {
object.key("appId").string(var_61.as_str());
}
if let Some(var_62) = &input.notification_context {
#[allow(unused_mut)]
let mut object_63 = object.key("notificationContext").start_object();
crate::json_ser::serialize_structure_crate_model_notification_context(
&mut object_63,
var_62,
)?;
object_63.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_put_app_launch_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutAppLaunchConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_64) = &input.app_id {
object.key("appId").string(var_64.as_str());
}
if let Some(var_65) = &input.role_name {
object.key("roleName").string(var_65.as_str());
}
if let Some(var_66) = &input.auto_launch {
object.key("autoLaunch").boolean(*var_66);
}
if let Some(var_67) = &input.server_group_launch_configurations {
let mut array_68 = object.key("serverGroupLaunchConfigurations").start_array();
for item_69 in var_67 {
{
#[allow(unused_mut)]
let mut object_70 = array_68.value().start_object();
crate::json_ser::serialize_structure_crate_model_server_group_launch_configuration(
&mut object_70,
item_69,
)?;
object_70.finish();
}
}
array_68.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_put_app_replication_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutAppReplicationConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_71) = &input.app_id {
object.key("appId").string(var_71.as_str());
}
if let Some(var_72) = &input.server_group_replication_configurations {
let mut array_73 = object
.key("serverGroupReplicationConfigurations")
.start_array();
for item_74 in var_72 {
{
#[allow(unused_mut)]
let mut object_75 = array_73.value().start_object();
crate::json_ser::serialize_structure_crate_model_server_group_replication_configuration(&mut object_75, item_74)?;
object_75.finish();
}
}
array_73.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_put_app_validation_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutAppValidationConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_76) = &input.app_id {
object.key("appId").string(var_76.as_str());
}
if let Some(var_77) = &input.app_validation_configurations {
let mut array_78 = object.key("appValidationConfigurations").start_array();
for item_79 in var_77 {
{
#[allow(unused_mut)]
let mut object_80 = array_78.value().start_object();
crate::json_ser::serialize_structure_crate_model_app_validation_configuration(
&mut object_80,
item_79,
)?;
object_80.finish();
}
}
array_78.finish();
}
if let Some(var_81) = &input.server_group_validation_configurations {
let mut array_82 = object
.key("serverGroupValidationConfigurations")
.start_array();
for item_83 in var_81 {
{
#[allow(unused_mut)]
let mut object_84 = array_82.value().start_object();
crate::json_ser::serialize_structure_crate_model_server_group_validation_configuration(&mut object_84, item_83)?;
object_84.finish();
}
}
array_82.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_start_app_replication_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartAppReplicationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_85) = &input.app_id {
object.key("appId").string(var_85.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_start_on_demand_app_replication_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartOnDemandAppReplicationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_86) = &input.app_id {
object.key("appId").string(var_86.as_str());
}
if let Some(var_87) = &input.description {
object.key("description").string(var_87.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_start_on_demand_replication_run_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartOnDemandReplicationRunInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_88) = &input.replication_job_id {
object.key("replicationJobId").string(var_88.as_str());
}
if let Some(var_89) = &input.description {
object.key("description").string(var_89.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_stop_app_replication_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StopAppReplicationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_90) = &input.app_id {
object.key("appId").string(var_90.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_terminate_app_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::TerminateAppInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_91) = &input.app_id {
object.key("appId").string(var_91.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_app_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateAppInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_92) = &input.app_id {
object.key("appId").string(var_92.as_str());
}
if let Some(var_93) = &input.name {
object.key("name").string(var_93.as_str());
}
if let Some(var_94) = &input.description {
object.key("description").string(var_94.as_str());
}
if let Some(var_95) = &input.role_name {
object.key("roleName").string(var_95.as_str());
}
if let Some(var_96) = &input.server_groups {
let mut array_97 = object.key("serverGroups").start_array();
for item_98 in var_96 {
{
#[allow(unused_mut)]
let mut object_99 = array_97.value().start_object();
crate::json_ser::serialize_structure_crate_model_server_group(
&mut object_99,
item_98,
)?;
object_99.finish();
}
}
array_97.finish();
}
if let Some(var_100) = &input.tags {
let mut array_101 = object.key("tags").start_array();
for item_102 in var_100 {
{
#[allow(unused_mut)]
let mut object_103 = array_101.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_103, item_102)?;
object_103.finish();
}
}
array_101.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_replication_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateReplicationJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_104) = &input.replication_job_id {
object.key("replicationJobId").string(var_104.as_str());
}
if let Some(var_105) = &input.frequency {
object.key("frequency").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_105).into()),
);
}
if let Some(var_106) = &input.next_replication_run_start_time {
object
.key("nextReplicationRunStartTime")
.date_time(var_106, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_107) = &input.license_type {
object.key("licenseType").string(var_107.as_str());
}
if let Some(var_108) = &input.role_name {
object.key("roleName").string(var_108.as_str());
}
if let Some(var_109) = &input.description {
object.key("description").string(var_109.as_str());
}
if let Some(var_110) = &input.number_of_recent_amis_to_keep {
object.key("numberOfRecentAmisToKeep").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_110).into()),
);
}
if let Some(var_111) = &input.encrypted {
object.key("encrypted").boolean(*var_111);
}
if let Some(var_112) = &input.kms_key_id {
object.key("kmsKeyId").string(var_112.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_server_group(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ServerGroup,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_113) = &input.server_group_id {
object.key("serverGroupId").string(var_113.as_str());
}
if let Some(var_114) = &input.name {
object.key("name").string(var_114.as_str());
}
if let Some(var_115) = &input.server_list {
let mut array_116 = object.key("serverList").start_array();
for item_117 in var_115 {
{
#[allow(unused_mut)]
let mut object_118 = array_116.value().start_object();
crate::json_ser::serialize_structure_crate_model_server(&mut object_118, item_117)?;
object_118.finish();
}
}
array_116.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_119) = &input.key {
object.key("key").string(var_119.as_str());
}
if let Some(var_120) = &input.value {
object.key("value").string(var_120.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_vm_server_address(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::VmServerAddress,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_121) = &input.vm_manager_id {
object.key("vmManagerId").string(var_121.as_str());
}
if let Some(var_122) = &input.vm_id {
object.key("vmId").string(var_122.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_notification_context(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::NotificationContext,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_123) = &input.validation_id {
object.key("validationId").string(var_123.as_str());
}
if let Some(var_124) = &input.status {
object.key("status").string(var_124.as_str());
}
if let Some(var_125) = &input.status_message {
object.key("statusMessage").string(var_125.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_server_group_launch_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ServerGroupLaunchConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_126) = &input.server_group_id {
object.key("serverGroupId").string(var_126.as_str());
}
if let Some(var_127) = &input.launch_order {
object.key("launchOrder").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_127).into()),
);
}
if let Some(var_128) = &input.server_launch_configurations {
let mut array_129 = object.key("serverLaunchConfigurations").start_array();
for item_130 in var_128 {
{
#[allow(unused_mut)]
let mut object_131 = array_129.value().start_object();
crate::json_ser::serialize_structure_crate_model_server_launch_configuration(
&mut object_131,
item_130,
)?;
object_131.finish();
}
}
array_129.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_server_group_replication_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ServerGroupReplicationConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_132) = &input.server_group_id {
object.key("serverGroupId").string(var_132.as_str());
}
if let Some(var_133) = &input.server_replication_configurations {
let mut array_134 = object.key("serverReplicationConfigurations").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_server_replication_configuration(
&mut object_136,
item_135,
)?;
object_136.finish();
}
}
array_134.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_app_validation_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AppValidationConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_137) = &input.validation_id {
object.key("validationId").string(var_137.as_str());
}
if let Some(var_138) = &input.name {
object.key("name").string(var_138.as_str());
}
if let Some(var_139) = &input.app_validation_strategy {
object.key("appValidationStrategy").string(var_139.as_str());
}
if let Some(var_140) = &input.ssm_validation_parameters {
#[allow(unused_mut)]
let mut object_141 = object.key("ssmValidationParameters").start_object();
crate::json_ser::serialize_structure_crate_model_ssm_validation_parameters(
&mut object_141,
var_140,
)?;
object_141.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_server_group_validation_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ServerGroupValidationConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_142) = &input.server_group_id {
object.key("serverGroupId").string(var_142.as_str());
}
if let Some(var_143) = &input.server_validation_configurations {
let mut array_144 = object.key("serverValidationConfigurations").start_array();
for item_145 in var_143 {
{
#[allow(unused_mut)]
let mut object_146 = array_144.value().start_object();
crate::json_ser::serialize_structure_crate_model_server_validation_configuration(
&mut object_146,
item_145,
)?;
object_146.finish();
}
}
array_144.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_server(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Server,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_147) = &input.server_id {
object.key("serverId").string(var_147.as_str());
}
if let Some(var_148) = &input.server_type {
object.key("serverType").string(var_148.as_str());
}
if let Some(var_149) = &input.vm_server {
#[allow(unused_mut)]
let mut object_150 = object.key("vmServer").start_object();
crate::json_ser::serialize_structure_crate_model_vm_server(&mut object_150, var_149)?;
object_150.finish();
}
if let Some(var_151) = &input.replication_job_id {
object.key("replicationJobId").string(var_151.as_str());
}
if let Some(var_152) = &input.replication_job_terminated {
object.key("replicationJobTerminated").boolean(*var_152);
}
Ok(())
}
pub fn serialize_structure_crate_model_server_launch_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ServerLaunchConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_153) = &input.server {
#[allow(unused_mut)]
let mut object_154 = object.key("server").start_object();
crate::json_ser::serialize_structure_crate_model_server(&mut object_154, var_153)?;
object_154.finish();
}
if let Some(var_155) = &input.logical_id {
object.key("logicalId").string(var_155.as_str());
}
if let Some(var_156) = &input.vpc {
object.key("vpc").string(var_156.as_str());
}
if let Some(var_157) = &input.subnet {
object.key("subnet").string(var_157.as_str());
}
if let Some(var_158) = &input.security_group {
object.key("securityGroup").string(var_158.as_str());
}
if let Some(var_159) = &input.ec2_key_name {
object.key("ec2KeyName").string(var_159.as_str());
}
if let Some(var_160) = &input.user_data {
#[allow(unused_mut)]
let mut object_161 = object.key("userData").start_object();
crate::json_ser::serialize_structure_crate_model_user_data(&mut object_161, var_160)?;
object_161.finish();
}
if let Some(var_162) = &input.instance_type {
object.key("instanceType").string(var_162.as_str());
}
if let Some(var_163) = &input.associate_public_ip_address {
object.key("associatePublicIpAddress").boolean(*var_163);
}
if let Some(var_164) = &input.iam_instance_profile_name {
object
.key("iamInstanceProfileName")
.string(var_164.as_str());
}
if let Some(var_165) = &input.configure_script {
#[allow(unused_mut)]
let mut object_166 = object.key("configureScript").start_object();
crate::json_ser::serialize_structure_crate_model_s3_location(&mut object_166, var_165)?;
object_166.finish();
}
if let Some(var_167) = &input.configure_script_type {
object.key("configureScriptType").string(var_167.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_server_replication_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ServerReplicationConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_168) = &input.server {
#[allow(unused_mut)]
let mut object_169 = object.key("server").start_object();
crate::json_ser::serialize_structure_crate_model_server(&mut object_169, var_168)?;
object_169.finish();
}
if let Some(var_170) = &input.server_replication_parameters {
#[allow(unused_mut)]
let mut object_171 = object.key("serverReplicationParameters").start_object();
crate::json_ser::serialize_structure_crate_model_server_replication_parameters(
&mut object_171,
var_170,
)?;
object_171.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_ssm_validation_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SsmValidationParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_172) = &input.source {
#[allow(unused_mut)]
let mut object_173 = object.key("source").start_object();
crate::json_ser::serialize_structure_crate_model_source(&mut object_173, var_172)?;
object_173.finish();
}
if let Some(var_174) = &input.instance_id {
object.key("instanceId").string(var_174.as_str());
}
if let Some(var_175) = &input.script_type {
object.key("scriptType").string(var_175.as_str());
}
if let Some(var_176) = &input.command {
object.key("command").string(var_176.as_str());
}
if input.execution_timeout_seconds != 0 {
object.key("executionTimeoutSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.execution_timeout_seconds).into()),
);
}
if let Some(var_177) = &input.output_s3_bucket_name {
object.key("outputS3BucketName").string(var_177.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_server_validation_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ServerValidationConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_178) = &input.server {
#[allow(unused_mut)]
let mut object_179 = object.key("server").start_object();
crate::json_ser::serialize_structure_crate_model_server(&mut object_179, var_178)?;
object_179.finish();
}
if let Some(var_180) = &input.validation_id {
object.key("validationId").string(var_180.as_str());
}
if let Some(var_181) = &input.name {
object.key("name").string(var_181.as_str());
}
if let Some(var_182) = &input.server_validation_strategy {
object
.key("serverValidationStrategy")
.string(var_182.as_str());
}
if let Some(var_183) = &input.user_data_validation_parameters {
#[allow(unused_mut)]
let mut object_184 = object.key("userDataValidationParameters").start_object();
crate::json_ser::serialize_structure_crate_model_user_data_validation_parameters(
&mut object_184,
var_183,
)?;
object_184.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_vm_server(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::VmServer,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_185) = &input.vm_server_address {
#[allow(unused_mut)]
let mut object_186 = object.key("vmServerAddress").start_object();
crate::json_ser::serialize_structure_crate_model_vm_server_address(
&mut object_186,
var_185,
)?;
object_186.finish();
}
if let Some(var_187) = &input.vm_name {
object.key("vmName").string(var_187.as_str());
}
if let Some(var_188) = &input.vm_manager_name {
object.key("vmManagerName").string(var_188.as_str());
}
if let Some(var_189) = &input.vm_manager_type {
object.key("vmManagerType").string(var_189.as_str());
}
if let Some(var_190) = &input.vm_path {
object.key("vmPath").string(var_190.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_user_data(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UserData,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_191) = &input.s3_location {
#[allow(unused_mut)]
let mut object_192 = object.key("s3Location").start_object();
crate::json_ser::serialize_structure_crate_model_s3_location(&mut object_192, var_191)?;
object_192.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_s3_location(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::S3Location,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_193) = &input.bucket {
object.key("bucket").string(var_193.as_str());
}
if let Some(var_194) = &input.key {
object.key("key").string(var_194.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_server_replication_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ServerReplicationParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_195) = &input.seed_time {
object
.key("seedTime")
.date_time(var_195, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_196) = &input.frequency {
object.key("frequency").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_196).into()),
);
}
if let Some(var_197) = &input.run_once {
object.key("runOnce").boolean(*var_197);
}
if let Some(var_198) = &input.license_type {
object.key("licenseType").string(var_198.as_str());
}
if let Some(var_199) = &input.number_of_recent_amis_to_keep {
object.key("numberOfRecentAmisToKeep").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_199).into()),
);
}
if let Some(var_200) = &input.encrypted {
object.key("encrypted").boolean(*var_200);
}
if let Some(var_201) = &input.kms_key_id {
object.key("kmsKeyId").string(var_201.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_source(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Source,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_202) = &input.s3_location {
#[allow(unused_mut)]
let mut object_203 = object.key("s3Location").start_object();
crate::json_ser::serialize_structure_crate_model_s3_location(&mut object_203, var_202)?;
object_203.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_user_data_validation_parameters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UserDataValidationParameters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_204) = &input.source {
#[allow(unused_mut)]
let mut object_205 = object.key("source").start_object();
crate::json_ser::serialize_structure_crate_model_source(&mut object_205, var_204)?;
object_205.finish();
}
if let Some(var_206) = &input.script_type {
object.key("scriptType").string(var_206.as_str());
}
Ok(())
}