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::error::SerializationError> {
if let Some(var_1) = &input.tags {
let mut array_2 = object.key("tags").start_array();
for item_3 in var_1 {
{
#[allow(unused_mut)]
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.as_str());
}
}
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::error::SerializationError> {
if let Some(var_8) = &input.application_name {
object.key("applicationName").string(var_8.as_str());
}
if let Some(var_9) = &input.revisions {
let mut array_10 = object.key("revisions").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_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::error::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.as_str());
}
}
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::error::SerializationError> {
if let Some(var_16) = &input.application_name {
object.key("applicationName").string(var_16.as_str());
}
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.as_str());
}
}
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::error::SerializationError> {
if let Some(var_20) = &input.deployment_id {
object.key("deploymentId").string(var_20.as_str());
}
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.as_str());
}
}
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::error::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.as_str());
}
}
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::error::SerializationError> {
if let Some(var_27) = &input.deployment_id {
object.key("deploymentId").string(var_27.as_str());
}
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.as_str());
}
}
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::error::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.as_str());
}
}
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::error::SerializationError> {
if let Some(var_34) = &input.deployment_id {
object.key("deploymentId").string(var_34.as_str());
}
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::error::SerializationError> {
if let Some(var_36) = &input.application_name {
object.key("applicationName").string(var_36.as_str());
}
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 {
{
#[allow(unused_mut)]
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::error::SerializationError> {
if let Some(var_42) = &input.application_name {
object.key("applicationName").string(var_42.as_str());
}
if let Some(var_43) = &input.deployment_group_name {
object.key("deploymentGroupName").string(var_43.as_str());
}
if let Some(var_44) = &input.revision {
#[allow(unused_mut)]
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.as_str());
}
if let Some(var_47) = &input.description {
object.key("description").string(var_47.as_str());
}
if input.ignore_application_stop_failures {
object
.key("ignoreApplicationStopFailures")
.boolean(input.ignore_application_stop_failures);
}
if let Some(var_48) = &input.target_instances {
#[allow(unused_mut)]
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 {
#[allow(unused_mut)]
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());
}
if let Some(var_53) = &input.override_alarm_configuration {
#[allow(unused_mut)]
let mut object_54 = object.key("overrideAlarmConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_alarm_configuration(
&mut object_54,
var_53,
)?;
object_54.finish();
}
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::error::SerializationError> {
if let Some(var_55) = &input.deployment_config_name {
object.key("deploymentConfigName").string(var_55.as_str());
}
if let Some(var_56) = &input.minimum_healthy_hosts {
#[allow(unused_mut)]
let mut object_57 = object.key("minimumHealthyHosts").start_object();
crate::json_ser::serialize_structure_crate_model_minimum_healthy_hosts(
&mut object_57,
var_56,
)?;
object_57.finish();
}
if let Some(var_58) = &input.traffic_routing_config {
#[allow(unused_mut)]
let mut object_59 = object.key("trafficRoutingConfig").start_object();
crate::json_ser::serialize_structure_crate_model_traffic_routing_config(
&mut object_59,
var_58,
)?;
object_59.finish();
}
if let Some(var_60) = &input.compute_platform {
object.key("computePlatform").string(var_60.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::error::SerializationError> {
if let Some(var_61) = &input.application_name {
object.key("applicationName").string(var_61.as_str());
}
if let Some(var_62) = &input.deployment_group_name {
object.key("deploymentGroupName").string(var_62.as_str());
}
if let Some(var_63) = &input.deployment_config_name {
object.key("deploymentConfigName").string(var_63.as_str());
}
if let Some(var_64) = &input.ec2_tag_filters {
let mut array_65 = object.key("ec2TagFilters").start_array();
for item_66 in var_64 {
{
#[allow(unused_mut)]
let mut object_67 = array_65.value().start_object();
crate::json_ser::serialize_structure_crate_model_ec2_tag_filter(
&mut object_67,
item_66,
)?;
object_67.finish();
}
}
array_65.finish();
}
if let Some(var_68) = &input.on_premises_instance_tag_filters {
let mut array_69 = object.key("onPremisesInstanceTagFilters").start_array();
for item_70 in var_68 {
{
#[allow(unused_mut)]
let mut object_71 = array_69.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag_filter(
&mut object_71,
item_70,
)?;
object_71.finish();
}
}
array_69.finish();
}
if let Some(var_72) = &input.auto_scaling_groups {
let mut array_73 = object.key("autoScalingGroups").start_array();
for item_74 in var_72 {
{
array_73.value().string(item_74.as_str());
}
}
array_73.finish();
}
if let Some(var_75) = &input.service_role_arn {
object.key("serviceRoleArn").string(var_75.as_str());
}
if let Some(var_76) = &input.trigger_configurations {
let mut array_77 = object.key("triggerConfigurations").start_array();
for item_78 in var_76 {
{
#[allow(unused_mut)]
let mut object_79 = array_77.value().start_object();
crate::json_ser::serialize_structure_crate_model_trigger_config(
&mut object_79,
item_78,
)?;
object_79.finish();
}
}
array_77.finish();
}
if let Some(var_80) = &input.alarm_configuration {
#[allow(unused_mut)]
let mut object_81 = object.key("alarmConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_alarm_configuration(
&mut object_81,
var_80,
)?;
object_81.finish();
}
if let Some(var_82) = &input.auto_rollback_configuration {
#[allow(unused_mut)]
let mut object_83 = object.key("autoRollbackConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_auto_rollback_configuration(
&mut object_83,
var_82,
)?;
object_83.finish();
}
if let Some(var_84) = &input.outdated_instances_strategy {
object
.key("outdatedInstancesStrategy")
.string(var_84.as_str());
}
if let Some(var_85) = &input.deployment_style {
#[allow(unused_mut)]
let mut object_86 = object.key("deploymentStyle").start_object();
crate::json_ser::serialize_structure_crate_model_deployment_style(&mut object_86, var_85)?;
object_86.finish();
}
if let Some(var_87) = &input.blue_green_deployment_configuration {
#[allow(unused_mut)]
let mut object_88 = object
.key("blueGreenDeploymentConfiguration")
.start_object();
crate::json_ser::serialize_structure_crate_model_blue_green_deployment_configuration(
&mut object_88,
var_87,
)?;
object_88.finish();
}
if let Some(var_89) = &input.load_balancer_info {
#[allow(unused_mut)]
let mut object_90 = object.key("loadBalancerInfo").start_object();
crate::json_ser::serialize_structure_crate_model_load_balancer_info(
&mut object_90,
var_89,
)?;
object_90.finish();
}
if let Some(var_91) = &input.ec2_tag_set {
#[allow(unused_mut)]
let mut object_92 = object.key("ec2TagSet").start_object();
crate::json_ser::serialize_structure_crate_model_ec2_tag_set(&mut object_92, var_91)?;
object_92.finish();
}
if let Some(var_93) = &input.ecs_services {
let mut array_94 = object.key("ecsServices").start_array();
for item_95 in var_93 {
{
#[allow(unused_mut)]
let mut object_96 = array_94.value().start_object();
crate::json_ser::serialize_structure_crate_model_ecs_service(
&mut object_96,
item_95,
)?;
object_96.finish();
}
}
array_94.finish();
}
if let Some(var_97) = &input.on_premises_tag_set {
#[allow(unused_mut)]
let mut object_98 = object.key("onPremisesTagSet").start_object();
crate::json_ser::serialize_structure_crate_model_on_premises_tag_set(
&mut object_98,
var_97,
)?;
object_98.finish();
}
if let Some(var_99) = &input.tags {
let mut array_100 = object.key("tags").start_array();
for item_101 in var_99 {
{
#[allow(unused_mut)]
let mut object_102 = array_100.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_102, item_101)?;
object_102.finish();
}
}
array_100.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_103) = &input.application_name {
object.key("applicationName").string(var_103.as_str());
}
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::error::SerializationError> {
if let Some(var_104) = &input.deployment_config_name {
object.key("deploymentConfigName").string(var_104.as_str());
}
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::error::SerializationError> {
if let Some(var_105) = &input.application_name {
object.key("applicationName").string(var_105.as_str());
}
if let Some(var_106) = &input.deployment_group_name {
object.key("deploymentGroupName").string(var_106.as_str());
}
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::error::SerializationError> {
if let Some(var_107) = &input.token_name {
object.key("tokenName").string(var_107.as_str());
}
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::error::SerializationError> {
if let Some(var_108) = &input.external_id {
object.key("externalId").string(var_108.as_str());
}
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::error::SerializationError> {
if let Some(var_109) = &input.instance_name {
object.key("instanceName").string(var_109.as_str());
}
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::error::SerializationError> {
if let Some(var_110) = &input.application_name {
object.key("applicationName").string(var_110.as_str());
}
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::error::SerializationError> {
if let Some(var_111) = &input.application_name {
object.key("applicationName").string(var_111.as_str());
}
if let Some(var_112) = &input.revision {
#[allow(unused_mut)]
let mut object_113 = object.key("revision").start_object();
crate::json_ser::serialize_structure_crate_model_revision_location(
&mut object_113,
var_112,
)?;
object_113.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::error::SerializationError> {
if let Some(var_114) = &input.deployment_id {
object.key("deploymentId").string(var_114.as_str());
}
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::error::SerializationError> {
if let Some(var_115) = &input.deployment_config_name {
object.key("deploymentConfigName").string(var_115.as_str());
}
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::error::SerializationError> {
if let Some(var_116) = &input.application_name {
object.key("applicationName").string(var_116.as_str());
}
if let Some(var_117) = &input.deployment_group_name {
object.key("deploymentGroupName").string(var_117.as_str());
}
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::error::SerializationError> {
if let Some(var_118) = &input.deployment_id {
object.key("deploymentId").string(var_118.as_str());
}
if let Some(var_119) = &input.instance_id {
object.key("instanceId").string(var_119.as_str());
}
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::error::SerializationError> {
if let Some(var_120) = &input.deployment_id {
object.key("deploymentId").string(var_120.as_str());
}
if let Some(var_121) = &input.target_id {
object.key("targetId").string(var_121.as_str());
}
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::error::SerializationError> {
if let Some(var_122) = &input.instance_name {
object.key("instanceName").string(var_122.as_str());
}
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::error::SerializationError> {
if let Some(var_123) = &input.application_name {
object.key("applicationName").string(var_123.as_str());
}
if let Some(var_124) = &input.sort_by {
object.key("sortBy").string(var_124.as_str());
}
if let Some(var_125) = &input.sort_order {
object.key("sortOrder").string(var_125.as_str());
}
if let Some(var_126) = &input.s3_bucket {
object.key("s3Bucket").string(var_126.as_str());
}
if let Some(var_127) = &input.s3_key_prefix {
object.key("s3KeyPrefix").string(var_127.as_str());
}
if let Some(var_128) = &input.deployed {
object.key("deployed").string(var_128.as_str());
}
if let Some(var_129) = &input.next_token {
object.key("nextToken").string(var_129.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_130) = &input.next_token {
object.key("nextToken").string(var_130.as_str());
}
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::error::SerializationError> {
if let Some(var_131) = &input.next_token {
object.key("nextToken").string(var_131.as_str());
}
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::error::SerializationError> {
if let Some(var_132) = &input.application_name {
object.key("applicationName").string(var_132.as_str());
}
if let Some(var_133) = &input.next_token {
object.key("nextToken").string(var_133.as_str());
}
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::error::SerializationError> {
if let Some(var_134) = &input.deployment_id {
object.key("deploymentId").string(var_134.as_str());
}
if let Some(var_135) = &input.next_token {
object.key("nextToken").string(var_135.as_str());
}
if let Some(var_136) = &input.instance_status_filter {
let mut array_137 = object.key("instanceStatusFilter").start_array();
for item_138 in var_136 {
{
array_137.value().string(item_138.as_str());
}
}
array_137.finish();
}
if let Some(var_139) = &input.instance_type_filter {
let mut array_140 = object.key("instanceTypeFilter").start_array();
for item_141 in var_139 {
{
array_140.value().string(item_141.as_str());
}
}
array_140.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::error::SerializationError> {
if let Some(var_142) = &input.application_name {
object.key("applicationName").string(var_142.as_str());
}
if let Some(var_143) = &input.deployment_group_name {
object.key("deploymentGroupName").string(var_143.as_str());
}
if let Some(var_144) = &input.external_id {
object.key("externalId").string(var_144.as_str());
}
if let Some(var_145) = &input.include_only_statuses {
let mut array_146 = object.key("includeOnlyStatuses").start_array();
for item_147 in var_145 {
{
array_146.value().string(item_147.as_str());
}
}
array_146.finish();
}
if let Some(var_148) = &input.create_time_range {
#[allow(unused_mut)]
let mut object_149 = object.key("createTimeRange").start_object();
crate::json_ser::serialize_structure_crate_model_time_range(&mut object_149, var_148)?;
object_149.finish();
}
if let Some(var_150) = &input.next_token {
object.key("nextToken").string(var_150.as_str());
}
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::error::SerializationError> {
if let Some(var_151) = &input.deployment_id {
object.key("deploymentId").string(var_151.as_str());
}
if let Some(var_152) = &input.next_token {
object.key("nextToken").string(var_152.as_str());
}
if let Some(var_153) = &input.target_filters {
#[allow(unused_mut)]
let mut object_154 = object.key("targetFilters").start_object();
for (key_155, value_156) in var_153 {
{
let mut array_157 = object_154.key(key_155.as_str()).start_array();
for item_158 in value_156 {
{
array_157.value().string(item_158.as_str());
}
}
array_157.finish();
}
}
object_154.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::error::SerializationError> {
if let Some(var_159) = &input.next_token {
object.key("nextToken").string(var_159.as_str());
}
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::error::SerializationError> {
if let Some(var_160) = &input.registration_status {
object.key("registrationStatus").string(var_160.as_str());
}
if let Some(var_161) = &input.tag_filters {
let mut array_162 = object.key("tagFilters").start_array();
for item_163 in var_161 {
{
#[allow(unused_mut)]
let mut object_164 = array_162.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag_filter(
&mut object_164,
item_163,
)?;
object_164.finish();
}
}
array_162.finish();
}
if let Some(var_165) = &input.next_token {
object.key("nextToken").string(var_165.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_tags_for_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListTagsForResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_166) = &input.resource_arn {
object.key("ResourceArn").string(var_166.as_str());
}
if let Some(var_167) = &input.next_token {
object.key("NextToken").string(var_167.as_str());
}
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::error::SerializationError> {
if let Some(var_168) = &input.deployment_id {
object.key("deploymentId").string(var_168.as_str());
}
if let Some(var_169) = &input.lifecycle_event_hook_execution_id {
object
.key("lifecycleEventHookExecutionId")
.string(var_169.as_str());
}
if let Some(var_170) = &input.status {
object.key("status").string(var_170.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::error::SerializationError> {
if let Some(var_171) = &input.application_name {
object.key("applicationName").string(var_171.as_str());
}
if let Some(var_172) = &input.description {
object.key("description").string(var_172.as_str());
}
if let Some(var_173) = &input.revision {
#[allow(unused_mut)]
let mut object_174 = object.key("revision").start_object();
crate::json_ser::serialize_structure_crate_model_revision_location(
&mut object_174,
var_173,
)?;
object_174.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::error::SerializationError> {
if let Some(var_175) = &input.instance_name {
object.key("instanceName").string(var_175.as_str());
}
if let Some(var_176) = &input.iam_session_arn {
object.key("iamSessionArn").string(var_176.as_str());
}
if let Some(var_177) = &input.iam_user_arn {
object.key("iamUserArn").string(var_177.as_str());
}
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::error::SerializationError> {
if let Some(var_178) = &input.tags {
let mut array_179 = object.key("tags").start_array();
for item_180 in var_178 {
{
#[allow(unused_mut)]
let mut object_181 = array_179.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_181, item_180)?;
object_181.finish();
}
}
array_179.finish();
}
if let Some(var_182) = &input.instance_names {
let mut array_183 = object.key("instanceNames").start_array();
for item_184 in var_182 {
{
array_183.value().string(item_184.as_str());
}
}
array_183.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::error::SerializationError> {
if let Some(var_185) = &input.deployment_id {
object.key("deploymentId").string(var_185.as_str());
}
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::error::SerializationError> {
if let Some(var_186) = &input.deployment_id {
object.key("deploymentId").string(var_186.as_str());
}
if let Some(var_187) = &input.auto_rollback_enabled {
object.key("autoRollbackEnabled").boolean(*var_187);
}
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_188) = &input.resource_arn {
object.key("ResourceArn").string(var_188.as_str());
}
if let Some(var_189) = &input.tags {
let mut array_190 = object.key("Tags").start_array();
for item_191 in var_189 {
{
#[allow(unused_mut)]
let mut object_192 = array_190.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_192, item_191)?;
object_192.finish();
}
}
array_190.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_untag_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UntagResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_193) = &input.resource_arn {
object.key("ResourceArn").string(var_193.as_str());
}
if let Some(var_194) = &input.tag_keys {
let mut array_195 = object.key("TagKeys").start_array();
for item_196 in var_194 {
{
array_195.value().string(item_196.as_str());
}
}
array_195.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::error::SerializationError> {
if let Some(var_197) = &input.application_name {
object.key("applicationName").string(var_197.as_str());
}
if let Some(var_198) = &input.new_application_name {
object.key("newApplicationName").string(var_198.as_str());
}
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::error::SerializationError> {
if let Some(var_199) = &input.application_name {
object.key("applicationName").string(var_199.as_str());
}
if let Some(var_200) = &input.current_deployment_group_name {
object
.key("currentDeploymentGroupName")
.string(var_200.as_str());
}
if let Some(var_201) = &input.new_deployment_group_name {
object
.key("newDeploymentGroupName")
.string(var_201.as_str());
}
if let Some(var_202) = &input.deployment_config_name {
object.key("deploymentConfigName").string(var_202.as_str());
}
if let Some(var_203) = &input.ec2_tag_filters {
let mut array_204 = object.key("ec2TagFilters").start_array();
for item_205 in var_203 {
{
#[allow(unused_mut)]
let mut object_206 = array_204.value().start_object();
crate::json_ser::serialize_structure_crate_model_ec2_tag_filter(
&mut object_206,
item_205,
)?;
object_206.finish();
}
}
array_204.finish();
}
if let Some(var_207) = &input.on_premises_instance_tag_filters {
let mut array_208 = object.key("onPremisesInstanceTagFilters").start_array();
for item_209 in var_207 {
{
#[allow(unused_mut)]
let mut object_210 = array_208.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag_filter(
&mut object_210,
item_209,
)?;
object_210.finish();
}
}
array_208.finish();
}
if let Some(var_211) = &input.auto_scaling_groups {
let mut array_212 = object.key("autoScalingGroups").start_array();
for item_213 in var_211 {
{
array_212.value().string(item_213.as_str());
}
}
array_212.finish();
}
if let Some(var_214) = &input.service_role_arn {
object.key("serviceRoleArn").string(var_214.as_str());
}
if let Some(var_215) = &input.trigger_configurations {
let mut array_216 = object.key("triggerConfigurations").start_array();
for item_217 in var_215 {
{
#[allow(unused_mut)]
let mut object_218 = array_216.value().start_object();
crate::json_ser::serialize_structure_crate_model_trigger_config(
&mut object_218,
item_217,
)?;
object_218.finish();
}
}
array_216.finish();
}
if let Some(var_219) = &input.alarm_configuration {
#[allow(unused_mut)]
let mut object_220 = object.key("alarmConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_alarm_configuration(
&mut object_220,
var_219,
)?;
object_220.finish();
}
if let Some(var_221) = &input.auto_rollback_configuration {
#[allow(unused_mut)]
let mut object_222 = object.key("autoRollbackConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_auto_rollback_configuration(
&mut object_222,
var_221,
)?;
object_222.finish();
}
if let Some(var_223) = &input.outdated_instances_strategy {
object
.key("outdatedInstancesStrategy")
.string(var_223.as_str());
}
if let Some(var_224) = &input.deployment_style {
#[allow(unused_mut)]
let mut object_225 = object.key("deploymentStyle").start_object();
crate::json_ser::serialize_structure_crate_model_deployment_style(
&mut object_225,
var_224,
)?;
object_225.finish();
}
if let Some(var_226) = &input.blue_green_deployment_configuration {
#[allow(unused_mut)]
let mut object_227 = object
.key("blueGreenDeploymentConfiguration")
.start_object();
crate::json_ser::serialize_structure_crate_model_blue_green_deployment_configuration(
&mut object_227,
var_226,
)?;
object_227.finish();
}
if let Some(var_228) = &input.load_balancer_info {
#[allow(unused_mut)]
let mut object_229 = object.key("loadBalancerInfo").start_object();
crate::json_ser::serialize_structure_crate_model_load_balancer_info(
&mut object_229,
var_228,
)?;
object_229.finish();
}
if let Some(var_230) = &input.ec2_tag_set {
#[allow(unused_mut)]
let mut object_231 = object.key("ec2TagSet").start_object();
crate::json_ser::serialize_structure_crate_model_ec2_tag_set(&mut object_231, var_230)?;
object_231.finish();
}
if let Some(var_232) = &input.ecs_services {
let mut array_233 = object.key("ecsServices").start_array();
for item_234 in var_232 {
{
#[allow(unused_mut)]
let mut object_235 = array_233.value().start_object();
crate::json_ser::serialize_structure_crate_model_ecs_service(
&mut object_235,
item_234,
)?;
object_235.finish();
}
}
array_233.finish();
}
if let Some(var_236) = &input.on_premises_tag_set {
#[allow(unused_mut)]
let mut object_237 = object.key("onPremisesTagSet").start_object();
crate::json_ser::serialize_structure_crate_model_on_premises_tag_set(
&mut object_237,
var_236,
)?;
object_237.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_238) = &input.key {
object.key("Key").string(var_238.as_str());
}
if let Some(var_239) = &input.value {
object.key("Value").string(var_239.as_str());
}
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::error::SerializationError> {
if let Some(var_240) = &input.revision_type {
object.key("revisionType").string(var_240.as_str());
}
if let Some(var_241) = &input.s3_location {
#[allow(unused_mut)]
let mut object_242 = object.key("s3Location").start_object();
crate::json_ser::serialize_structure_crate_model_s3_location(&mut object_242, var_241)?;
object_242.finish();
}
if let Some(var_243) = &input.git_hub_location {
#[allow(unused_mut)]
let mut object_244 = object.key("gitHubLocation").start_object();
crate::json_ser::serialize_structure_crate_model_git_hub_location(
&mut object_244,
var_243,
)?;
object_244.finish();
}
if let Some(var_245) = &input.string {
#[allow(unused_mut)]
let mut object_246 = object.key("string").start_object();
crate::json_ser::serialize_structure_crate_model_raw_string(&mut object_246, var_245)?;
object_246.finish();
}
if let Some(var_247) = &input.app_spec_content {
#[allow(unused_mut)]
let mut object_248 = object.key("appSpecContent").start_object();
crate::json_ser::serialize_structure_crate_model_app_spec_content(
&mut object_248,
var_247,
)?;
object_248.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::error::SerializationError> {
if let Some(var_249) = &input.tag_filters {
let mut array_250 = object.key("tagFilters").start_array();
for item_251 in var_249 {
{
#[allow(unused_mut)]
let mut object_252 = array_250.value().start_object();
crate::json_ser::serialize_structure_crate_model_ec2_tag_filter(
&mut object_252,
item_251,
)?;
object_252.finish();
}
}
array_250.finish();
}
if let Some(var_253) = &input.auto_scaling_groups {
let mut array_254 = object.key("autoScalingGroups").start_array();
for item_255 in var_253 {
{
array_254.value().string(item_255.as_str());
}
}
array_254.finish();
}
if let Some(var_256) = &input.ec2_tag_set {
#[allow(unused_mut)]
let mut object_257 = object.key("ec2TagSet").start_object();
crate::json_ser::serialize_structure_crate_model_ec2_tag_set(&mut object_257, var_256)?;
object_257.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::error::SerializationError> {
if input.enabled {
object.key("enabled").boolean(input.enabled);
}
if let Some(var_258) = &input.events {
let mut array_259 = object.key("events").start_array();
for item_260 in var_258 {
{
array_259.value().string(item_260.as_str());
}
}
array_259.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::error::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_261) = &input.alarms {
let mut array_262 = object.key("alarms").start_array();
for item_263 in var_261 {
{
#[allow(unused_mut)]
let mut object_264 = array_262.value().start_object();
crate::json_ser::serialize_structure_crate_model_alarm(&mut object_264, item_263)?;
object_264.finish();
}
}
array_262.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::error::SerializationError> {
if let Some(var_265) = &input.r#type {
object.key("type").string(var_265.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::error::SerializationError> {
if let Some(var_266) = &input.r#type {
object.key("type").string(var_266.as_str());
}
if let Some(var_267) = &input.time_based_canary {
#[allow(unused_mut)]
let mut object_268 = object.key("timeBasedCanary").start_object();
crate::json_ser::serialize_structure_crate_model_time_based_canary(
&mut object_268,
var_267,
)?;
object_268.finish();
}
if let Some(var_269) = &input.time_based_linear {
#[allow(unused_mut)]
let mut object_270 = object.key("timeBasedLinear").start_object();
crate::json_ser::serialize_structure_crate_model_time_based_linear(
&mut object_270,
var_269,
)?;
object_270.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::error::SerializationError> {
if let Some(var_271) = &input.key {
object.key("Key").string(var_271.as_str());
}
if let Some(var_272) = &input.value {
object.key("Value").string(var_272.as_str());
}
if let Some(var_273) = &input.r#type {
object.key("Type").string(var_273.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::error::SerializationError> {
if let Some(var_274) = &input.key {
object.key("Key").string(var_274.as_str());
}
if let Some(var_275) = &input.value {
object.key("Value").string(var_275.as_str());
}
if let Some(var_276) = &input.r#type {
object.key("Type").string(var_276.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::error::SerializationError> {
if let Some(var_277) = &input.trigger_name {
object.key("triggerName").string(var_277.as_str());
}
if let Some(var_278) = &input.trigger_target_arn {
object.key("triggerTargetArn").string(var_278.as_str());
}
if let Some(var_279) = &input.trigger_events {
let mut array_280 = object.key("triggerEvents").start_array();
for item_281 in var_279 {
{
array_280.value().string(item_281.as_str());
}
}
array_280.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::error::SerializationError> {
if let Some(var_282) = &input.deployment_type {
object.key("deploymentType").string(var_282.as_str());
}
if let Some(var_283) = &input.deployment_option {
object.key("deploymentOption").string(var_283.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::error::SerializationError> {
if let Some(var_284) = &input.terminate_blue_instances_on_deployment_success {
#[allow(unused_mut)]
let mut object_285 = object
.key("terminateBlueInstancesOnDeploymentSuccess")
.start_object();
crate::json_ser::serialize_structure_crate_model_blue_instance_termination_option(
&mut object_285,
var_284,
)?;
object_285.finish();
}
if let Some(var_286) = &input.deployment_ready_option {
#[allow(unused_mut)]
let mut object_287 = object.key("deploymentReadyOption").start_object();
crate::json_ser::serialize_structure_crate_model_deployment_ready_option(
&mut object_287,
var_286,
)?;
object_287.finish();
}
if let Some(var_288) = &input.green_fleet_provisioning_option {
#[allow(unused_mut)]
let mut object_289 = object.key("greenFleetProvisioningOption").start_object();
crate::json_ser::serialize_structure_crate_model_green_fleet_provisioning_option(
&mut object_289,
var_288,
)?;
object_289.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::error::SerializationError> {
if let Some(var_290) = &input.elb_info_list {
let mut array_291 = object.key("elbInfoList").start_array();
for item_292 in var_290 {
{
#[allow(unused_mut)]
let mut object_293 = array_291.value().start_object();
crate::json_ser::serialize_structure_crate_model_elb_info(
&mut object_293,
item_292,
)?;
object_293.finish();
}
}
array_291.finish();
}
if let Some(var_294) = &input.target_group_info_list {
let mut array_295 = object.key("targetGroupInfoList").start_array();
for item_296 in var_294 {
{
#[allow(unused_mut)]
let mut object_297 = array_295.value().start_object();
crate::json_ser::serialize_structure_crate_model_target_group_info(
&mut object_297,
item_296,
)?;
object_297.finish();
}
}
array_295.finish();
}
if let Some(var_298) = &input.target_group_pair_info_list {
let mut array_299 = object.key("targetGroupPairInfoList").start_array();
for item_300 in var_298 {
{
#[allow(unused_mut)]
let mut object_301 = array_299.value().start_object();
crate::json_ser::serialize_structure_crate_model_target_group_pair_info(
&mut object_301,
item_300,
)?;
object_301.finish();
}
}
array_299.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::error::SerializationError> {
if let Some(var_302) = &input.ec2_tag_set_list {
let mut array_303 = object.key("ec2TagSetList").start_array();
for item_304 in var_302 {
{
let mut array_305 = array_303.value().start_array();
for item_306 in item_304 {
{
#[allow(unused_mut)]
let mut object_307 = array_305.value().start_object();
crate::json_ser::serialize_structure_crate_model_ec2_tag_filter(
&mut object_307,
item_306,
)?;
object_307.finish();
}
}
array_305.finish();
}
}
array_303.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::error::SerializationError> {
if let Some(var_308) = &input.service_name {
object.key("serviceName").string(var_308.as_str());
}
if let Some(var_309) = &input.cluster_name {
object.key("clusterName").string(var_309.as_str());
}
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::error::SerializationError> {
if let Some(var_310) = &input.on_premises_tag_set_list {
let mut array_311 = object.key("onPremisesTagSetList").start_array();
for item_312 in var_310 {
{
let mut array_313 = array_311.value().start_array();
for item_314 in item_312 {
{
#[allow(unused_mut)]
let mut object_315 = array_313.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag_filter(
&mut object_315,
item_314,
)?;
object_315.finish();
}
}
array_313.finish();
}
}
array_311.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::error::SerializationError> {
if let Some(var_316) = &input.start {
object
.key("start")
.date_time(var_316, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_317) = &input.end {
object
.key("end")
.date_time(var_317, 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::error::SerializationError> {
if let Some(var_318) = &input.bucket {
object.key("bucket").string(var_318.as_str());
}
if let Some(var_319) = &input.key {
object.key("key").string(var_319.as_str());
}
if let Some(var_320) = &input.bundle_type {
object.key("bundleType").string(var_320.as_str());
}
if let Some(var_321) = &input.version {
object.key("version").string(var_321.as_str());
}
if let Some(var_322) = &input.e_tag {
object.key("eTag").string(var_322.as_str());
}
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::error::SerializationError> {
if let Some(var_323) = &input.repository {
object.key("repository").string(var_323.as_str());
}
if let Some(var_324) = &input.commit_id {
object.key("commitId").string(var_324.as_str());
}
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::error::SerializationError> {
if let Some(var_325) = &input.content {
object.key("content").string(var_325.as_str());
}
if let Some(var_326) = &input.sha256 {
object.key("sha256").string(var_326.as_str());
}
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::error::SerializationError> {
if let Some(var_327) = &input.content {
object.key("content").string(var_327.as_str());
}
if let Some(var_328) = &input.sha256 {
object.key("sha256").string(var_328.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_alarm(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Alarm,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_329) = &input.name {
object.key("name").string(var_329.as_str());
}
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::error::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::error::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_blue_instance_termination_option(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BlueInstanceTerminationOption,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_330) = &input.action {
object.key("action").string(var_330.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::error::SerializationError> {
if let Some(var_331) = &input.action_on_timeout {
object.key("actionOnTimeout").string(var_331.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::error::SerializationError> {
if let Some(var_332) = &input.action {
object.key("action").string(var_332.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::error::SerializationError> {
if let Some(var_333) = &input.name {
object.key("name").string(var_333.as_str());
}
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::error::SerializationError> {
if let Some(var_334) = &input.name {
object.key("name").string(var_334.as_str());
}
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::error::SerializationError> {
if let Some(var_335) = &input.target_groups {
let mut array_336 = object.key("targetGroups").start_array();
for item_337 in var_335 {
{
#[allow(unused_mut)]
let mut object_338 = array_336.value().start_object();
crate::json_ser::serialize_structure_crate_model_target_group_info(
&mut object_338,
item_337,
)?;
object_338.finish();
}
}
array_336.finish();
}
if let Some(var_339) = &input.prod_traffic_route {
#[allow(unused_mut)]
let mut object_340 = object.key("prodTrafficRoute").start_object();
crate::json_ser::serialize_structure_crate_model_traffic_route(&mut object_340, var_339)?;
object_340.finish();
}
if let Some(var_341) = &input.test_traffic_route {
#[allow(unused_mut)]
let mut object_342 = object.key("testTrafficRoute").start_object();
crate::json_ser::serialize_structure_crate_model_traffic_route(&mut object_342, var_341)?;
object_342.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::error::SerializationError> {
if let Some(var_343) = &input.listener_arns {
let mut array_344 = object.key("listenerArns").start_array();
for item_345 in var_343 {
{
array_344.value().string(item_345.as_str());
}
}
array_344.finish();
}
Ok(())
}