pub fn serialize_structure_crate_input_associate_custom_domain_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociateCustomDomainInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_1) = &input.service_arn {
object.key("ServiceArn").string(var_1);
}
if let Some(var_2) = &input.domain_name {
object.key("DomainName").string(var_2);
}
if let Some(var_3) = &input.enable_www_subdomain {
object.key("EnableWWWSubdomain").boolean(*var_3);
}
Ok(())
}
pub fn serialize_structure_crate_input_create_auto_scaling_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateAutoScalingConfigurationInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_4) = &input.auto_scaling_configuration_name {
object.key("AutoScalingConfigurationName").string(var_4);
}
if let Some(var_5) = &input.max_concurrency {
object.key("MaxConcurrency").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_5).into()),
);
}
if let Some(var_6) = &input.min_size {
object.key("MinSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_6).into()),
);
}
if let Some(var_7) = &input.max_size {
object.key("MaxSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_7).into()),
);
}
if let Some(var_8) = &input.tags {
let mut array_9 = object.key("Tags").start_array();
for item_10 in var_8 {
{
let mut object_11 = array_9.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_11, item_10)?;
object_11.finish();
}
}
array_9.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_connection_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateConnectionInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_12) = &input.connection_name {
object.key("ConnectionName").string(var_12);
}
if let Some(var_13) = &input.provider_type {
object.key("ProviderType").string(var_13.as_str());
}
if let Some(var_14) = &input.tags {
let mut array_15 = object.key("Tags").start_array();
for item_16 in var_14 {
{
let mut object_17 = array_15.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_17, item_16)?;
object_17.finish();
}
}
array_15.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_service_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateServiceInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_18) = &input.service_name {
object.key("ServiceName").string(var_18);
}
if let Some(var_19) = &input.source_configuration {
let mut object_20 = object.key("SourceConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_source_configuration(
&mut object_20,
var_19,
)?;
object_20.finish();
}
if let Some(var_21) = &input.instance_configuration {
let mut object_22 = object.key("InstanceConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_instance_configuration(
&mut object_22,
var_21,
)?;
object_22.finish();
}
if let Some(var_23) = &input.tags {
let mut array_24 = object.key("Tags").start_array();
for item_25 in var_23 {
{
let mut object_26 = array_24.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_26, item_25)?;
object_26.finish();
}
}
array_24.finish();
}
if let Some(var_27) = &input.encryption_configuration {
let mut object_28 = object.key("EncryptionConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_encryption_configuration(
&mut object_28,
var_27,
)?;
object_28.finish();
}
if let Some(var_29) = &input.health_check_configuration {
let mut object_30 = object.key("HealthCheckConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_health_check_configuration(
&mut object_30,
var_29,
)?;
object_30.finish();
}
if let Some(var_31) = &input.auto_scaling_configuration_arn {
object.key("AutoScalingConfigurationArn").string(var_31);
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_auto_scaling_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteAutoScalingConfigurationInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_32) = &input.auto_scaling_configuration_arn {
object.key("AutoScalingConfigurationArn").string(var_32);
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_connection_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteConnectionInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_33) = &input.connection_arn {
object.key("ConnectionArn").string(var_33);
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_service_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteServiceInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_34) = &input.service_arn {
object.key("ServiceArn").string(var_34);
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_auto_scaling_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeAutoScalingConfigurationInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_35) = &input.auto_scaling_configuration_arn {
object.key("AutoScalingConfigurationArn").string(var_35);
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_custom_domains_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeCustomDomainsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_36) = &input.service_arn {
object.key("ServiceArn").string(var_36);
}
if let Some(var_37) = &input.next_token {
object.key("NextToken").string(var_37);
}
if let Some(var_38) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_38).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_service_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeServiceInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_39) = &input.service_arn {
object.key("ServiceArn").string(var_39);
}
Ok(())
}
pub fn serialize_structure_crate_input_disassociate_custom_domain_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DisassociateCustomDomainInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_40) = &input.service_arn {
object.key("ServiceArn").string(var_40);
}
if let Some(var_41) = &input.domain_name {
object.key("DomainName").string(var_41);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_auto_scaling_configurations_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListAutoScalingConfigurationsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_42) = &input.auto_scaling_configuration_name {
object.key("AutoScalingConfigurationName").string(var_42);
}
if input.latest_only {
object.key("LatestOnly").boolean(input.latest_only);
}
if let Some(var_43) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_43).into()),
);
}
if let Some(var_44) = &input.next_token {
object.key("NextToken").string(var_44);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_connections_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListConnectionsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_45) = &input.connection_name {
object.key("ConnectionName").string(var_45);
}
if let Some(var_46) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_46).into()),
);
}
if let Some(var_47) = &input.next_token {
object.key("NextToken").string(var_47);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_operations_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListOperationsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_48) = &input.service_arn {
object.key("ServiceArn").string(var_48);
}
if let Some(var_49) = &input.next_token {
object.key("NextToken").string(var_49);
}
if let Some(var_50) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_50).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_services_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListServicesInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_51) = &input.next_token {
object.key("NextToken").string(var_51);
}
if let Some(var_52) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_52).into()),
);
}
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_53) = &input.resource_arn {
object.key("ResourceArn").string(var_53);
}
Ok(())
}
pub fn serialize_structure_crate_input_pause_service_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PauseServiceInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_54) = &input.service_arn {
object.key("ServiceArn").string(var_54);
}
Ok(())
}
pub fn serialize_structure_crate_input_resume_service_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ResumeServiceInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_55) = &input.service_arn {
object.key("ServiceArn").string(var_55);
}
Ok(())
}
pub fn serialize_structure_crate_input_start_deployment_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartDeploymentInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_56) = &input.service_arn {
object.key("ServiceArn").string(var_56);
}
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_57) = &input.resource_arn {
object.key("ResourceArn").string(var_57);
}
if let Some(var_58) = &input.tags {
let mut array_59 = object.key("Tags").start_array();
for item_60 in var_58 {
{
let mut object_61 = array_59.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_61, item_60)?;
object_61.finish();
}
}
array_59.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_62) = &input.resource_arn {
object.key("ResourceArn").string(var_62);
}
if let Some(var_63) = &input.tag_keys {
let mut array_64 = object.key("TagKeys").start_array();
for item_65 in var_63 {
{
array_64.value().string(item_65);
}
}
array_64.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_service_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateServiceInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_66) = &input.service_arn {
object.key("ServiceArn").string(var_66);
}
if let Some(var_67) = &input.source_configuration {
let mut object_68 = object.key("SourceConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_source_configuration(
&mut object_68,
var_67,
)?;
object_68.finish();
}
if let Some(var_69) = &input.instance_configuration {
let mut object_70 = object.key("InstanceConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_instance_configuration(
&mut object_70,
var_69,
)?;
object_70.finish();
}
if let Some(var_71) = &input.auto_scaling_configuration_arn {
object.key("AutoScalingConfigurationArn").string(var_71);
}
if let Some(var_72) = &input.health_check_configuration {
let mut object_73 = object.key("HealthCheckConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_health_check_configuration(
&mut object_73,
var_72,
)?;
object_73.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_74) = &input.key {
object.key("Key").string(var_74);
}
if let Some(var_75) = &input.value {
object.key("Value").string(var_75);
}
Ok(())
}
pub fn serialize_structure_crate_model_source_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SourceConfiguration,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_76) = &input.code_repository {
let mut object_77 = object.key("CodeRepository").start_object();
crate::json_ser::serialize_structure_crate_model_code_repository(&mut object_77, var_76)?;
object_77.finish();
}
if let Some(var_78) = &input.image_repository {
let mut object_79 = object.key("ImageRepository").start_object();
crate::json_ser::serialize_structure_crate_model_image_repository(&mut object_79, var_78)?;
object_79.finish();
}
if let Some(var_80) = &input.auto_deployments_enabled {
object.key("AutoDeploymentsEnabled").boolean(*var_80);
}
if let Some(var_81) = &input.authentication_configuration {
let mut object_82 = object.key("AuthenticationConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_authentication_configuration(
&mut object_82,
var_81,
)?;
object_82.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_instance_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::InstanceConfiguration,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_83) = &input.cpu {
object.key("Cpu").string(var_83);
}
if let Some(var_84) = &input.memory {
object.key("Memory").string(var_84);
}
if let Some(var_85) = &input.instance_role_arn {
object.key("InstanceRoleArn").string(var_85);
}
Ok(())
}
pub fn serialize_structure_crate_model_encryption_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EncryptionConfiguration,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_86) = &input.kms_key {
object.key("KmsKey").string(var_86);
}
Ok(())
}
pub fn serialize_structure_crate_model_health_check_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::HealthCheckConfiguration,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_87) = &input.protocol {
object.key("Protocol").string(var_87.as_str());
}
if let Some(var_88) = &input.path {
object.key("Path").string(var_88);
}
if let Some(var_89) = &input.interval {
object.key("Interval").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_89).into()),
);
}
if let Some(var_90) = &input.timeout {
object.key("Timeout").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_90).into()),
);
}
if let Some(var_91) = &input.healthy_threshold {
object.key("HealthyThreshold").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_91).into()),
);
}
if let Some(var_92) = &input.unhealthy_threshold {
object.key("UnhealthyThreshold").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_92).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_code_repository(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CodeRepository,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_93) = &input.repository_url {
object.key("RepositoryUrl").string(var_93);
}
if let Some(var_94) = &input.source_code_version {
let mut object_95 = object.key("SourceCodeVersion").start_object();
crate::json_ser::serialize_structure_crate_model_source_code_version(
&mut object_95,
var_94,
)?;
object_95.finish();
}
if let Some(var_96) = &input.code_configuration {
let mut object_97 = object.key("CodeConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_code_configuration(
&mut object_97,
var_96,
)?;
object_97.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_image_repository(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ImageRepository,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_98) = &input.image_identifier {
object.key("ImageIdentifier").string(var_98);
}
if let Some(var_99) = &input.image_configuration {
let mut object_100 = object.key("ImageConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_image_configuration(
&mut object_100,
var_99,
)?;
object_100.finish();
}
if let Some(var_101) = &input.image_repository_type {
object.key("ImageRepositoryType").string(var_101.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_authentication_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AuthenticationConfiguration,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_102) = &input.connection_arn {
object.key("ConnectionArn").string(var_102);
}
if let Some(var_103) = &input.access_role_arn {
object.key("AccessRoleArn").string(var_103);
}
Ok(())
}
pub fn serialize_structure_crate_model_source_code_version(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SourceCodeVersion,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_104) = &input.r#type {
object.key("Type").string(var_104.as_str());
}
if let Some(var_105) = &input.value {
object.key("Value").string(var_105);
}
Ok(())
}
pub fn serialize_structure_crate_model_code_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CodeConfiguration,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_106) = &input.configuration_source {
object.key("ConfigurationSource").string(var_106.as_str());
}
if let Some(var_107) = &input.code_configuration_values {
let mut object_108 = object.key("CodeConfigurationValues").start_object();
crate::json_ser::serialize_structure_crate_model_code_configuration_values(
&mut object_108,
var_107,
)?;
object_108.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_image_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ImageConfiguration,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_109) = &input.runtime_environment_variables {
let mut object_110 = object.key("RuntimeEnvironmentVariables").start_object();
for (key_111, value_112) in var_109 {
{
object_110.key(key_111).string(value_112);
}
}
object_110.finish();
}
if let Some(var_113) = &input.start_command {
object.key("StartCommand").string(var_113);
}
if let Some(var_114) = &input.port {
object.key("Port").string(var_114);
}
Ok(())
}
pub fn serialize_structure_crate_model_code_configuration_values(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CodeConfigurationValues,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_115) = &input.runtime {
object.key("Runtime").string(var_115.as_str());
}
if let Some(var_116) = &input.build_command {
object.key("BuildCommand").string(var_116);
}
if let Some(var_117) = &input.start_command {
object.key("StartCommand").string(var_117);
}
if let Some(var_118) = &input.port {
object.key("Port").string(var_118);
}
if let Some(var_119) = &input.runtime_environment_variables {
let mut object_120 = object.key("RuntimeEnvironmentVariables").start_object();
for (key_121, value_122) in var_119 {
{
object_120.key(key_121).string(value_122);
}
}
object_120.finish();
}
Ok(())
}