pub fn serialize_structure_crate_input_add_tags_to_on_premises_instances_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AddTagsToOnPremisesInstancesInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_1) = &input.tags {
let mut array_2 = object.key("tags").start_array();
for item_3 in var_1 {
{
let mut object_4 = array_2.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_4, item_3)?;
object_4.finish();
}
}
array_2.finish();
}
if let Some(var_5) = &input.instance_names {
let mut array_6 = object.key("instanceNames").start_array();
for item_7 in var_5 {
{
array_6.value().string(item_7);
}
}
array_6.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_batch_get_application_revisions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchGetApplicationRevisionsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_8) = &input.application_name {
object.key("applicationName").string(var_8);
}
if let Some(var_9) = &input.revisions {
let mut array_10 = object.key("revisions").start_array();
for item_11 in var_9 {
{
let mut object_12 = array_10.value().start_object();
crate::json_ser::serialize_structure_crate_model_revision_location(
&mut object_12,
item_11,
)?;
object_12.finish();
}
}
array_10.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_batch_get_applications_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchGetApplicationsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_13) = &input.application_names {
let mut array_14 = object.key("applicationNames").start_array();
for item_15 in var_13 {
{
array_14.value().string(item_15);
}
}
array_14.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_batch_get_deployment_groups_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchGetDeploymentGroupsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_16) = &input.application_name {
object.key("applicationName").string(var_16);
}
if let Some(var_17) = &input.deployment_group_names {
let mut array_18 = object.key("deploymentGroupNames").start_array();
for item_19 in var_17 {
{
array_18.value().string(item_19);
}
}
array_18.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_batch_get_deployment_instances_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchGetDeploymentInstancesInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_20) = &input.deployment_id {
object.key("deploymentId").string(var_20);
}
if let Some(var_21) = &input.instance_ids {
let mut array_22 = object.key("instanceIds").start_array();
for item_23 in var_21 {
{
array_22.value().string(item_23);
}
}
array_22.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_batch_get_deployments_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchGetDeploymentsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_24) = &input.deployment_ids {
let mut array_25 = object.key("deploymentIds").start_array();
for item_26 in var_24 {
{
array_25.value().string(item_26);
}
}
array_25.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_batch_get_deployment_targets_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchGetDeploymentTargetsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_27) = &input.deployment_id {
object.key("deploymentId").string(var_27);
}
if let Some(var_28) = &input.target_ids {
let mut array_29 = object.key("targetIds").start_array();
for item_30 in var_28 {
{
array_29.value().string(item_30);
}
}
array_29.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_batch_get_on_premises_instances_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchGetOnPremisesInstancesInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_31) = &input.instance_names {
let mut array_32 = object.key("instanceNames").start_array();
for item_33 in var_31 {
{
array_32.value().string(item_33);
}
}
array_32.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_continue_deployment_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ContinueDeploymentInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_34) = &input.deployment_id {
object.key("deploymentId").string(var_34);
}
if let Some(var_35) = &input.deployment_wait_type {
object.key("deploymentWaitType").string(var_35.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::SerializationError> {
if let Some(var_36) = &input.application_name {
object.key("applicationName").string(var_36);
}
if let Some(var_37) = &input.compute_platform {
object.key("computePlatform").string(var_37.as_str());
}
if let Some(var_38) = &input.tags {
let mut array_39 = object.key("tags").start_array();
for item_40 in var_38 {
{
let mut object_41 = array_39.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_41, item_40)?;
object_41.finish();
}
}
array_39.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_deployment_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateDeploymentInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_42) = &input.application_name {
object.key("applicationName").string(var_42);
}
if let Some(var_43) = &input.deployment_group_name {
object.key("deploymentGroupName").string(var_43);
}
if let Some(var_44) = &input.revision {
let mut object_45 = object.key("revision").start_object();
crate::json_ser::serialize_structure_crate_model_revision_location(&mut object_45, var_44)?;
object_45.finish();
}
if let Some(var_46) = &input.deployment_config_name {
object.key("deploymentConfigName").string(var_46);
}
if let Some(var_47) = &input.description {
object.key("description").string(var_47);
}
if input.ignore_application_stop_failures {
object
.key("ignoreApplicationStopFailures")
.boolean(input.ignore_application_stop_failures);
}
if let Some(var_48) = &input.target_instances {
let mut object_49 = object.key("targetInstances").start_object();
crate::json_ser::serialize_structure_crate_model_target_instances(&mut object_49, var_48)?;
object_49.finish();
}
if let Some(var_50) = &input.auto_rollback_configuration {
let mut object_51 = object.key("autoRollbackConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_auto_rollback_configuration(
&mut object_51,
var_50,
)?;
object_51.finish();
}
if input.update_outdated_instances_only {
object
.key("updateOutdatedInstancesOnly")
.boolean(input.update_outdated_instances_only);
}
if let Some(var_52) = &input.file_exists_behavior {
object.key("fileExistsBehavior").string(var_52.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_deployment_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateDeploymentConfigInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_53) = &input.deployment_config_name {
object.key("deploymentConfigName").string(var_53);
}
if let Some(var_54) = &input.minimum_healthy_hosts {
let mut object_55 = object.key("minimumHealthyHosts").start_object();
crate::json_ser::serialize_structure_crate_model_minimum_healthy_hosts(
&mut object_55,
var_54,
)?;
object_55.finish();
}
if let Some(var_56) = &input.traffic_routing_config {
let mut object_57 = object.key("trafficRoutingConfig").start_object();
crate::json_ser::serialize_structure_crate_model_traffic_routing_config(
&mut object_57,
var_56,
)?;
object_57.finish();
}
if let Some(var_58) = &input.compute_platform {
object.key("computePlatform").string(var_58.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_deployment_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateDeploymentGroupInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_59) = &input.application_name {
object.key("applicationName").string(var_59);
}
if let Some(var_60) = &input.deployment_group_name {
object.key("deploymentGroupName").string(var_60);
}
if let Some(var_61) = &input.deployment_config_name {
object.key("deploymentConfigName").string(var_61);
}
if let Some(var_62) = &input.ec2_tag_filters {
let mut array_63 = object.key("ec2TagFilters").start_array();
for item_64 in var_62 {
{
let mut object_65 = array_63.value().start_object();
crate::json_ser::serialize_structure_crate_model_ec2_tag_filter(
&mut object_65,
item_64,
)?;
object_65.finish();
}
}
array_63.finish();
}
if let Some(var_66) = &input.on_premises_instance_tag_filters {
let mut array_67 = object.key("onPremisesInstanceTagFilters").start_array();
for item_68 in var_66 {
{
let mut object_69 = array_67.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag_filter(
&mut object_69,
item_68,
)?;
object_69.finish();
}
}
array_67.finish();
}
if let Some(var_70) = &input.auto_scaling_groups {
let mut array_71 = object.key("autoScalingGroups").start_array();
for item_72 in var_70 {
{
array_71.value().string(item_72);
}
}
array_71.finish();
}
if let Some(var_73) = &input.service_role_arn {
object.key("serviceRoleArn").string(var_73);
}
if let Some(var_74) = &input.trigger_configurations {
let mut array_75 = object.key("triggerConfigurations").start_array();
for item_76 in var_74 {
{
let mut object_77 = array_75.value().start_object();
crate::json_ser::serialize_structure_crate_model_trigger_config(
&mut object_77,
item_76,
)?;
object_77.finish();
}
}
array_75.finish();
}
if let Some(var_78) = &input.alarm_configuration {
let mut object_79 = object.key("alarmConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_alarm_configuration(
&mut object_79,
var_78,
)?;
object_79.finish();
}
if let Some(var_80) = &input.auto_rollback_configuration {
let mut object_81 = object.key("autoRollbackConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_auto_rollback_configuration(
&mut object_81,
var_80,
)?;
object_81.finish();
}
if let Some(var_82) = &input.outdated_instances_strategy {
object
.key("outdatedInstancesStrategy")
.string(var_82.as_str());
}
if let Some(var_83) = &input.deployment_style {
let mut object_84 = object.key("deploymentStyle").start_object();
crate::json_ser::serialize_structure_crate_model_deployment_style(&mut object_84, var_83)?;
object_84.finish();
}
if let Some(var_85) = &input.blue_green_deployment_configuration {
let mut object_86 = object
.key("blueGreenDeploymentConfiguration")
.start_object();
crate::json_ser::serialize_structure_crate_model_blue_green_deployment_configuration(
&mut object_86,
var_85,
)?;
object_86.finish();
}
if let Some(var_87) = &input.load_balancer_info {
let mut object_88 = object.key("loadBalancerInfo").start_object();
crate::json_ser::serialize_structure_crate_model_load_balancer_info(
&mut object_88,
var_87,
)?;
object_88.finish();
}
if let Some(var_89) = &input.ec2_tag_set {
let mut object_90 = object.key("ec2TagSet").start_object();
crate::json_ser::serialize_structure_crate_model_ec2_tag_set(&mut object_90, var_89)?;
object_90.finish();
}
if let Some(var_91) = &input.ecs_services {
let mut array_92 = object.key("ecsServices").start_array();
for item_93 in var_91 {
{
let mut object_94 = array_92.value().start_object();
crate::json_ser::serialize_structure_crate_model_ecs_service(
&mut object_94,
item_93,
)?;
object_94.finish();
}
}
array_92.finish();
}
if let Some(var_95) = &input.on_premises_tag_set {
let mut object_96 = object.key("onPremisesTagSet").start_object();
crate::json_ser::serialize_structure_crate_model_on_premises_tag_set(
&mut object_96,
var_95,
)?;
object_96.finish();
}
if let Some(var_97) = &input.tags {
let mut array_98 = object.key("tags").start_array();
for item_99 in var_97 {
{
let mut object_100 = array_98.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_100, item_99)?;
object_100.finish();
}
}
array_98.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::SerializationError> {
if let Some(var_101) = &input.application_name {
object.key("applicationName").string(var_101);
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_deployment_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteDeploymentConfigInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_102) = &input.deployment_config_name {
object.key("deploymentConfigName").string(var_102);
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_deployment_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteDeploymentGroupInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_103) = &input.application_name {
object.key("applicationName").string(var_103);
}
if let Some(var_104) = &input.deployment_group_name {
object.key("deploymentGroupName").string(var_104);
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_git_hub_account_token_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteGitHubAccountTokenInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_105) = &input.token_name {
object.key("tokenName").string(var_105);
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_resources_by_external_id_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteResourcesByExternalIdInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_106) = &input.external_id {
object.key("externalId").string(var_106);
}
Ok(())
}
pub fn serialize_structure_crate_input_deregister_on_premises_instance_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeregisterOnPremisesInstanceInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_107) = &input.instance_name {
object.key("instanceName").string(var_107);
}
Ok(())
}
pub fn serialize_structure_crate_input_get_application_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetApplicationInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_108) = &input.application_name {
object.key("applicationName").string(var_108);
}
Ok(())
}
pub fn serialize_structure_crate_input_get_application_revision_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetApplicationRevisionInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_109) = &input.application_name {
object.key("applicationName").string(var_109);
}
if let Some(var_110) = &input.revision {
let mut object_111 = object.key("revision").start_object();
crate::json_ser::serialize_structure_crate_model_revision_location(
&mut object_111,
var_110,
)?;
object_111.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_get_deployment_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetDeploymentInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_112) = &input.deployment_id {
object.key("deploymentId").string(var_112);
}
Ok(())
}
pub fn serialize_structure_crate_input_get_deployment_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetDeploymentConfigInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_113) = &input.deployment_config_name {
object.key("deploymentConfigName").string(var_113);
}
Ok(())
}
pub fn serialize_structure_crate_input_get_deployment_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetDeploymentGroupInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_114) = &input.application_name {
object.key("applicationName").string(var_114);
}
if let Some(var_115) = &input.deployment_group_name {
object.key("deploymentGroupName").string(var_115);
}
Ok(())
}
pub fn serialize_structure_crate_input_get_deployment_instance_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetDeploymentInstanceInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_116) = &input.deployment_id {
object.key("deploymentId").string(var_116);
}
if let Some(var_117) = &input.instance_id {
object.key("instanceId").string(var_117);
}
Ok(())
}
pub fn serialize_structure_crate_input_get_deployment_target_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetDeploymentTargetInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_118) = &input.deployment_id {
object.key("deploymentId").string(var_118);
}
if let Some(var_119) = &input.target_id {
object.key("targetId").string(var_119);
}
Ok(())
}
pub fn serialize_structure_crate_input_get_on_premises_instance_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetOnPremisesInstanceInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_120) = &input.instance_name {
object.key("instanceName").string(var_120);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_application_revisions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListApplicationRevisionsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_121) = &input.application_name {
object.key("applicationName").string(var_121);
}
if let Some(var_122) = &input.sort_by {
object.key("sortBy").string(var_122.as_str());
}
if let Some(var_123) = &input.sort_order {
object.key("sortOrder").string(var_123.as_str());
}
if let Some(var_124) = &input.s3_bucket {
object.key("s3Bucket").string(var_124);
}
if let Some(var_125) = &input.s3_key_prefix {
object.key("s3KeyPrefix").string(var_125);
}
if let Some(var_126) = &input.deployed {
object.key("deployed").string(var_126.as_str());
}
if let Some(var_127) = &input.next_token {
object.key("nextToken").string(var_127);
}
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::SerializationError> {
if let Some(var_128) = &input.next_token {
object.key("nextToken").string(var_128);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_deployment_configs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListDeploymentConfigsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_129) = &input.next_token {
object.key("nextToken").string(var_129);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_deployment_groups_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListDeploymentGroupsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_130) = &input.application_name {
object.key("applicationName").string(var_130);
}
if let Some(var_131) = &input.next_token {
object.key("nextToken").string(var_131);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_deployment_instances_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListDeploymentInstancesInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_132) = &input.deployment_id {
object.key("deploymentId").string(var_132);
}
if let Some(var_133) = &input.next_token {
object.key("nextToken").string(var_133);
}
if let Some(var_134) = &input.instance_status_filter {
let mut array_135 = object.key("instanceStatusFilter").start_array();
for item_136 in var_134 {
{
array_135.value().string(item_136.as_str());
}
}
array_135.finish();
}
if let Some(var_137) = &input.instance_type_filter {
let mut array_138 = object.key("instanceTypeFilter").start_array();
for item_139 in var_137 {
{
array_138.value().string(item_139.as_str());
}
}
array_138.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_deployments_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListDeploymentsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_140) = &input.application_name {
object.key("applicationName").string(var_140);
}
if let Some(var_141) = &input.deployment_group_name {
object.key("deploymentGroupName").string(var_141);
}
if let Some(var_142) = &input.external_id {
object.key("externalId").string(var_142);
}
if let Some(var_143) = &input.include_only_statuses {
let mut array_144 = object.key("includeOnlyStatuses").start_array();
for item_145 in var_143 {
{
array_144.value().string(item_145.as_str());
}
}
array_144.finish();
}
if let Some(var_146) = &input.create_time_range {
let mut object_147 = object.key("createTimeRange").start_object();
crate::json_ser::serialize_structure_crate_model_time_range(&mut object_147, var_146)?;
object_147.finish();
}
if let Some(var_148) = &input.next_token {
object.key("nextToken").string(var_148);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_deployment_targets_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListDeploymentTargetsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_149) = &input.deployment_id {
object.key("deploymentId").string(var_149);
}
if let Some(var_150) = &input.next_token {
object.key("nextToken").string(var_150);
}
if let Some(var_151) = &input.target_filters {
let mut object_152 = object.key("targetFilters").start_object();
for (key_153, value_154) in var_151 {
{
let mut array_155 = object_152.key(key_153.as_str()).start_array();
for item_156 in value_154 {
{
array_155.value().string(item_156);
}
}
array_155.finish();
}
}
object_152.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_git_hub_account_token_names_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListGitHubAccountTokenNamesInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_157) = &input.next_token {
object.key("nextToken").string(var_157);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_on_premises_instances_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListOnPremisesInstancesInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_158) = &input.registration_status {
object.key("registrationStatus").string(var_158.as_str());
}
if let Some(var_159) = &input.tag_filters {
let mut array_160 = object.key("tagFilters").start_array();
for item_161 in var_159 {
{
let mut object_162 = array_160.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag_filter(
&mut object_162,
item_161,
)?;
object_162.finish();
}
}
array_160.finish();
}
if let Some(var_163) = &input.next_token {
object.key("nextToken").string(var_163);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_tags_for_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListTagsForResourceInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_164) = &input.resource_arn {
object.key("ResourceArn").string(var_164);
}
if let Some(var_165) = &input.next_token {
object.key("NextToken").string(var_165);
}
Ok(())
}
pub fn serialize_structure_crate_input_put_lifecycle_event_hook_execution_status_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutLifecycleEventHookExecutionStatusInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_166) = &input.deployment_id {
object.key("deploymentId").string(var_166);
}
if let Some(var_167) = &input.lifecycle_event_hook_execution_id {
object.key("lifecycleEventHookExecutionId").string(var_167);
}
if let Some(var_168) = &input.status {
object.key("status").string(var_168.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_register_application_revision_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RegisterApplicationRevisionInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_169) = &input.application_name {
object.key("applicationName").string(var_169);
}
if let Some(var_170) = &input.description {
object.key("description").string(var_170);
}
if let Some(var_171) = &input.revision {
let mut object_172 = object.key("revision").start_object();
crate::json_ser::serialize_structure_crate_model_revision_location(
&mut object_172,
var_171,
)?;
object_172.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_register_on_premises_instance_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RegisterOnPremisesInstanceInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_173) = &input.instance_name {
object.key("instanceName").string(var_173);
}
if let Some(var_174) = &input.iam_session_arn {
object.key("iamSessionArn").string(var_174);
}
if let Some(var_175) = &input.iam_user_arn {
object.key("iamUserArn").string(var_175);
}
Ok(())
}
pub fn serialize_structure_crate_input_remove_tags_from_on_premises_instances_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RemoveTagsFromOnPremisesInstancesInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_176) = &input.tags {
let mut array_177 = object.key("tags").start_array();
for item_178 in var_176 {
{
let mut object_179 = array_177.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_179, item_178)?;
object_179.finish();
}
}
array_177.finish();
}
if let Some(var_180) = &input.instance_names {
let mut array_181 = object.key("instanceNames").start_array();
for item_182 in var_180 {
{
array_181.value().string(item_182);
}
}
array_181.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_skip_wait_time_for_instance_termination_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::SkipWaitTimeForInstanceTerminationInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_183) = &input.deployment_id {
object.key("deploymentId").string(var_183);
}
Ok(())
}
pub fn serialize_structure_crate_input_stop_deployment_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StopDeploymentInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_184) = &input.deployment_id {
object.key("deploymentId").string(var_184);
}
if let Some(var_185) = &input.auto_rollback_enabled {
object.key("autoRollbackEnabled").boolean(*var_185);
}
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::SerializationError> {
if let Some(var_186) = &input.resource_arn {
object.key("ResourceArn").string(var_186);
}
if let Some(var_187) = &input.tags {
let mut array_188 = object.key("Tags").start_array();
for item_189 in var_187 {
{
let mut object_190 = array_188.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_190, item_189)?;
object_190.finish();
}
}
array_188.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_untag_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UntagResourceInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_191) = &input.resource_arn {
object.key("ResourceArn").string(var_191);
}
if let Some(var_192) = &input.tag_keys {
let mut array_193 = object.key("TagKeys").start_array();
for item_194 in var_192 {
{
array_193.value().string(item_194);
}
}
array_193.finish();
}
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::SerializationError> {
if let Some(var_195) = &input.application_name {
object.key("applicationName").string(var_195);
}
if let Some(var_196) = &input.new_application_name {
object.key("newApplicationName").string(var_196);
}
Ok(())
}
pub fn serialize_structure_crate_input_update_deployment_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateDeploymentGroupInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_197) = &input.application_name {
object.key("applicationName").string(var_197);
}
if let Some(var_198) = &input.current_deployment_group_name {
object.key("currentDeploymentGroupName").string(var_198);
}
if let Some(var_199) = &input.new_deployment_group_name {
object.key("newDeploymentGroupName").string(var_199);
}
if let Some(var_200) = &input.deployment_config_name {
object.key("deploymentConfigName").string(var_200);
}
if let Some(var_201) = &input.ec2_tag_filters {
let mut array_202 = object.key("ec2TagFilters").start_array();
for item_203 in var_201 {
{
let mut object_204 = array_202.value().start_object();
crate::json_ser::serialize_structure_crate_model_ec2_tag_filter(
&mut object_204,
item_203,
)?;
object_204.finish();
}
}
array_202.finish();
}
if let Some(var_205) = &input.on_premises_instance_tag_filters {
let mut array_206 = object.key("onPremisesInstanceTagFilters").start_array();
for item_207 in var_205 {
{
let mut object_208 = array_206.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag_filter(
&mut object_208,
item_207,
)?;
object_208.finish();
}
}
array_206.finish();
}
if let Some(var_209) = &input.auto_scaling_groups {
let mut array_210 = object.key("autoScalingGroups").start_array();
for item_211 in var_209 {
{
array_210.value().string(item_211);
}
}
array_210.finish();
}
if let Some(var_212) = &input.service_role_arn {
object.key("serviceRoleArn").string(var_212);
}
if let Some(var_213) = &input.trigger_configurations {
let mut array_214 = object.key("triggerConfigurations").start_array();
for item_215 in var_213 {
{
let mut object_216 = array_214.value().start_object();
crate::json_ser::serialize_structure_crate_model_trigger_config(
&mut object_216,
item_215,
)?;
object_216.finish();
}
}
array_214.finish();
}
if let Some(var_217) = &input.alarm_configuration {
let mut object_218 = object.key("alarmConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_alarm_configuration(
&mut object_218,
var_217,
)?;
object_218.finish();
}
if let Some(var_219) = &input.auto_rollback_configuration {
let mut object_220 = object.key("autoRollbackConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_auto_rollback_configuration(
&mut object_220,
var_219,
)?;
object_220.finish();
}
if let Some(var_221) = &input.outdated_instances_strategy {
object
.key("outdatedInstancesStrategy")
.string(var_221.as_str());
}
if let Some(var_222) = &input.deployment_style {
let mut object_223 = object.key("deploymentStyle").start_object();
crate::json_ser::serialize_structure_crate_model_deployment_style(
&mut object_223,
var_222,
)?;
object_223.finish();
}
if let Some(var_224) = &input.blue_green_deployment_configuration {
let mut object_225 = object
.key("blueGreenDeploymentConfiguration")
.start_object();
crate::json_ser::serialize_structure_crate_model_blue_green_deployment_configuration(
&mut object_225,
var_224,
)?;
object_225.finish();
}
if let Some(var_226) = &input.load_balancer_info {
let mut object_227 = object.key("loadBalancerInfo").start_object();
crate::json_ser::serialize_structure_crate_model_load_balancer_info(
&mut object_227,
var_226,
)?;
object_227.finish();
}
if let Some(var_228) = &input.ec2_tag_set {
let mut object_229 = object.key("ec2TagSet").start_object();
crate::json_ser::serialize_structure_crate_model_ec2_tag_set(&mut object_229, var_228)?;
object_229.finish();
}
if let Some(var_230) = &input.ecs_services {
let mut array_231 = object.key("ecsServices").start_array();
for item_232 in var_230 {
{
let mut object_233 = array_231.value().start_object();
crate::json_ser::serialize_structure_crate_model_ecs_service(
&mut object_233,
item_232,
)?;
object_233.finish();
}
}
array_231.finish();
}
if let Some(var_234) = &input.on_premises_tag_set {
let mut object_235 = object.key("onPremisesTagSet").start_object();
crate::json_ser::serialize_structure_crate_model_on_premises_tag_set(
&mut object_235,
var_234,
)?;
object_235.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::SerializationError> {
if let Some(var_236) = &input.key {
object.key("Key").string(var_236);
}
if let Some(var_237) = &input.value {
object.key("Value").string(var_237);
}
Ok(())
}
pub fn serialize_structure_crate_model_revision_location(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RevisionLocation,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_238) = &input.revision_type {
object.key("revisionType").string(var_238.as_str());
}
if let Some(var_239) = &input.s3_location {
let mut object_240 = object.key("s3Location").start_object();
crate::json_ser::serialize_structure_crate_model_s3_location(&mut object_240, var_239)?;
object_240.finish();
}
if let Some(var_241) = &input.git_hub_location {
let mut object_242 = object.key("gitHubLocation").start_object();
crate::json_ser::serialize_structure_crate_model_git_hub_location(
&mut object_242,
var_241,
)?;
object_242.finish();
}
if let Some(var_243) = &input.string {
let mut object_244 = object.key("string").start_object();
crate::json_ser::serialize_structure_crate_model_raw_string(&mut object_244, var_243)?;
object_244.finish();
}
if let Some(var_245) = &input.app_spec_content {
let mut object_246 = object.key("appSpecContent").start_object();
crate::json_ser::serialize_structure_crate_model_app_spec_content(
&mut object_246,
var_245,
)?;
object_246.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_target_instances(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TargetInstances,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_247) = &input.tag_filters {
let mut array_248 = object.key("tagFilters").start_array();
for item_249 in var_247 {
{
let mut object_250 = array_248.value().start_object();
crate::json_ser::serialize_structure_crate_model_ec2_tag_filter(
&mut object_250,
item_249,
)?;
object_250.finish();
}
}
array_248.finish();
}
if let Some(var_251) = &input.auto_scaling_groups {
let mut array_252 = object.key("autoScalingGroups").start_array();
for item_253 in var_251 {
{
array_252.value().string(item_253);
}
}
array_252.finish();
}
if let Some(var_254) = &input.ec2_tag_set {
let mut object_255 = object.key("ec2TagSet").start_object();
crate::json_ser::serialize_structure_crate_model_ec2_tag_set(&mut object_255, var_254)?;
object_255.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_auto_rollback_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AutoRollbackConfiguration,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if input.enabled {
object.key("enabled").boolean(input.enabled);
}
if let Some(var_256) = &input.events {
let mut array_257 = object.key("events").start_array();
for item_258 in var_256 {
{
array_257.value().string(item_258.as_str());
}
}
array_257.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_minimum_healthy_hosts(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MinimumHealthyHosts,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_259) = &input.r#type {
object.key("type").string(var_259.as_str());
}
if input.value != 0 {
object.key("value").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.value).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_traffic_routing_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TrafficRoutingConfig,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_260) = &input.r#type {
object.key("type").string(var_260.as_str());
}
if let Some(var_261) = &input.time_based_canary {
let mut object_262 = object.key("timeBasedCanary").start_object();
crate::json_ser::serialize_structure_crate_model_time_based_canary(
&mut object_262,
var_261,
)?;
object_262.finish();
}
if let Some(var_263) = &input.time_based_linear {
let mut object_264 = object.key("timeBasedLinear").start_object();
crate::json_ser::serialize_structure_crate_model_time_based_linear(
&mut object_264,
var_263,
)?;
object_264.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_ec2_tag_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Ec2TagFilter,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_265) = &input.key {
object.key("Key").string(var_265);
}
if let Some(var_266) = &input.value {
object.key("Value").string(var_266);
}
if let Some(var_267) = &input.r#type {
object.key("Type").string(var_267.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_tag_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TagFilter,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_268) = &input.key {
object.key("Key").string(var_268);
}
if let Some(var_269) = &input.value {
object.key("Value").string(var_269);
}
if let Some(var_270) = &input.r#type {
object.key("Type").string(var_270.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_trigger_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TriggerConfig,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_271) = &input.trigger_name {
object.key("triggerName").string(var_271);
}
if let Some(var_272) = &input.trigger_target_arn {
object.key("triggerTargetArn").string(var_272);
}
if let Some(var_273) = &input.trigger_events {
let mut array_274 = object.key("triggerEvents").start_array();
for item_275 in var_273 {
{
array_274.value().string(item_275.as_str());
}
}
array_274.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_alarm_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AlarmConfiguration,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if input.enabled {
object.key("enabled").boolean(input.enabled);
}
if input.ignore_poll_alarm_failure {
object
.key("ignorePollAlarmFailure")
.boolean(input.ignore_poll_alarm_failure);
}
if let Some(var_276) = &input.alarms {
let mut array_277 = object.key("alarms").start_array();
for item_278 in var_276 {
{
let mut object_279 = array_277.value().start_object();
crate::json_ser::serialize_structure_crate_model_alarm(&mut object_279, item_278)?;
object_279.finish();
}
}
array_277.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_deployment_style(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DeploymentStyle,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_280) = &input.deployment_type {
object.key("deploymentType").string(var_280.as_str());
}
if let Some(var_281) = &input.deployment_option {
object.key("deploymentOption").string(var_281.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_blue_green_deployment_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BlueGreenDeploymentConfiguration,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_282) = &input.terminate_blue_instances_on_deployment_success {
let mut object_283 = object
.key("terminateBlueInstancesOnDeploymentSuccess")
.start_object();
crate::json_ser::serialize_structure_crate_model_blue_instance_termination_option(
&mut object_283,
var_282,
)?;
object_283.finish();
}
if let Some(var_284) = &input.deployment_ready_option {
let mut object_285 = object.key("deploymentReadyOption").start_object();
crate::json_ser::serialize_structure_crate_model_deployment_ready_option(
&mut object_285,
var_284,
)?;
object_285.finish();
}
if let Some(var_286) = &input.green_fleet_provisioning_option {
let mut object_287 = object.key("greenFleetProvisioningOption").start_object();
crate::json_ser::serialize_structure_crate_model_green_fleet_provisioning_option(
&mut object_287,
var_286,
)?;
object_287.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_load_balancer_info(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LoadBalancerInfo,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_288) = &input.elb_info_list {
let mut array_289 = object.key("elbInfoList").start_array();
for item_290 in var_288 {
{
let mut object_291 = array_289.value().start_object();
crate::json_ser::serialize_structure_crate_model_elb_info(
&mut object_291,
item_290,
)?;
object_291.finish();
}
}
array_289.finish();
}
if let Some(var_292) = &input.target_group_info_list {
let mut array_293 = object.key("targetGroupInfoList").start_array();
for item_294 in var_292 {
{
let mut object_295 = array_293.value().start_object();
crate::json_ser::serialize_structure_crate_model_target_group_info(
&mut object_295,
item_294,
)?;
object_295.finish();
}
}
array_293.finish();
}
if let Some(var_296) = &input.target_group_pair_info_list {
let mut array_297 = object.key("targetGroupPairInfoList").start_array();
for item_298 in var_296 {
{
let mut object_299 = array_297.value().start_object();
crate::json_ser::serialize_structure_crate_model_target_group_pair_info(
&mut object_299,
item_298,
)?;
object_299.finish();
}
}
array_297.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_ec2_tag_set(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Ec2TagSet,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_300) = &input.ec2_tag_set_list {
let mut array_301 = object.key("ec2TagSetList").start_array();
for item_302 in var_300 {
{
let mut array_303 = array_301.value().start_array();
for item_304 in item_302 {
{
let mut object_305 = array_303.value().start_object();
crate::json_ser::serialize_structure_crate_model_ec2_tag_filter(
&mut object_305,
item_304,
)?;
object_305.finish();
}
}
array_303.finish();
}
}
array_301.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_ecs_service(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EcsService,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_306) = &input.service_name {
object.key("serviceName").string(var_306);
}
if let Some(var_307) = &input.cluster_name {
object.key("clusterName").string(var_307);
}
Ok(())
}
pub fn serialize_structure_crate_model_on_premises_tag_set(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OnPremisesTagSet,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_308) = &input.on_premises_tag_set_list {
let mut array_309 = object.key("onPremisesTagSetList").start_array();
for item_310 in var_308 {
{
let mut array_311 = array_309.value().start_array();
for item_312 in item_310 {
{
let mut object_313 = array_311.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag_filter(
&mut object_313,
item_312,
)?;
object_313.finish();
}
}
array_311.finish();
}
}
array_309.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_time_range(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TimeRange,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_314) = &input.start {
object
.key("start")
.date_time(var_314, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_315) = &input.end {
object
.key("end")
.date_time(var_315, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
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::SerializationError> {
if let Some(var_316) = &input.bucket {
object.key("bucket").string(var_316);
}
if let Some(var_317) = &input.key {
object.key("key").string(var_317);
}
if let Some(var_318) = &input.bundle_type {
object.key("bundleType").string(var_318.as_str());
}
if let Some(var_319) = &input.version {
object.key("version").string(var_319);
}
if let Some(var_320) = &input.e_tag {
object.key("eTag").string(var_320);
}
Ok(())
}
pub fn serialize_structure_crate_model_git_hub_location(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GitHubLocation,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_321) = &input.repository {
object.key("repository").string(var_321);
}
if let Some(var_322) = &input.commit_id {
object.key("commitId").string(var_322);
}
Ok(())
}
pub fn serialize_structure_crate_model_raw_string(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RawString,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_323) = &input.content {
object.key("content").string(var_323);
}
if let Some(var_324) = &input.sha256 {
object.key("sha256").string(var_324);
}
Ok(())
}
pub fn serialize_structure_crate_model_app_spec_content(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AppSpecContent,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_325) = &input.content {
object.key("content").string(var_325);
}
if let Some(var_326) = &input.sha256 {
object.key("sha256").string(var_326);
}
Ok(())
}
pub fn serialize_structure_crate_model_time_based_canary(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TimeBasedCanary,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if input.canary_percentage != 0 {
object.key("canaryPercentage").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.canary_percentage).into()),
);
}
if input.canary_interval != 0 {
object.key("canaryInterval").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.canary_interval).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_time_based_linear(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TimeBasedLinear,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if input.linear_percentage != 0 {
object.key("linearPercentage").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.linear_percentage).into()),
);
}
if input.linear_interval != 0 {
object.key("linearInterval").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.linear_interval).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_alarm(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Alarm,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_327) = &input.name {
object.key("name").string(var_327);
}
Ok(())
}
pub fn serialize_structure_crate_model_blue_instance_termination_option(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BlueInstanceTerminationOption,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_328) = &input.action {
object.key("action").string(var_328.as_str());
}
if input.termination_wait_time_in_minutes != 0 {
object.key("terminationWaitTimeInMinutes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.termination_wait_time_in_minutes).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_deployment_ready_option(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DeploymentReadyOption,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_329) = &input.action_on_timeout {
object.key("actionOnTimeout").string(var_329.as_str());
}
if input.wait_time_in_minutes != 0 {
object.key("waitTimeInMinutes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.wait_time_in_minutes).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_green_fleet_provisioning_option(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GreenFleetProvisioningOption,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_330) = &input.action {
object.key("action").string(var_330.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_elb_info(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ElbInfo,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_331) = &input.name {
object.key("name").string(var_331);
}
Ok(())
}
pub fn serialize_structure_crate_model_target_group_info(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TargetGroupInfo,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_332) = &input.name {
object.key("name").string(var_332);
}
Ok(())
}
pub fn serialize_structure_crate_model_target_group_pair_info(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TargetGroupPairInfo,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_333) = &input.target_groups {
let mut array_334 = object.key("targetGroups").start_array();
for item_335 in var_333 {
{
let mut object_336 = array_334.value().start_object();
crate::json_ser::serialize_structure_crate_model_target_group_info(
&mut object_336,
item_335,
)?;
object_336.finish();
}
}
array_334.finish();
}
if let Some(var_337) = &input.prod_traffic_route {
let mut object_338 = object.key("prodTrafficRoute").start_object();
crate::json_ser::serialize_structure_crate_model_traffic_route(&mut object_338, var_337)?;
object_338.finish();
}
if let Some(var_339) = &input.test_traffic_route {
let mut object_340 = object.key("testTrafficRoute").start_object();
crate::json_ser::serialize_structure_crate_model_traffic_route(&mut object_340, var_339)?;
object_340.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_traffic_route(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TrafficRoute,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_341) = &input.listener_arns {
let mut array_342 = object.key("listenerArns").start_array();
for item_343 in var_341 {
{
array_342.value().string(item_343);
}
}
array_342.finish();
}
Ok(())
}