pub fn serialize_structure_crate_input_batch_delete_builds_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchDeleteBuildsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.ids {
let mut array_2 = object.key("ids").start_array();
for item_3 in var_1 {
{
array_2.value().string(item_3.as_str());
}
}
array_2.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_batch_get_build_batches_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchGetBuildBatchesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_4) = &input.ids {
let mut array_5 = object.key("ids").start_array();
for item_6 in var_4 {
{
array_5.value().string(item_6.as_str());
}
}
array_5.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_batch_get_builds_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchGetBuildsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_7) = &input.ids {
let mut array_8 = object.key("ids").start_array();
for item_9 in var_7 {
{
array_8.value().string(item_9.as_str());
}
}
array_8.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_batch_get_projects_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchGetProjectsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_10) = &input.names {
let mut array_11 = object.key("names").start_array();
for item_12 in var_10 {
{
array_11.value().string(item_12.as_str());
}
}
array_11.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_batch_get_report_groups_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchGetReportGroupsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_13) = &input.report_group_arns {
let mut array_14 = object.key("reportGroupArns").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_reports_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchGetReportsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_16) = &input.report_arns {
let mut array_17 = object.key("reportArns").start_array();
for item_18 in var_16 {
{
array_17.value().string(item_18.as_str());
}
}
array_17.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_project_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateProjectInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_19) = &input.name {
object.key("name").string(var_19.as_str());
}
if let Some(var_20) = &input.description {
object.key("description").string(var_20.as_str());
}
if let Some(var_21) = &input.source {
#[allow(unused_mut)]
let mut object_22 = object.key("source").start_object();
crate::json_ser::serialize_structure_crate_model_project_source(&mut object_22, var_21)?;
object_22.finish();
}
if let Some(var_23) = &input.secondary_sources {
let mut array_24 = object.key("secondarySources").start_array();
for item_25 in var_23 {
{
#[allow(unused_mut)]
let mut object_26 = array_24.value().start_object();
crate::json_ser::serialize_structure_crate_model_project_source(
&mut object_26,
item_25,
)?;
object_26.finish();
}
}
array_24.finish();
}
if let Some(var_27) = &input.source_version {
object.key("sourceVersion").string(var_27.as_str());
}
if let Some(var_28) = &input.secondary_source_versions {
let mut array_29 = object.key("secondarySourceVersions").start_array();
for item_30 in var_28 {
{
#[allow(unused_mut)]
let mut object_31 = array_29.value().start_object();
crate::json_ser::serialize_structure_crate_model_project_source_version(
&mut object_31,
item_30,
)?;
object_31.finish();
}
}
array_29.finish();
}
if let Some(var_32) = &input.artifacts {
#[allow(unused_mut)]
let mut object_33 = object.key("artifacts").start_object();
crate::json_ser::serialize_structure_crate_model_project_artifacts(&mut object_33, var_32)?;
object_33.finish();
}
if let Some(var_34) = &input.secondary_artifacts {
let mut array_35 = object.key("secondaryArtifacts").start_array();
for item_36 in var_34 {
{
#[allow(unused_mut)]
let mut object_37 = array_35.value().start_object();
crate::json_ser::serialize_structure_crate_model_project_artifacts(
&mut object_37,
item_36,
)?;
object_37.finish();
}
}
array_35.finish();
}
if let Some(var_38) = &input.cache {
#[allow(unused_mut)]
let mut object_39 = object.key("cache").start_object();
crate::json_ser::serialize_structure_crate_model_project_cache(&mut object_39, var_38)?;
object_39.finish();
}
if let Some(var_40) = &input.environment {
#[allow(unused_mut)]
let mut object_41 = object.key("environment").start_object();
crate::json_ser::serialize_structure_crate_model_project_environment(
&mut object_41,
var_40,
)?;
object_41.finish();
}
if let Some(var_42) = &input.service_role {
object.key("serviceRole").string(var_42.as_str());
}
if let Some(var_43) = &input.timeout_in_minutes {
object.key("timeoutInMinutes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_43).into()),
);
}
if let Some(var_44) = &input.queued_timeout_in_minutes {
object.key("queuedTimeoutInMinutes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_44).into()),
);
}
if let Some(var_45) = &input.encryption_key {
object.key("encryptionKey").string(var_45.as_str());
}
if let Some(var_46) = &input.tags {
let mut array_47 = object.key("tags").start_array();
for item_48 in var_46 {
{
#[allow(unused_mut)]
let mut object_49 = array_47.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_49, item_48)?;
object_49.finish();
}
}
array_47.finish();
}
if let Some(var_50) = &input.vpc_config {
#[allow(unused_mut)]
let mut object_51 = object.key("vpcConfig").start_object();
crate::json_ser::serialize_structure_crate_model_vpc_config(&mut object_51, var_50)?;
object_51.finish();
}
if let Some(var_52) = &input.badge_enabled {
object.key("badgeEnabled").boolean(*var_52);
}
if let Some(var_53) = &input.logs_config {
#[allow(unused_mut)]
let mut object_54 = object.key("logsConfig").start_object();
crate::json_ser::serialize_structure_crate_model_logs_config(&mut object_54, var_53)?;
object_54.finish();
}
if let Some(var_55) = &input.file_system_locations {
let mut array_56 = object.key("fileSystemLocations").start_array();
for item_57 in var_55 {
{
#[allow(unused_mut)]
let mut object_58 = array_56.value().start_object();
crate::json_ser::serialize_structure_crate_model_project_file_system_location(
&mut object_58,
item_57,
)?;
object_58.finish();
}
}
array_56.finish();
}
if let Some(var_59) = &input.build_batch_config {
#[allow(unused_mut)]
let mut object_60 = object.key("buildBatchConfig").start_object();
crate::json_ser::serialize_structure_crate_model_project_build_batch_config(
&mut object_60,
var_59,
)?;
object_60.finish();
}
if let Some(var_61) = &input.concurrent_build_limit {
object.key("concurrentBuildLimit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_61).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_create_report_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateReportGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_62) = &input.name {
object.key("name").string(var_62.as_str());
}
if let Some(var_63) = &input.r#type {
object.key("type").string(var_63.as_str());
}
if let Some(var_64) = &input.export_config {
#[allow(unused_mut)]
let mut object_65 = object.key("exportConfig").start_object();
crate::json_ser::serialize_structure_crate_model_report_export_config(
&mut object_65,
var_64,
)?;
object_65.finish();
}
if let Some(var_66) = &input.tags {
let mut array_67 = object.key("tags").start_array();
for item_68 in var_66 {
{
#[allow(unused_mut)]
let mut object_69 = array_67.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_69, item_68)?;
object_69.finish();
}
}
array_67.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_webhook_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateWebhookInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_70) = &input.project_name {
object.key("projectName").string(var_70.as_str());
}
if let Some(var_71) = &input.branch_filter {
object.key("branchFilter").string(var_71.as_str());
}
if let Some(var_72) = &input.filter_groups {
let mut array_73 = object.key("filterGroups").start_array();
for item_74 in var_72 {
{
let mut array_75 = array_73.value().start_array();
for item_76 in item_74 {
{
#[allow(unused_mut)]
let mut object_77 = array_75.value().start_object();
crate::json_ser::serialize_structure_crate_model_webhook_filter(
&mut object_77,
item_76,
)?;
object_77.finish();
}
}
array_75.finish();
}
}
array_73.finish();
}
if let Some(var_78) = &input.build_type {
object.key("buildType").string(var_78.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_build_batch_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteBuildBatchInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_79) = &input.id {
object.key("id").string(var_79.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_project_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteProjectInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_80) = &input.name {
object.key("name").string(var_80.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_report_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteReportInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_81) = &input.arn {
object.key("arn").string(var_81.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_report_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteReportGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_82) = &input.arn {
object.key("arn").string(var_82.as_str());
}
if input.delete_reports {
object.key("deleteReports").boolean(input.delete_reports);
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_resource_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteResourcePolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_83) = &input.resource_arn {
object.key("resourceArn").string(var_83.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_source_credentials_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteSourceCredentialsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_84) = &input.arn {
object.key("arn").string(var_84.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_webhook_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteWebhookInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_85) = &input.project_name {
object.key("projectName").string(var_85.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_code_coverages_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeCodeCoveragesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_86) = &input.report_arn {
object.key("reportArn").string(var_86.as_str());
}
if let Some(var_87) = &input.next_token {
object.key("nextToken").string(var_87.as_str());
}
if let Some(var_88) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_88).into()),
);
}
if let Some(var_89) = &input.sort_order {
object.key("sortOrder").string(var_89.as_str());
}
if let Some(var_90) = &input.sort_by {
object.key("sortBy").string(var_90.as_str());
}
if let Some(var_91) = &input.min_line_coverage_percentage {
object.key("minLineCoveragePercentage").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_91).into()),
);
}
if let Some(var_92) = &input.max_line_coverage_percentage {
object.key("maxLineCoveragePercentage").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_92).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_test_cases_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeTestCasesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_93) = &input.report_arn {
object.key("reportArn").string(var_93.as_str());
}
if let Some(var_94) = &input.next_token {
object.key("nextToken").string(var_94.as_str());
}
if let Some(var_95) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_95).into()),
);
}
if let Some(var_96) = &input.filter {
#[allow(unused_mut)]
let mut object_97 = object.key("filter").start_object();
crate::json_ser::serialize_structure_crate_model_test_case_filter(&mut object_97, var_96)?;
object_97.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_get_report_group_trend_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetReportGroupTrendInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_98) = &input.report_group_arn {
object.key("reportGroupArn").string(var_98.as_str());
}
if let Some(var_99) = &input.num_of_reports {
object.key("numOfReports").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_99).into()),
);
}
if let Some(var_100) = &input.trend_field {
object.key("trendField").string(var_100.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_resource_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetResourcePolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_101) = &input.resource_arn {
object.key("resourceArn").string(var_101.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_import_source_credentials_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ImportSourceCredentialsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_102) = &input.username {
object.key("username").string(var_102.as_str());
}
if let Some(var_103) = &input.token {
object.key("token").string(var_103.as_str());
}
if let Some(var_104) = &input.server_type {
object.key("serverType").string(var_104.as_str());
}
if let Some(var_105) = &input.auth_type {
object.key("authType").string(var_105.as_str());
}
if let Some(var_106) = &input.should_overwrite {
object.key("shouldOverwrite").boolean(*var_106);
}
Ok(())
}
pub fn serialize_structure_crate_input_invalidate_project_cache_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::InvalidateProjectCacheInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_107) = &input.project_name {
object.key("projectName").string(var_107.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_build_batches_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListBuildBatchesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_108) = &input.filter {
#[allow(unused_mut)]
let mut object_109 = object.key("filter").start_object();
crate::json_ser::serialize_structure_crate_model_build_batch_filter(
&mut object_109,
var_108,
)?;
object_109.finish();
}
if let Some(var_110) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_110).into()),
);
}
if let Some(var_111) = &input.sort_order {
object.key("sortOrder").string(var_111.as_str());
}
if let Some(var_112) = &input.next_token {
object.key("nextToken").string(var_112.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_build_batches_for_project_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListBuildBatchesForProjectInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_113) = &input.project_name {
object.key("projectName").string(var_113.as_str());
}
if let Some(var_114) = &input.filter {
#[allow(unused_mut)]
let mut object_115 = object.key("filter").start_object();
crate::json_ser::serialize_structure_crate_model_build_batch_filter(
&mut object_115,
var_114,
)?;
object_115.finish();
}
if let Some(var_116) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_116).into()),
);
}
if let Some(var_117) = &input.sort_order {
object.key("sortOrder").string(var_117.as_str());
}
if let Some(var_118) = &input.next_token {
object.key("nextToken").string(var_118.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_builds_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListBuildsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_119) = &input.sort_order {
object.key("sortOrder").string(var_119.as_str());
}
if let Some(var_120) = &input.next_token {
object.key("nextToken").string(var_120.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_builds_for_project_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListBuildsForProjectInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_121) = &input.project_name {
object.key("projectName").string(var_121.as_str());
}
if let Some(var_122) = &input.sort_order {
object.key("sortOrder").string(var_122.as_str());
}
if let Some(var_123) = &input.next_token {
object.key("nextToken").string(var_123.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_projects_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListProjectsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
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.next_token {
object.key("nextToken").string(var_126.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_report_groups_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListReportGroupsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_127) = &input.sort_order {
object.key("sortOrder").string(var_127.as_str());
}
if let Some(var_128) = &input.sort_by {
object.key("sortBy").string(var_128.as_str());
}
if let Some(var_129) = &input.next_token {
object.key("nextToken").string(var_129.as_str());
}
if let Some(var_130) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_130).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_reports_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListReportsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_131) = &input.sort_order {
object.key("sortOrder").string(var_131.as_str());
}
if let Some(var_132) = &input.next_token {
object.key("nextToken").string(var_132.as_str());
}
if let Some(var_133) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_133).into()),
);
}
if let Some(var_134) = &input.filter {
#[allow(unused_mut)]
let mut object_135 = object.key("filter").start_object();
crate::json_ser::serialize_structure_crate_model_report_filter(&mut object_135, var_134)?;
object_135.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_reports_for_report_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListReportsForReportGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_136) = &input.report_group_arn {
object.key("reportGroupArn").string(var_136.as_str());
}
if let Some(var_137) = &input.next_token {
object.key("nextToken").string(var_137.as_str());
}
if let Some(var_138) = &input.sort_order {
object.key("sortOrder").string(var_138.as_str());
}
if let Some(var_139) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_139).into()),
);
}
if let Some(var_140) = &input.filter {
#[allow(unused_mut)]
let mut object_141 = object.key("filter").start_object();
crate::json_ser::serialize_structure_crate_model_report_filter(&mut object_141, var_140)?;
object_141.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_shared_projects_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListSharedProjectsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_142) = &input.sort_by {
object.key("sortBy").string(var_142.as_str());
}
if let Some(var_143) = &input.sort_order {
object.key("sortOrder").string(var_143.as_str());
}
if let Some(var_144) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_144).into()),
);
}
if let Some(var_145) = &input.next_token {
object.key("nextToken").string(var_145.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_shared_report_groups_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListSharedReportGroupsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_146) = &input.sort_order {
object.key("sortOrder").string(var_146.as_str());
}
if let Some(var_147) = &input.sort_by {
object.key("sortBy").string(var_147.as_str());
}
if let Some(var_148) = &input.next_token {
object.key("nextToken").string(var_148.as_str());
}
if let Some(var_149) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_149).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_put_resource_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutResourcePolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_150) = &input.policy {
object.key("policy").string(var_150.as_str());
}
if let Some(var_151) = &input.resource_arn {
object.key("resourceArn").string(var_151.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_retry_build_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RetryBuildInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_152) = &input.id {
object.key("id").string(var_152.as_str());
}
if let Some(var_153) = &input.idempotency_token {
object.key("idempotencyToken").string(var_153.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_retry_build_batch_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RetryBuildBatchInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_154) = &input.id {
object.key("id").string(var_154.as_str());
}
if let Some(var_155) = &input.idempotency_token {
object.key("idempotencyToken").string(var_155.as_str());
}
if let Some(var_156) = &input.retry_type {
object.key("retryType").string(var_156.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_start_build_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartBuildInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_157) = &input.project_name {
object.key("projectName").string(var_157.as_str());
}
if let Some(var_158) = &input.secondary_sources_override {
let mut array_159 = object.key("secondarySourcesOverride").start_array();
for item_160 in var_158 {
{
#[allow(unused_mut)]
let mut object_161 = array_159.value().start_object();
crate::json_ser::serialize_structure_crate_model_project_source(
&mut object_161,
item_160,
)?;
object_161.finish();
}
}
array_159.finish();
}
if let Some(var_162) = &input.secondary_sources_version_override {
let mut array_163 = object.key("secondarySourcesVersionOverride").start_array();
for item_164 in var_162 {
{
#[allow(unused_mut)]
let mut object_165 = array_163.value().start_object();
crate::json_ser::serialize_structure_crate_model_project_source_version(
&mut object_165,
item_164,
)?;
object_165.finish();
}
}
array_163.finish();
}
if let Some(var_166) = &input.source_version {
object.key("sourceVersion").string(var_166.as_str());
}
if let Some(var_167) = &input.artifacts_override {
#[allow(unused_mut)]
let mut object_168 = object.key("artifactsOverride").start_object();
crate::json_ser::serialize_structure_crate_model_project_artifacts(
&mut object_168,
var_167,
)?;
object_168.finish();
}
if let Some(var_169) = &input.secondary_artifacts_override {
let mut array_170 = object.key("secondaryArtifactsOverride").start_array();
for item_171 in var_169 {
{
#[allow(unused_mut)]
let mut object_172 = array_170.value().start_object();
crate::json_ser::serialize_structure_crate_model_project_artifacts(
&mut object_172,
item_171,
)?;
object_172.finish();
}
}
array_170.finish();
}
if let Some(var_173) = &input.environment_variables_override {
let mut array_174 = object.key("environmentVariablesOverride").start_array();
for item_175 in var_173 {
{
#[allow(unused_mut)]
let mut object_176 = array_174.value().start_object();
crate::json_ser::serialize_structure_crate_model_environment_variable(
&mut object_176,
item_175,
)?;
object_176.finish();
}
}
array_174.finish();
}
if let Some(var_177) = &input.source_type_override {
object.key("sourceTypeOverride").string(var_177.as_str());
}
if let Some(var_178) = &input.source_location_override {
object
.key("sourceLocationOverride")
.string(var_178.as_str());
}
if let Some(var_179) = &input.source_auth_override {
#[allow(unused_mut)]
let mut object_180 = object.key("sourceAuthOverride").start_object();
crate::json_ser::serialize_structure_crate_model_source_auth(&mut object_180, var_179)?;
object_180.finish();
}
if let Some(var_181) = &input.git_clone_depth_override {
object.key("gitCloneDepthOverride").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_181).into()),
);
}
if let Some(var_182) = &input.git_submodules_config_override {
#[allow(unused_mut)]
let mut object_183 = object.key("gitSubmodulesConfigOverride").start_object();
crate::json_ser::serialize_structure_crate_model_git_submodules_config(
&mut object_183,
var_182,
)?;
object_183.finish();
}
if let Some(var_184) = &input.buildspec_override {
object.key("buildspecOverride").string(var_184.as_str());
}
if let Some(var_185) = &input.insecure_ssl_override {
object.key("insecureSslOverride").boolean(*var_185);
}
if let Some(var_186) = &input.report_build_status_override {
object.key("reportBuildStatusOverride").boolean(*var_186);
}
if let Some(var_187) = &input.build_status_config_override {
#[allow(unused_mut)]
let mut object_188 = object.key("buildStatusConfigOverride").start_object();
crate::json_ser::serialize_structure_crate_model_build_status_config(
&mut object_188,
var_187,
)?;
object_188.finish();
}
if let Some(var_189) = &input.environment_type_override {
object
.key("environmentTypeOverride")
.string(var_189.as_str());
}
if let Some(var_190) = &input.image_override {
object.key("imageOverride").string(var_190.as_str());
}
if let Some(var_191) = &input.compute_type_override {
object.key("computeTypeOverride").string(var_191.as_str());
}
if let Some(var_192) = &input.certificate_override {
object.key("certificateOverride").string(var_192.as_str());
}
if let Some(var_193) = &input.cache_override {
#[allow(unused_mut)]
let mut object_194 = object.key("cacheOverride").start_object();
crate::json_ser::serialize_structure_crate_model_project_cache(&mut object_194, var_193)?;
object_194.finish();
}
if let Some(var_195) = &input.service_role_override {
object.key("serviceRoleOverride").string(var_195.as_str());
}
if let Some(var_196) = &input.privileged_mode_override {
object.key("privilegedModeOverride").boolean(*var_196);
}
if let Some(var_197) = &input.timeout_in_minutes_override {
object.key("timeoutInMinutesOverride").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_197).into()),
);
}
if let Some(var_198) = &input.queued_timeout_in_minutes_override {
object.key("queuedTimeoutInMinutesOverride").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_198).into()),
);
}
if let Some(var_199) = &input.encryption_key_override {
object.key("encryptionKeyOverride").string(var_199.as_str());
}
if let Some(var_200) = &input.idempotency_token {
object.key("idempotencyToken").string(var_200.as_str());
}
if let Some(var_201) = &input.logs_config_override {
#[allow(unused_mut)]
let mut object_202 = object.key("logsConfigOverride").start_object();
crate::json_ser::serialize_structure_crate_model_logs_config(&mut object_202, var_201)?;
object_202.finish();
}
if let Some(var_203) = &input.registry_credential_override {
#[allow(unused_mut)]
let mut object_204 = object.key("registryCredentialOverride").start_object();
crate::json_ser::serialize_structure_crate_model_registry_credential(
&mut object_204,
var_203,
)?;
object_204.finish();
}
if let Some(var_205) = &input.image_pull_credentials_type_override {
object
.key("imagePullCredentialsTypeOverride")
.string(var_205.as_str());
}
if let Some(var_206) = &input.debug_session_enabled {
object.key("debugSessionEnabled").boolean(*var_206);
}
Ok(())
}
pub fn serialize_structure_crate_input_start_build_batch_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartBuildBatchInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_207) = &input.project_name {
object.key("projectName").string(var_207.as_str());
}
if let Some(var_208) = &input.secondary_sources_override {
let mut array_209 = object.key("secondarySourcesOverride").start_array();
for item_210 in var_208 {
{
#[allow(unused_mut)]
let mut object_211 = array_209.value().start_object();
crate::json_ser::serialize_structure_crate_model_project_source(
&mut object_211,
item_210,
)?;
object_211.finish();
}
}
array_209.finish();
}
if let Some(var_212) = &input.secondary_sources_version_override {
let mut array_213 = object.key("secondarySourcesVersionOverride").start_array();
for item_214 in var_212 {
{
#[allow(unused_mut)]
let mut object_215 = array_213.value().start_object();
crate::json_ser::serialize_structure_crate_model_project_source_version(
&mut object_215,
item_214,
)?;
object_215.finish();
}
}
array_213.finish();
}
if let Some(var_216) = &input.source_version {
object.key("sourceVersion").string(var_216.as_str());
}
if let Some(var_217) = &input.artifacts_override {
#[allow(unused_mut)]
let mut object_218 = object.key("artifactsOverride").start_object();
crate::json_ser::serialize_structure_crate_model_project_artifacts(
&mut object_218,
var_217,
)?;
object_218.finish();
}
if let Some(var_219) = &input.secondary_artifacts_override {
let mut array_220 = object.key("secondaryArtifactsOverride").start_array();
for item_221 in var_219 {
{
#[allow(unused_mut)]
let mut object_222 = array_220.value().start_object();
crate::json_ser::serialize_structure_crate_model_project_artifacts(
&mut object_222,
item_221,
)?;
object_222.finish();
}
}
array_220.finish();
}
if let Some(var_223) = &input.environment_variables_override {
let mut array_224 = object.key("environmentVariablesOverride").start_array();
for item_225 in var_223 {
{
#[allow(unused_mut)]
let mut object_226 = array_224.value().start_object();
crate::json_ser::serialize_structure_crate_model_environment_variable(
&mut object_226,
item_225,
)?;
object_226.finish();
}
}
array_224.finish();
}
if let Some(var_227) = &input.source_type_override {
object.key("sourceTypeOverride").string(var_227.as_str());
}
if let Some(var_228) = &input.source_location_override {
object
.key("sourceLocationOverride")
.string(var_228.as_str());
}
if let Some(var_229) = &input.source_auth_override {
#[allow(unused_mut)]
let mut object_230 = object.key("sourceAuthOverride").start_object();
crate::json_ser::serialize_structure_crate_model_source_auth(&mut object_230, var_229)?;
object_230.finish();
}
if let Some(var_231) = &input.git_clone_depth_override {
object.key("gitCloneDepthOverride").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_231).into()),
);
}
if let Some(var_232) = &input.git_submodules_config_override {
#[allow(unused_mut)]
let mut object_233 = object.key("gitSubmodulesConfigOverride").start_object();
crate::json_ser::serialize_structure_crate_model_git_submodules_config(
&mut object_233,
var_232,
)?;
object_233.finish();
}
if let Some(var_234) = &input.buildspec_override {
object.key("buildspecOverride").string(var_234.as_str());
}
if let Some(var_235) = &input.insecure_ssl_override {
object.key("insecureSslOverride").boolean(*var_235);
}
if let Some(var_236) = &input.report_build_batch_status_override {
object
.key("reportBuildBatchStatusOverride")
.boolean(*var_236);
}
if let Some(var_237) = &input.environment_type_override {
object
.key("environmentTypeOverride")
.string(var_237.as_str());
}
if let Some(var_238) = &input.image_override {
object.key("imageOverride").string(var_238.as_str());
}
if let Some(var_239) = &input.compute_type_override {
object.key("computeTypeOverride").string(var_239.as_str());
}
if let Some(var_240) = &input.certificate_override {
object.key("certificateOverride").string(var_240.as_str());
}
if let Some(var_241) = &input.cache_override {
#[allow(unused_mut)]
let mut object_242 = object.key("cacheOverride").start_object();
crate::json_ser::serialize_structure_crate_model_project_cache(&mut object_242, var_241)?;
object_242.finish();
}
if let Some(var_243) = &input.service_role_override {
object.key("serviceRoleOverride").string(var_243.as_str());
}
if let Some(var_244) = &input.privileged_mode_override {
object.key("privilegedModeOverride").boolean(*var_244);
}
if let Some(var_245) = &input.build_timeout_in_minutes_override {
object.key("buildTimeoutInMinutesOverride").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_245).into()),
);
}
if let Some(var_246) = &input.queued_timeout_in_minutes_override {
object.key("queuedTimeoutInMinutesOverride").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_246).into()),
);
}
if let Some(var_247) = &input.encryption_key_override {
object.key("encryptionKeyOverride").string(var_247.as_str());
}
if let Some(var_248) = &input.idempotency_token {
object.key("idempotencyToken").string(var_248.as_str());
}
if let Some(var_249) = &input.logs_config_override {
#[allow(unused_mut)]
let mut object_250 = object.key("logsConfigOverride").start_object();
crate::json_ser::serialize_structure_crate_model_logs_config(&mut object_250, var_249)?;
object_250.finish();
}
if let Some(var_251) = &input.registry_credential_override {
#[allow(unused_mut)]
let mut object_252 = object.key("registryCredentialOverride").start_object();
crate::json_ser::serialize_structure_crate_model_registry_credential(
&mut object_252,
var_251,
)?;
object_252.finish();
}
if let Some(var_253) = &input.image_pull_credentials_type_override {
object
.key("imagePullCredentialsTypeOverride")
.string(var_253.as_str());
}
if let Some(var_254) = &input.build_batch_config_override {
#[allow(unused_mut)]
let mut object_255 = object.key("buildBatchConfigOverride").start_object();
crate::json_ser::serialize_structure_crate_model_project_build_batch_config(
&mut object_255,
var_254,
)?;
object_255.finish();
}
if let Some(var_256) = &input.debug_session_enabled {
object.key("debugSessionEnabled").boolean(*var_256);
}
Ok(())
}
pub fn serialize_structure_crate_input_stop_build_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StopBuildInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_257) = &input.id {
object.key("id").string(var_257.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_stop_build_batch_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StopBuildBatchInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_258) = &input.id {
object.key("id").string(var_258.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_project_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateProjectInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_259) = &input.name {
object.key("name").string(var_259.as_str());
}
if let Some(var_260) = &input.description {
object.key("description").string(var_260.as_str());
}
if let Some(var_261) = &input.source {
#[allow(unused_mut)]
let mut object_262 = object.key("source").start_object();
crate::json_ser::serialize_structure_crate_model_project_source(&mut object_262, var_261)?;
object_262.finish();
}
if let Some(var_263) = &input.secondary_sources {
let mut array_264 = object.key("secondarySources").start_array();
for item_265 in var_263 {
{
#[allow(unused_mut)]
let mut object_266 = array_264.value().start_object();
crate::json_ser::serialize_structure_crate_model_project_source(
&mut object_266,
item_265,
)?;
object_266.finish();
}
}
array_264.finish();
}
if let Some(var_267) = &input.source_version {
object.key("sourceVersion").string(var_267.as_str());
}
if let Some(var_268) = &input.secondary_source_versions {
let mut array_269 = object.key("secondarySourceVersions").start_array();
for item_270 in var_268 {
{
#[allow(unused_mut)]
let mut object_271 = array_269.value().start_object();
crate::json_ser::serialize_structure_crate_model_project_source_version(
&mut object_271,
item_270,
)?;
object_271.finish();
}
}
array_269.finish();
}
if let Some(var_272) = &input.artifacts {
#[allow(unused_mut)]
let mut object_273 = object.key("artifacts").start_object();
crate::json_ser::serialize_structure_crate_model_project_artifacts(
&mut object_273,
var_272,
)?;
object_273.finish();
}
if let Some(var_274) = &input.secondary_artifacts {
let mut array_275 = object.key("secondaryArtifacts").start_array();
for item_276 in var_274 {
{
#[allow(unused_mut)]
let mut object_277 = array_275.value().start_object();
crate::json_ser::serialize_structure_crate_model_project_artifacts(
&mut object_277,
item_276,
)?;
object_277.finish();
}
}
array_275.finish();
}
if let Some(var_278) = &input.cache {
#[allow(unused_mut)]
let mut object_279 = object.key("cache").start_object();
crate::json_ser::serialize_structure_crate_model_project_cache(&mut object_279, var_278)?;
object_279.finish();
}
if let Some(var_280) = &input.environment {
#[allow(unused_mut)]
let mut object_281 = object.key("environment").start_object();
crate::json_ser::serialize_structure_crate_model_project_environment(
&mut object_281,
var_280,
)?;
object_281.finish();
}
if let Some(var_282) = &input.service_role {
object.key("serviceRole").string(var_282.as_str());
}
if let Some(var_283) = &input.timeout_in_minutes {
object.key("timeoutInMinutes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_283).into()),
);
}
if let Some(var_284) = &input.queued_timeout_in_minutes {
object.key("queuedTimeoutInMinutes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_284).into()),
);
}
if let Some(var_285) = &input.encryption_key {
object.key("encryptionKey").string(var_285.as_str());
}
if let Some(var_286) = &input.tags {
let mut array_287 = object.key("tags").start_array();
for item_288 in var_286 {
{
#[allow(unused_mut)]
let mut object_289 = array_287.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_289, item_288)?;
object_289.finish();
}
}
array_287.finish();
}
if let Some(var_290) = &input.vpc_config {
#[allow(unused_mut)]
let mut object_291 = object.key("vpcConfig").start_object();
crate::json_ser::serialize_structure_crate_model_vpc_config(&mut object_291, var_290)?;
object_291.finish();
}
if let Some(var_292) = &input.badge_enabled {
object.key("badgeEnabled").boolean(*var_292);
}
if let Some(var_293) = &input.logs_config {
#[allow(unused_mut)]
let mut object_294 = object.key("logsConfig").start_object();
crate::json_ser::serialize_structure_crate_model_logs_config(&mut object_294, var_293)?;
object_294.finish();
}
if let Some(var_295) = &input.file_system_locations {
let mut array_296 = object.key("fileSystemLocations").start_array();
for item_297 in var_295 {
{
#[allow(unused_mut)]
let mut object_298 = array_296.value().start_object();
crate::json_ser::serialize_structure_crate_model_project_file_system_location(
&mut object_298,
item_297,
)?;
object_298.finish();
}
}
array_296.finish();
}
if let Some(var_299) = &input.build_batch_config {
#[allow(unused_mut)]
let mut object_300 = object.key("buildBatchConfig").start_object();
crate::json_ser::serialize_structure_crate_model_project_build_batch_config(
&mut object_300,
var_299,
)?;
object_300.finish();
}
if let Some(var_301) = &input.concurrent_build_limit {
object.key("concurrentBuildLimit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_301).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_update_project_visibility_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateProjectVisibilityInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_302) = &input.project_arn {
object.key("projectArn").string(var_302.as_str());
}
if let Some(var_303) = &input.project_visibility {
object.key("projectVisibility").string(var_303.as_str());
}
if let Some(var_304) = &input.resource_access_role {
object.key("resourceAccessRole").string(var_304.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_report_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateReportGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_305) = &input.arn {
object.key("arn").string(var_305.as_str());
}
if let Some(var_306) = &input.export_config {
#[allow(unused_mut)]
let mut object_307 = object.key("exportConfig").start_object();
crate::json_ser::serialize_structure_crate_model_report_export_config(
&mut object_307,
var_306,
)?;
object_307.finish();
}
if let Some(var_308) = &input.tags {
let mut array_309 = object.key("tags").start_array();
for item_310 in var_308 {
{
#[allow(unused_mut)]
let mut object_311 = array_309.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_311, item_310)?;
object_311.finish();
}
}
array_309.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_webhook_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateWebhookInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_312) = &input.project_name {
object.key("projectName").string(var_312.as_str());
}
if let Some(var_313) = &input.branch_filter {
object.key("branchFilter").string(var_313.as_str());
}
if input.rotate_secret {
object.key("rotateSecret").boolean(input.rotate_secret);
}
if let Some(var_314) = &input.filter_groups {
let mut array_315 = object.key("filterGroups").start_array();
for item_316 in var_314 {
{
let mut array_317 = array_315.value().start_array();
for item_318 in item_316 {
{
#[allow(unused_mut)]
let mut object_319 = array_317.value().start_object();
crate::json_ser::serialize_structure_crate_model_webhook_filter(
&mut object_319,
item_318,
)?;
object_319.finish();
}
}
array_317.finish();
}
}
array_315.finish();
}
if let Some(var_320) = &input.build_type {
object.key("buildType").string(var_320.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_project_source(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ProjectSource,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_321) = &input.r#type {
object.key("type").string(var_321.as_str());
}
if let Some(var_322) = &input.location {
object.key("location").string(var_322.as_str());
}
if let Some(var_323) = &input.git_clone_depth {
object.key("gitCloneDepth").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_323).into()),
);
}
if let Some(var_324) = &input.git_submodules_config {
#[allow(unused_mut)]
let mut object_325 = object.key("gitSubmodulesConfig").start_object();
crate::json_ser::serialize_structure_crate_model_git_submodules_config(
&mut object_325,
var_324,
)?;
object_325.finish();
}
if let Some(var_326) = &input.buildspec {
object.key("buildspec").string(var_326.as_str());
}
if let Some(var_327) = &input.auth {
#[allow(unused_mut)]
let mut object_328 = object.key("auth").start_object();
crate::json_ser::serialize_structure_crate_model_source_auth(&mut object_328, var_327)?;
object_328.finish();
}
if let Some(var_329) = &input.report_build_status {
object.key("reportBuildStatus").boolean(*var_329);
}
if let Some(var_330) = &input.build_status_config {
#[allow(unused_mut)]
let mut object_331 = object.key("buildStatusConfig").start_object();
crate::json_ser::serialize_structure_crate_model_build_status_config(
&mut object_331,
var_330,
)?;
object_331.finish();
}
if let Some(var_332) = &input.insecure_ssl {
object.key("insecureSsl").boolean(*var_332);
}
if let Some(var_333) = &input.source_identifier {
object.key("sourceIdentifier").string(var_333.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_project_source_version(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ProjectSourceVersion,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_334) = &input.source_identifier {
object.key("sourceIdentifier").string(var_334.as_str());
}
if let Some(var_335) = &input.source_version {
object.key("sourceVersion").string(var_335.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_project_artifacts(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ProjectArtifacts,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_336) = &input.r#type {
object.key("type").string(var_336.as_str());
}
if let Some(var_337) = &input.location {
object.key("location").string(var_337.as_str());
}
if let Some(var_338) = &input.path {
object.key("path").string(var_338.as_str());
}
if let Some(var_339) = &input.namespace_type {
object.key("namespaceType").string(var_339.as_str());
}
if let Some(var_340) = &input.name {
object.key("name").string(var_340.as_str());
}
if let Some(var_341) = &input.packaging {
object.key("packaging").string(var_341.as_str());
}
if let Some(var_342) = &input.override_artifact_name {
object.key("overrideArtifactName").boolean(*var_342);
}
if let Some(var_343) = &input.encryption_disabled {
object.key("encryptionDisabled").boolean(*var_343);
}
if let Some(var_344) = &input.artifact_identifier {
object.key("artifactIdentifier").string(var_344.as_str());
}
if let Some(var_345) = &input.bucket_owner_access {
object.key("bucketOwnerAccess").string(var_345.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_project_cache(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ProjectCache,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_346) = &input.r#type {
object.key("type").string(var_346.as_str());
}
if let Some(var_347) = &input.location {
object.key("location").string(var_347.as_str());
}
if let Some(var_348) = &input.modes {
let mut array_349 = object.key("modes").start_array();
for item_350 in var_348 {
{
array_349.value().string(item_350.as_str());
}
}
array_349.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_project_environment(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ProjectEnvironment,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_351) = &input.r#type {
object.key("type").string(var_351.as_str());
}
if let Some(var_352) = &input.image {
object.key("image").string(var_352.as_str());
}
if let Some(var_353) = &input.compute_type {
object.key("computeType").string(var_353.as_str());
}
if let Some(var_354) = &input.environment_variables {
let mut array_355 = object.key("environmentVariables").start_array();
for item_356 in var_354 {
{
#[allow(unused_mut)]
let mut object_357 = array_355.value().start_object();
crate::json_ser::serialize_structure_crate_model_environment_variable(
&mut object_357,
item_356,
)?;
object_357.finish();
}
}
array_355.finish();
}
if let Some(var_358) = &input.privileged_mode {
object.key("privilegedMode").boolean(*var_358);
}
if let Some(var_359) = &input.certificate {
object.key("certificate").string(var_359.as_str());
}
if let Some(var_360) = &input.registry_credential {
#[allow(unused_mut)]
let mut object_361 = object.key("registryCredential").start_object();
crate::json_ser::serialize_structure_crate_model_registry_credential(
&mut object_361,
var_360,
)?;
object_361.finish();
}
if let Some(var_362) = &input.image_pull_credentials_type {
object
.key("imagePullCredentialsType")
.string(var_362.as_str());
}
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_363) = &input.key {
object.key("key").string(var_363.as_str());
}
if let Some(var_364) = &input.value {
object.key("value").string(var_364.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_vpc_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::VpcConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_365) = &input.vpc_id {
object.key("vpcId").string(var_365.as_str());
}
if let Some(var_366) = &input.subnets {
let mut array_367 = object.key("subnets").start_array();
for item_368 in var_366 {
{
array_367.value().string(item_368.as_str());
}
}
array_367.finish();
}
if let Some(var_369) = &input.security_group_ids {
let mut array_370 = object.key("securityGroupIds").start_array();
for item_371 in var_369 {
{
array_370.value().string(item_371.as_str());
}
}
array_370.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_logs_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LogsConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_372) = &input.cloud_watch_logs {
#[allow(unused_mut)]
let mut object_373 = object.key("cloudWatchLogs").start_object();
crate::json_ser::serialize_structure_crate_model_cloud_watch_logs_config(
&mut object_373,
var_372,
)?;
object_373.finish();
}
if let Some(var_374) = &input.s3_logs {
#[allow(unused_mut)]
let mut object_375 = object.key("s3Logs").start_object();
crate::json_ser::serialize_structure_crate_model_s3_logs_config(&mut object_375, var_374)?;
object_375.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_project_file_system_location(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ProjectFileSystemLocation,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_376) = &input.r#type {
object.key("type").string(var_376.as_str());
}
if let Some(var_377) = &input.location {
object.key("location").string(var_377.as_str());
}
if let Some(var_378) = &input.mount_point {
object.key("mountPoint").string(var_378.as_str());
}
if let Some(var_379) = &input.identifier {
object.key("identifier").string(var_379.as_str());
}
if let Some(var_380) = &input.mount_options {
object.key("mountOptions").string(var_380.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_project_build_batch_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ProjectBuildBatchConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_381) = &input.service_role {
object.key("serviceRole").string(var_381.as_str());
}
if let Some(var_382) = &input.combine_artifacts {
object.key("combineArtifacts").boolean(*var_382);
}
if let Some(var_383) = &input.restrictions {
#[allow(unused_mut)]
let mut object_384 = object.key("restrictions").start_object();
crate::json_ser::serialize_structure_crate_model_batch_restrictions(
&mut object_384,
var_383,
)?;
object_384.finish();
}
if let Some(var_385) = &input.timeout_in_mins {
object.key("timeoutInMins").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_385).into()),
);
}
if let Some(var_386) = &input.batch_report_mode {
object.key("batchReportMode").string(var_386.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_report_export_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ReportExportConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_387) = &input.export_config_type {
object.key("exportConfigType").string(var_387.as_str());
}
if let Some(var_388) = &input.s3_destination {
#[allow(unused_mut)]
let mut object_389 = object.key("s3Destination").start_object();
crate::json_ser::serialize_structure_crate_model_s3_report_export_config(
&mut object_389,
var_388,
)?;
object_389.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_webhook_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::WebhookFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_390) = &input.r#type {
object.key("type").string(var_390.as_str());
}
if let Some(var_391) = &input.pattern {
object.key("pattern").string(var_391.as_str());
}
if let Some(var_392) = &input.exclude_matched_pattern {
object.key("excludeMatchedPattern").boolean(*var_392);
}
Ok(())
}
pub fn serialize_structure_crate_model_test_case_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TestCaseFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_393) = &input.status {
object.key("status").string(var_393.as_str());
}
if let Some(var_394) = &input.keyword {
object.key("keyword").string(var_394.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_build_batch_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BuildBatchFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_395) = &input.status {
object.key("status").string(var_395.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_report_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ReportFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_396) = &input.status {
object.key("status").string(var_396.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_environment_variable(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EnvironmentVariable,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_397) = &input.name {
object.key("name").string(var_397.as_str());
}
if let Some(var_398) = &input.value {
object.key("value").string(var_398.as_str());
}
if let Some(var_399) = &input.r#type {
object.key("type").string(var_399.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_source_auth(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SourceAuth,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_400) = &input.r#type {
object.key("type").string(var_400.as_str());
}
if let Some(var_401) = &input.resource {
object.key("resource").string(var_401.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_git_submodules_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GitSubmodulesConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_402) = &input.fetch_submodules {
object.key("fetchSubmodules").boolean(*var_402);
}
Ok(())
}
pub fn serialize_structure_crate_model_build_status_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BuildStatusConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_403) = &input.context {
object.key("context").string(var_403.as_str());
}
if let Some(var_404) = &input.target_url {
object.key("targetUrl").string(var_404.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_registry_credential(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RegistryCredential,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_405) = &input.credential {
object.key("credential").string(var_405.as_str());
}
if let Some(var_406) = &input.credential_provider {
object.key("credentialProvider").string(var_406.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_cloud_watch_logs_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CloudWatchLogsConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_407) = &input.status {
object.key("status").string(var_407.as_str());
}
if let Some(var_408) = &input.group_name {
object.key("groupName").string(var_408.as_str());
}
if let Some(var_409) = &input.stream_name {
object.key("streamName").string(var_409.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_s3_logs_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::S3LogsConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_410) = &input.status {
object.key("status").string(var_410.as_str());
}
if let Some(var_411) = &input.location {
object.key("location").string(var_411.as_str());
}
if let Some(var_412) = &input.encryption_disabled {
object.key("encryptionDisabled").boolean(*var_412);
}
if let Some(var_413) = &input.bucket_owner_access {
object.key("bucketOwnerAccess").string(var_413.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_batch_restrictions(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BatchRestrictions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_414) = &input.maximum_builds_allowed {
object.key("maximumBuildsAllowed").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_414).into()),
);
}
if let Some(var_415) = &input.compute_types_allowed {
let mut array_416 = object.key("computeTypesAllowed").start_array();
for item_417 in var_415 {
{
array_416.value().string(item_417.as_str());
}
}
array_416.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_s3_report_export_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::S3ReportExportConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_418) = &input.bucket {
object.key("bucket").string(var_418.as_str());
}
if let Some(var_419) = &input.bucket_owner {
object.key("bucketOwner").string(var_419.as_str());
}
if let Some(var_420) = &input.path {
object.key("path").string(var_420.as_str());
}
if let Some(var_421) = &input.packaging {
object.key("packaging").string(var_421.as_str());
}
if let Some(var_422) = &input.encryption_key {
object.key("encryptionKey").string(var_422.as_str());
}
if let Some(var_423) = &input.encryption_disabled {
object.key("encryptionDisabled").boolean(*var_423);
}
Ok(())
}