pub fn serialize_structure_crate_input_acknowledge_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AcknowledgeJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.job_id {
object.key("jobId").string(var_1.as_str());
}
if let Some(var_2) = &input.nonce {
object.key("nonce").string(var_2.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_acknowledge_third_party_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AcknowledgeThirdPartyJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3) = &input.job_id {
object.key("jobId").string(var_3.as_str());
}
if let Some(var_4) = &input.nonce {
object.key("nonce").string(var_4.as_str());
}
if let Some(var_5) = &input.client_token {
object.key("clientToken").string(var_5.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_custom_action_type_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateCustomActionTypeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_6) = &input.category {
object.key("category").string(var_6.as_str());
}
if let Some(var_7) = &input.provider {
object.key("provider").string(var_7.as_str());
}
if let Some(var_8) = &input.version {
object.key("version").string(var_8.as_str());
}
if let Some(var_9) = &input.settings {
#[allow(unused_mut)]
let mut object_10 = object.key("settings").start_object();
crate::json_ser::serialize_structure_crate_model_action_type_settings(
&mut object_10,
var_9,
)?;
object_10.finish();
}
if let Some(var_11) = &input.configuration_properties {
let mut array_12 = object.key("configurationProperties").start_array();
for item_13 in var_11 {
{
#[allow(unused_mut)]
let mut object_14 = array_12.value().start_object();
crate::json_ser::serialize_structure_crate_model_action_configuration_property(
&mut object_14,
item_13,
)?;
object_14.finish();
}
}
array_12.finish();
}
if let Some(var_15) = &input.input_artifact_details {
#[allow(unused_mut)]
let mut object_16 = object.key("inputArtifactDetails").start_object();
crate::json_ser::serialize_structure_crate_model_artifact_details(&mut object_16, var_15)?;
object_16.finish();
}
if let Some(var_17) = &input.output_artifact_details {
#[allow(unused_mut)]
let mut object_18 = object.key("outputArtifactDetails").start_object();
crate::json_ser::serialize_structure_crate_model_artifact_details(&mut object_18, var_17)?;
object_18.finish();
}
if let Some(var_19) = &input.tags {
let mut array_20 = object.key("tags").start_array();
for item_21 in var_19 {
{
#[allow(unused_mut)]
let mut object_22 = array_20.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_22, item_21)?;
object_22.finish();
}
}
array_20.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_pipeline_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreatePipelineInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_23) = &input.pipeline {
#[allow(unused_mut)]
let mut object_24 = object.key("pipeline").start_object();
crate::json_ser::serialize_structure_crate_model_pipeline_declaration(
&mut object_24,
var_23,
)?;
object_24.finish();
}
if let Some(var_25) = &input.tags {
let mut array_26 = object.key("tags").start_array();
for item_27 in var_25 {
{
#[allow(unused_mut)]
let mut object_28 = array_26.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_28, item_27)?;
object_28.finish();
}
}
array_26.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_custom_action_type_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteCustomActionTypeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_29) = &input.category {
object.key("category").string(var_29.as_str());
}
if let Some(var_30) = &input.provider {
object.key("provider").string(var_30.as_str());
}
if let Some(var_31) = &input.version {
object.key("version").string(var_31.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_pipeline_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeletePipelineInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_32) = &input.name {
object.key("name").string(var_32.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_33) = &input.name {
object.key("name").string(var_33.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_deregister_webhook_with_third_party_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeregisterWebhookWithThirdPartyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_34) = &input.webhook_name {
object.key("webhookName").string(var_34.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_disable_stage_transition_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DisableStageTransitionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_35) = &input.pipeline_name {
object.key("pipelineName").string(var_35.as_str());
}
if let Some(var_36) = &input.stage_name {
object.key("stageName").string(var_36.as_str());
}
if let Some(var_37) = &input.transition_type {
object.key("transitionType").string(var_37.as_str());
}
if let Some(var_38) = &input.reason {
object.key("reason").string(var_38.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_enable_stage_transition_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::EnableStageTransitionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_39) = &input.pipeline_name {
object.key("pipelineName").string(var_39.as_str());
}
if let Some(var_40) = &input.stage_name {
object.key("stageName").string(var_40.as_str());
}
if let Some(var_41) = &input.transition_type {
object.key("transitionType").string(var_41.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_action_type_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetActionTypeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_42) = &input.category {
object.key("category").string(var_42.as_str());
}
if let Some(var_43) = &input.owner {
object.key("owner").string(var_43.as_str());
}
if let Some(var_44) = &input.provider {
object.key("provider").string(var_44.as_str());
}
if let Some(var_45) = &input.version {
object.key("version").string(var_45.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_job_details_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetJobDetailsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_46) = &input.job_id {
object.key("jobId").string(var_46.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_pipeline_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetPipelineInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_47) = &input.name {
object.key("name").string(var_47.as_str());
}
if let Some(var_48) = &input.version {
object.key("version").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_48).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_get_pipeline_execution_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetPipelineExecutionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_49) = &input.pipeline_name {
object.key("pipelineName").string(var_49.as_str());
}
if let Some(var_50) = &input.pipeline_execution_id {
object.key("pipelineExecutionId").string(var_50.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_pipeline_state_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetPipelineStateInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_51) = &input.name {
object.key("name").string(var_51.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_third_party_job_details_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetThirdPartyJobDetailsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_52) = &input.job_id {
object.key("jobId").string(var_52.as_str());
}
if let Some(var_53) = &input.client_token {
object.key("clientToken").string(var_53.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_action_executions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListActionExecutionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_54) = &input.pipeline_name {
object.key("pipelineName").string(var_54.as_str());
}
if let Some(var_55) = &input.filter {
#[allow(unused_mut)]
let mut object_56 = object.key("filter").start_object();
crate::json_ser::serialize_structure_crate_model_action_execution_filter(
&mut object_56,
var_55,
)?;
object_56.finish();
}
if let Some(var_57) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_57).into()),
);
}
if let Some(var_58) = &input.next_token {
object.key("nextToken").string(var_58.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_action_types_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListActionTypesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_59) = &input.action_owner_filter {
object.key("actionOwnerFilter").string(var_59.as_str());
}
if let Some(var_60) = &input.next_token {
object.key("nextToken").string(var_60.as_str());
}
if let Some(var_61) = &input.region_filter {
object.key("regionFilter").string(var_61.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_pipeline_executions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListPipelineExecutionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_62) = &input.pipeline_name {
object.key("pipelineName").string(var_62.as_str());
}
if let Some(var_63) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_63).into()),
);
}
if let Some(var_64) = &input.next_token {
object.key("nextToken").string(var_64.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_pipelines_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListPipelinesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_65) = &input.next_token {
object.key("nextToken").string(var_65.as_str());
}
if let Some(var_66) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_66).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::error::SerializationError> {
if let Some(var_67) = &input.resource_arn {
object.key("resourceArn").string(var_67.as_str());
}
if let Some(var_68) = &input.next_token {
object.key("nextToken").string(var_68.as_str());
}
if let Some(var_69) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_69).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_webhooks_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListWebhooksInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_70) = &input.next_token {
object.key("NextToken").string(var_70.as_str());
}
if let Some(var_71) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_71).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_poll_for_jobs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PollForJobsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_72) = &input.action_type_id {
#[allow(unused_mut)]
let mut object_73 = object.key("actionTypeId").start_object();
crate::json_ser::serialize_structure_crate_model_action_type_id(&mut object_73, var_72)?;
object_73.finish();
}
if let Some(var_74) = &input.max_batch_size {
object.key("maxBatchSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_74).into()),
);
}
if let Some(var_75) = &input.query_param {
#[allow(unused_mut)]
let mut object_76 = object.key("queryParam").start_object();
for (key_77, value_78) in var_75 {
{
object_76.key(key_77.as_str()).string(value_78.as_str());
}
}
object_76.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_poll_for_third_party_jobs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PollForThirdPartyJobsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_79) = &input.action_type_id {
#[allow(unused_mut)]
let mut object_80 = object.key("actionTypeId").start_object();
crate::json_ser::serialize_structure_crate_model_action_type_id(&mut object_80, var_79)?;
object_80.finish();
}
if let Some(var_81) = &input.max_batch_size {
object.key("maxBatchSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_81).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_put_action_revision_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutActionRevisionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_82) = &input.pipeline_name {
object.key("pipelineName").string(var_82.as_str());
}
if let Some(var_83) = &input.stage_name {
object.key("stageName").string(var_83.as_str());
}
if let Some(var_84) = &input.action_name {
object.key("actionName").string(var_84.as_str());
}
if let Some(var_85) = &input.action_revision {
#[allow(unused_mut)]
let mut object_86 = object.key("actionRevision").start_object();
crate::json_ser::serialize_structure_crate_model_action_revision(&mut object_86, var_85)?;
object_86.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_put_approval_result_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutApprovalResultInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_87) = &input.pipeline_name {
object.key("pipelineName").string(var_87.as_str());
}
if let Some(var_88) = &input.stage_name {
object.key("stageName").string(var_88.as_str());
}
if let Some(var_89) = &input.action_name {
object.key("actionName").string(var_89.as_str());
}
if let Some(var_90) = &input.result {
#[allow(unused_mut)]
let mut object_91 = object.key("result").start_object();
crate::json_ser::serialize_structure_crate_model_approval_result(&mut object_91, var_90)?;
object_91.finish();
}
if let Some(var_92) = &input.token {
object.key("token").string(var_92.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_put_job_failure_result_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutJobFailureResultInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_93) = &input.job_id {
object.key("jobId").string(var_93.as_str());
}
if let Some(var_94) = &input.failure_details {
#[allow(unused_mut)]
let mut object_95 = object.key("failureDetails").start_object();
crate::json_ser::serialize_structure_crate_model_failure_details(&mut object_95, var_94)?;
object_95.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_put_job_success_result_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutJobSuccessResultInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_96) = &input.job_id {
object.key("jobId").string(var_96.as_str());
}
if let Some(var_97) = &input.current_revision {
#[allow(unused_mut)]
let mut object_98 = object.key("currentRevision").start_object();
crate::json_ser::serialize_structure_crate_model_current_revision(&mut object_98, var_97)?;
object_98.finish();
}
if let Some(var_99) = &input.continuation_token {
object.key("continuationToken").string(var_99.as_str());
}
if let Some(var_100) = &input.execution_details {
#[allow(unused_mut)]
let mut object_101 = object.key("executionDetails").start_object();
crate::json_ser::serialize_structure_crate_model_execution_details(
&mut object_101,
var_100,
)?;
object_101.finish();
}
if let Some(var_102) = &input.output_variables {
#[allow(unused_mut)]
let mut object_103 = object.key("outputVariables").start_object();
for (key_104, value_105) in var_102 {
{
object_103.key(key_104.as_str()).string(value_105.as_str());
}
}
object_103.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_put_third_party_job_failure_result_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutThirdPartyJobFailureResultInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_106) = &input.job_id {
object.key("jobId").string(var_106.as_str());
}
if let Some(var_107) = &input.client_token {
object.key("clientToken").string(var_107.as_str());
}
if let Some(var_108) = &input.failure_details {
#[allow(unused_mut)]
let mut object_109 = object.key("failureDetails").start_object();
crate::json_ser::serialize_structure_crate_model_failure_details(&mut object_109, var_108)?;
object_109.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_put_third_party_job_success_result_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutThirdPartyJobSuccessResultInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_110) = &input.job_id {
object.key("jobId").string(var_110.as_str());
}
if let Some(var_111) = &input.client_token {
object.key("clientToken").string(var_111.as_str());
}
if let Some(var_112) = &input.current_revision {
#[allow(unused_mut)]
let mut object_113 = object.key("currentRevision").start_object();
crate::json_ser::serialize_structure_crate_model_current_revision(
&mut object_113,
var_112,
)?;
object_113.finish();
}
if let Some(var_114) = &input.continuation_token {
object.key("continuationToken").string(var_114.as_str());
}
if let Some(var_115) = &input.execution_details {
#[allow(unused_mut)]
let mut object_116 = object.key("executionDetails").start_object();
crate::json_ser::serialize_structure_crate_model_execution_details(
&mut object_116,
var_115,
)?;
object_116.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_put_webhook_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutWebhookInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_117) = &input.webhook {
#[allow(unused_mut)]
let mut object_118 = object.key("webhook").start_object();
crate::json_ser::serialize_structure_crate_model_webhook_definition(
&mut object_118,
var_117,
)?;
object_118.finish();
}
if let Some(var_119) = &input.tags {
let mut array_120 = object.key("tags").start_array();
for item_121 in var_119 {
{
#[allow(unused_mut)]
let mut object_122 = array_120.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_122, item_121)?;
object_122.finish();
}
}
array_120.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_register_webhook_with_third_party_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RegisterWebhookWithThirdPartyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_123) = &input.webhook_name {
object.key("webhookName").string(var_123.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_retry_stage_execution_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RetryStageExecutionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_124) = &input.pipeline_name {
object.key("pipelineName").string(var_124.as_str());
}
if let Some(var_125) = &input.stage_name {
object.key("stageName").string(var_125.as_str());
}
if let Some(var_126) = &input.pipeline_execution_id {
object.key("pipelineExecutionId").string(var_126.as_str());
}
if let Some(var_127) = &input.retry_mode {
object.key("retryMode").string(var_127.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_start_pipeline_execution_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartPipelineExecutionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_128) = &input.name {
object.key("name").string(var_128.as_str());
}
if let Some(var_129) = &input.client_request_token {
object.key("clientRequestToken").string(var_129.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_stop_pipeline_execution_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StopPipelineExecutionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_130) = &input.pipeline_name {
object.key("pipelineName").string(var_130.as_str());
}
if let Some(var_131) = &input.pipeline_execution_id {
object.key("pipelineExecutionId").string(var_131.as_str());
}
if input.abandon {
object.key("abandon").boolean(input.abandon);
}
if let Some(var_132) = &input.reason {
object.key("reason").string(var_132.as_str());
}
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_133) = &input.resource_arn {
object.key("resourceArn").string(var_133.as_str());
}
if let Some(var_134) = &input.tags {
let mut array_135 = object.key("tags").start_array();
for item_136 in var_134 {
{
#[allow(unused_mut)]
let mut object_137 = array_135.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_137, item_136)?;
object_137.finish();
}
}
array_135.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_138) = &input.resource_arn {
object.key("resourceArn").string(var_138.as_str());
}
if let Some(var_139) = &input.tag_keys {
let mut array_140 = object.key("tagKeys").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_update_action_type_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateActionTypeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_142) = &input.action_type {
#[allow(unused_mut)]
let mut object_143 = object.key("actionType").start_object();
crate::json_ser::serialize_structure_crate_model_action_type_declaration(
&mut object_143,
var_142,
)?;
object_143.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_pipeline_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdatePipelineInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_144) = &input.pipeline {
#[allow(unused_mut)]
let mut object_145 = object.key("pipeline").start_object();
crate::json_ser::serialize_structure_crate_model_pipeline_declaration(
&mut object_145,
var_144,
)?;
object_145.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_action_type_settings(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ActionTypeSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_146) = &input.third_party_configuration_url {
object
.key("thirdPartyConfigurationUrl")
.string(var_146.as_str());
}
if let Some(var_147) = &input.entity_url_template {
object.key("entityUrlTemplate").string(var_147.as_str());
}
if let Some(var_148) = &input.execution_url_template {
object.key("executionUrlTemplate").string(var_148.as_str());
}
if let Some(var_149) = &input.revision_url_template {
object.key("revisionUrlTemplate").string(var_149.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_action_configuration_property(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ActionConfigurationProperty,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_150) = &input.name {
object.key("name").string(var_150.as_str());
}
{
object.key("required").boolean(input.required);
}
{
object.key("key").boolean(input.key);
}
{
object.key("secret").boolean(input.secret);
}
if input.queryable {
object.key("queryable").boolean(input.queryable);
}
if let Some(var_151) = &input.description {
object.key("description").string(var_151.as_str());
}
if let Some(var_152) = &input.r#type {
object.key("type").string(var_152.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_artifact_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ArtifactDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
{
object.key("minimumCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.minimum_count).into()),
);
}
{
object.key("maximumCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.maximum_count).into()),
);
}
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_153) = &input.key {
object.key("key").string(var_153.as_str());
}
if let Some(var_154) = &input.value {
object.key("value").string(var_154.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_pipeline_declaration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PipelineDeclaration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_155) = &input.name {
object.key("name").string(var_155.as_str());
}
if let Some(var_156) = &input.role_arn {
object.key("roleArn").string(var_156.as_str());
}
if let Some(var_157) = &input.artifact_store {
#[allow(unused_mut)]
let mut object_158 = object.key("artifactStore").start_object();
crate::json_ser::serialize_structure_crate_model_artifact_store(&mut object_158, var_157)?;
object_158.finish();
}
if let Some(var_159) = &input.artifact_stores {
#[allow(unused_mut)]
let mut object_160 = object.key("artifactStores").start_object();
for (key_161, value_162) in var_159 {
{
#[allow(unused_mut)]
let mut object_163 = object_160.key(key_161.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_artifact_store(
&mut object_163,
value_162,
)?;
object_163.finish();
}
}
object_160.finish();
}
if let Some(var_164) = &input.stages {
let mut array_165 = object.key("stages").start_array();
for item_166 in var_164 {
{
#[allow(unused_mut)]
let mut object_167 = array_165.value().start_object();
crate::json_ser::serialize_structure_crate_model_stage_declaration(
&mut object_167,
item_166,
)?;
object_167.finish();
}
}
array_165.finish();
}
if let Some(var_168) = &input.version {
object.key("version").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_168).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_action_execution_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ActionExecutionFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_169) = &input.pipeline_execution_id {
object.key("pipelineExecutionId").string(var_169.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_action_type_id(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ActionTypeId,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_170) = &input.category {
object.key("category").string(var_170.as_str());
}
if let Some(var_171) = &input.owner {
object.key("owner").string(var_171.as_str());
}
if let Some(var_172) = &input.provider {
object.key("provider").string(var_172.as_str());
}
if let Some(var_173) = &input.version {
object.key("version").string(var_173.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_action_revision(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ActionRevision,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_174) = &input.revision_id {
object.key("revisionId").string(var_174.as_str());
}
if let Some(var_175) = &input.revision_change_id {
object.key("revisionChangeId").string(var_175.as_str());
}
if let Some(var_176) = &input.created {
object
.key("created")
.date_time(var_176, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
Ok(())
}
pub fn serialize_structure_crate_model_approval_result(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ApprovalResult,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_177) = &input.summary {
object.key("summary").string(var_177.as_str());
}
if let Some(var_178) = &input.status {
object.key("status").string(var_178.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_failure_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FailureDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_179) = &input.r#type {
object.key("type").string(var_179.as_str());
}
if let Some(var_180) = &input.message {
object.key("message").string(var_180.as_str());
}
if let Some(var_181) = &input.external_execution_id {
object.key("externalExecutionId").string(var_181.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_current_revision(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CurrentRevision,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_182) = &input.revision {
object.key("revision").string(var_182.as_str());
}
if let Some(var_183) = &input.change_identifier {
object.key("changeIdentifier").string(var_183.as_str());
}
if let Some(var_184) = &input.created {
object
.key("created")
.date_time(var_184, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_185) = &input.revision_summary {
object.key("revisionSummary").string(var_185.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_execution_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ExecutionDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_186) = &input.summary {
object.key("summary").string(var_186.as_str());
}
if let Some(var_187) = &input.external_execution_id {
object.key("externalExecutionId").string(var_187.as_str());
}
if let Some(var_188) = &input.percent_complete {
object.key("percentComplete").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_188).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_webhook_definition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::WebhookDefinition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_189) = &input.name {
object.key("name").string(var_189.as_str());
}
if let Some(var_190) = &input.target_pipeline {
object.key("targetPipeline").string(var_190.as_str());
}
if let Some(var_191) = &input.target_action {
object.key("targetAction").string(var_191.as_str());
}
if let Some(var_192) = &input.filters {
let mut array_193 = object.key("filters").start_array();
for item_194 in var_192 {
{
#[allow(unused_mut)]
let mut object_195 = array_193.value().start_object();
crate::json_ser::serialize_structure_crate_model_webhook_filter_rule(
&mut object_195,
item_194,
)?;
object_195.finish();
}
}
array_193.finish();
}
if let Some(var_196) = &input.authentication {
object.key("authentication").string(var_196.as_str());
}
if let Some(var_197) = &input.authentication_configuration {
#[allow(unused_mut)]
let mut object_198 = object.key("authenticationConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_webhook_auth_configuration(
&mut object_198,
var_197,
)?;
object_198.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_action_type_declaration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ActionTypeDeclaration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_199) = &input.description {
object.key("description").string(var_199.as_str());
}
if let Some(var_200) = &input.executor {
#[allow(unused_mut)]
let mut object_201 = object.key("executor").start_object();
crate::json_ser::serialize_structure_crate_model_action_type_executor(
&mut object_201,
var_200,
)?;
object_201.finish();
}
if let Some(var_202) = &input.id {
#[allow(unused_mut)]
let mut object_203 = object.key("id").start_object();
crate::json_ser::serialize_structure_crate_model_action_type_identifier(
&mut object_203,
var_202,
)?;
object_203.finish();
}
if let Some(var_204) = &input.input_artifact_details {
#[allow(unused_mut)]
let mut object_205 = object.key("inputArtifactDetails").start_object();
crate::json_ser::serialize_structure_crate_model_action_type_artifact_details(
&mut object_205,
var_204,
)?;
object_205.finish();
}
if let Some(var_206) = &input.output_artifact_details {
#[allow(unused_mut)]
let mut object_207 = object.key("outputArtifactDetails").start_object();
crate::json_ser::serialize_structure_crate_model_action_type_artifact_details(
&mut object_207,
var_206,
)?;
object_207.finish();
}
if let Some(var_208) = &input.permissions {
#[allow(unused_mut)]
let mut object_209 = object.key("permissions").start_object();
crate::json_ser::serialize_structure_crate_model_action_type_permissions(
&mut object_209,
var_208,
)?;
object_209.finish();
}
if let Some(var_210) = &input.properties {
let mut array_211 = object.key("properties").start_array();
for item_212 in var_210 {
{
#[allow(unused_mut)]
let mut object_213 = array_211.value().start_object();
crate::json_ser::serialize_structure_crate_model_action_type_property(
&mut object_213,
item_212,
)?;
object_213.finish();
}
}
array_211.finish();
}
if let Some(var_214) = &input.urls {
#[allow(unused_mut)]
let mut object_215 = object.key("urls").start_object();
crate::json_ser::serialize_structure_crate_model_action_type_urls(
&mut object_215,
var_214,
)?;
object_215.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_artifact_store(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ArtifactStore,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_216) = &input.r#type {
object.key("type").string(var_216.as_str());
}
if let Some(var_217) = &input.location {
object.key("location").string(var_217.as_str());
}
if let Some(var_218) = &input.encryption_key {
#[allow(unused_mut)]
let mut object_219 = object.key("encryptionKey").start_object();
crate::json_ser::serialize_structure_crate_model_encryption_key(&mut object_219, var_218)?;
object_219.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_stage_declaration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StageDeclaration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_220) = &input.name {
object.key("name").string(var_220.as_str());
}
if let Some(var_221) = &input.blockers {
let mut array_222 = object.key("blockers").start_array();
for item_223 in var_221 {
{
#[allow(unused_mut)]
let mut object_224 = array_222.value().start_object();
crate::json_ser::serialize_structure_crate_model_blocker_declaration(
&mut object_224,
item_223,
)?;
object_224.finish();
}
}
array_222.finish();
}
if let Some(var_225) = &input.actions {
let mut array_226 = object.key("actions").start_array();
for item_227 in var_225 {
{
#[allow(unused_mut)]
let mut object_228 = array_226.value().start_object();
crate::json_ser::serialize_structure_crate_model_action_declaration(
&mut object_228,
item_227,
)?;
object_228.finish();
}
}
array_226.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_webhook_filter_rule(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::WebhookFilterRule,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_229) = &input.json_path {
object.key("jsonPath").string(var_229.as_str());
}
if let Some(var_230) = &input.match_equals {
object.key("matchEquals").string(var_230.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_webhook_auth_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::WebhookAuthConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_231) = &input.allowed_ip_range {
object.key("AllowedIPRange").string(var_231.as_str());
}
if let Some(var_232) = &input.secret_token {
object.key("SecretToken").string(var_232.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_action_type_executor(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ActionTypeExecutor,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_233) = &input.configuration {
#[allow(unused_mut)]
let mut object_234 = object.key("configuration").start_object();
crate::json_ser::serialize_structure_crate_model_executor_configuration(
&mut object_234,
var_233,
)?;
object_234.finish();
}
if let Some(var_235) = &input.r#type {
object.key("type").string(var_235.as_str());
}
if let Some(var_236) = &input.policy_statements_template {
object
.key("policyStatementsTemplate")
.string(var_236.as_str());
}
if let Some(var_237) = &input.job_timeout {
object.key("jobTimeout").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_237).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_action_type_identifier(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ActionTypeIdentifier,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_238) = &input.category {
object.key("category").string(var_238.as_str());
}
if let Some(var_239) = &input.owner {
object.key("owner").string(var_239.as_str());
}
if let Some(var_240) = &input.provider {
object.key("provider").string(var_240.as_str());
}
if let Some(var_241) = &input.version {
object.key("version").string(var_241.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_action_type_artifact_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ActionTypeArtifactDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
{
object.key("minimumCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.minimum_count).into()),
);
}
{
object.key("maximumCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.maximum_count).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_action_type_permissions(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ActionTypePermissions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_242) = &input.allowed_accounts {
let mut array_243 = object.key("allowedAccounts").start_array();
for item_244 in var_242 {
{
array_243.value().string(item_244.as_str());
}
}
array_243.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_action_type_property(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ActionTypeProperty,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_245) = &input.name {
object.key("name").string(var_245.as_str());
}
{
object.key("optional").boolean(input.optional);
}
{
object.key("key").boolean(input.key);
}
{
object.key("noEcho").boolean(input.no_echo);
}
if input.queryable {
object.key("queryable").boolean(input.queryable);
}
if let Some(var_246) = &input.description {
object.key("description").string(var_246.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_action_type_urls(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ActionTypeUrls,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_247) = &input.configuration_url {
object.key("configurationUrl").string(var_247.as_str());
}
if let Some(var_248) = &input.entity_url_template {
object.key("entityUrlTemplate").string(var_248.as_str());
}
if let Some(var_249) = &input.execution_url_template {
object.key("executionUrlTemplate").string(var_249.as_str());
}
if let Some(var_250) = &input.revision_url_template {
object.key("revisionUrlTemplate").string(var_250.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_encryption_key(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EncryptionKey,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_251) = &input.id {
object.key("id").string(var_251.as_str());
}
if let Some(var_252) = &input.r#type {
object.key("type").string(var_252.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_blocker_declaration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BlockerDeclaration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_253) = &input.name {
object.key("name").string(var_253.as_str());
}
if let Some(var_254) = &input.r#type {
object.key("type").string(var_254.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_action_declaration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ActionDeclaration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_255) = &input.name {
object.key("name").string(var_255.as_str());
}
if let Some(var_256) = &input.action_type_id {
#[allow(unused_mut)]
let mut object_257 = object.key("actionTypeId").start_object();
crate::json_ser::serialize_structure_crate_model_action_type_id(&mut object_257, var_256)?;
object_257.finish();
}
if let Some(var_258) = &input.run_order {
object.key("runOrder").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_258).into()),
);
}
if let Some(var_259) = &input.configuration {
#[allow(unused_mut)]
let mut object_260 = object.key("configuration").start_object();
for (key_261, value_262) in var_259 {
{
object_260.key(key_261.as_str()).string(value_262.as_str());
}
}
object_260.finish();
}
if let Some(var_263) = &input.output_artifacts {
let mut array_264 = object.key("outputArtifacts").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_output_artifact(
&mut object_266,
item_265,
)?;
object_266.finish();
}
}
array_264.finish();
}
if let Some(var_267) = &input.input_artifacts {
let mut array_268 = object.key("inputArtifacts").start_array();
for item_269 in var_267 {
{
#[allow(unused_mut)]
let mut object_270 = array_268.value().start_object();
crate::json_ser::serialize_structure_crate_model_input_artifact(
&mut object_270,
item_269,
)?;
object_270.finish();
}
}
array_268.finish();
}
if let Some(var_271) = &input.role_arn {
object.key("roleArn").string(var_271.as_str());
}
if let Some(var_272) = &input.region {
object.key("region").string(var_272.as_str());
}
if let Some(var_273) = &input.namespace {
object.key("namespace").string(var_273.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_executor_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ExecutorConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_274) = &input.lambda_executor_configuration {
#[allow(unused_mut)]
let mut object_275 = object.key("lambdaExecutorConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_lambda_executor_configuration(
&mut object_275,
var_274,
)?;
object_275.finish();
}
if let Some(var_276) = &input.job_worker_executor_configuration {
#[allow(unused_mut)]
let mut object_277 = object.key("jobWorkerExecutorConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_job_worker_executor_configuration(
&mut object_277,
var_276,
)?;
object_277.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_output_artifact(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OutputArtifact,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_278) = &input.name {
object.key("name").string(var_278.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_input_artifact(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::InputArtifact,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_279) = &input.name {
object.key("name").string(var_279.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_lambda_executor_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LambdaExecutorConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_280) = &input.lambda_function_arn {
object.key("lambdaFunctionArn").string(var_280.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_job_worker_executor_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::JobWorkerExecutorConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_281) = &input.polling_accounts {
let mut array_282 = object.key("pollingAccounts").start_array();
for item_283 in var_281 {
{
array_282.value().string(item_283.as_str());
}
}
array_282.finish();
}
if let Some(var_284) = &input.polling_service_principals {
let mut array_285 = object.key("pollingServicePrincipals").start_array();
for item_286 in var_284 {
{
array_285.value().string(item_286.as_str());
}
}
array_285.finish();
}
Ok(())
}