pub fn serialize_structure_crate_input_count_closed_workflow_executions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CountClosedWorkflowExecutionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.domain {
object.key("domain").string(var_1.as_str());
}
if let Some(var_2) = &input.start_time_filter {
#[allow(unused_mut)]
let mut object_3 = object.key("startTimeFilter").start_object();
crate::json_ser::serialize_structure_crate_model_execution_time_filter(
&mut object_3,
var_2,
)?;
object_3.finish();
}
if let Some(var_4) = &input.close_time_filter {
#[allow(unused_mut)]
let mut object_5 = object.key("closeTimeFilter").start_object();
crate::json_ser::serialize_structure_crate_model_execution_time_filter(
&mut object_5,
var_4,
)?;
object_5.finish();
}
if let Some(var_6) = &input.execution_filter {
#[allow(unused_mut)]
let mut object_7 = object.key("executionFilter").start_object();
crate::json_ser::serialize_structure_crate_model_workflow_execution_filter(
&mut object_7,
var_6,
)?;
object_7.finish();
}
if let Some(var_8) = &input.type_filter {
#[allow(unused_mut)]
let mut object_9 = object.key("typeFilter").start_object();
crate::json_ser::serialize_structure_crate_model_workflow_type_filter(
&mut object_9,
var_8,
)?;
object_9.finish();
}
if let Some(var_10) = &input.tag_filter {
#[allow(unused_mut)]
let mut object_11 = object.key("tagFilter").start_object();
crate::json_ser::serialize_structure_crate_model_tag_filter(&mut object_11, var_10)?;
object_11.finish();
}
if let Some(var_12) = &input.close_status_filter {
#[allow(unused_mut)]
let mut object_13 = object.key("closeStatusFilter").start_object();
crate::json_ser::serialize_structure_crate_model_close_status_filter(
&mut object_13,
var_12,
)?;
object_13.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_count_open_workflow_executions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CountOpenWorkflowExecutionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_14) = &input.domain {
object.key("domain").string(var_14.as_str());
}
if let Some(var_15) = &input.start_time_filter {
#[allow(unused_mut)]
let mut object_16 = object.key("startTimeFilter").start_object();
crate::json_ser::serialize_structure_crate_model_execution_time_filter(
&mut object_16,
var_15,
)?;
object_16.finish();
}
if let Some(var_17) = &input.type_filter {
#[allow(unused_mut)]
let mut object_18 = object.key("typeFilter").start_object();
crate::json_ser::serialize_structure_crate_model_workflow_type_filter(
&mut object_18,
var_17,
)?;
object_18.finish();
}
if let Some(var_19) = &input.tag_filter {
#[allow(unused_mut)]
let mut object_20 = object.key("tagFilter").start_object();
crate::json_ser::serialize_structure_crate_model_tag_filter(&mut object_20, var_19)?;
object_20.finish();
}
if let Some(var_21) = &input.execution_filter {
#[allow(unused_mut)]
let mut object_22 = object.key("executionFilter").start_object();
crate::json_ser::serialize_structure_crate_model_workflow_execution_filter(
&mut object_22,
var_21,
)?;
object_22.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_count_pending_activity_tasks_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CountPendingActivityTasksInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_23) = &input.domain {
object.key("domain").string(var_23.as_str());
}
if let Some(var_24) = &input.task_list {
#[allow(unused_mut)]
let mut object_25 = object.key("taskList").start_object();
crate::json_ser::serialize_structure_crate_model_task_list(&mut object_25, var_24)?;
object_25.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_count_pending_decision_tasks_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CountPendingDecisionTasksInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_26) = &input.domain {
object.key("domain").string(var_26.as_str());
}
if let Some(var_27) = &input.task_list {
#[allow(unused_mut)]
let mut object_28 = object.key("taskList").start_object();
crate::json_ser::serialize_structure_crate_model_task_list(&mut object_28, var_27)?;
object_28.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_deprecate_activity_type_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeprecateActivityTypeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_29) = &input.domain {
object.key("domain").string(var_29.as_str());
}
if let Some(var_30) = &input.activity_type {
#[allow(unused_mut)]
let mut object_31 = object.key("activityType").start_object();
crate::json_ser::serialize_structure_crate_model_activity_type(&mut object_31, var_30)?;
object_31.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_deprecate_domain_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeprecateDomainInput,
) -> 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_deprecate_workflow_type_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeprecateWorkflowTypeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_33) = &input.domain {
object.key("domain").string(var_33.as_str());
}
if let Some(var_34) = &input.workflow_type {
#[allow(unused_mut)]
let mut object_35 = object.key("workflowType").start_object();
crate::json_ser::serialize_structure_crate_model_workflow_type(&mut object_35, var_34)?;
object_35.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_activity_type_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeActivityTypeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_36) = &input.domain {
object.key("domain").string(var_36.as_str());
}
if let Some(var_37) = &input.activity_type {
#[allow(unused_mut)]
let mut object_38 = object.key("activityType").start_object();
crate::json_ser::serialize_structure_crate_model_activity_type(&mut object_38, var_37)?;
object_38.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_domain_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeDomainInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_39) = &input.name {
object.key("name").string(var_39.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_workflow_execution_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeWorkflowExecutionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_40) = &input.domain {
object.key("domain").string(var_40.as_str());
}
if let Some(var_41) = &input.execution {
#[allow(unused_mut)]
let mut object_42 = object.key("execution").start_object();
crate::json_ser::serialize_structure_crate_model_workflow_execution(
&mut object_42,
var_41,
)?;
object_42.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_workflow_type_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeWorkflowTypeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_43) = &input.domain {
object.key("domain").string(var_43.as_str());
}
if let Some(var_44) = &input.workflow_type {
#[allow(unused_mut)]
let mut object_45 = object.key("workflowType").start_object();
crate::json_ser::serialize_structure_crate_model_workflow_type(&mut object_45, var_44)?;
object_45.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_get_workflow_execution_history_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetWorkflowExecutionHistoryInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_46) = &input.domain {
object.key("domain").string(var_46.as_str());
}
if let Some(var_47) = &input.execution {
#[allow(unused_mut)]
let mut object_48 = object.key("execution").start_object();
crate::json_ser::serialize_structure_crate_model_workflow_execution(
&mut object_48,
var_47,
)?;
object_48.finish();
}
if let Some(var_49) = &input.next_page_token {
object.key("nextPageToken").string(var_49.as_str());
}
if input.maximum_page_size != 0 {
object.key("maximumPageSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.maximum_page_size).into()),
);
}
if input.reverse_order {
object.key("reverseOrder").boolean(input.reverse_order);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_activity_types_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListActivityTypesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_50) = &input.domain {
object.key("domain").string(var_50.as_str());
}
if let Some(var_51) = &input.name {
object.key("name").string(var_51.as_str());
}
if let Some(var_52) = &input.registration_status {
object.key("registrationStatus").string(var_52.as_str());
}
if let Some(var_53) = &input.next_page_token {
object.key("nextPageToken").string(var_53.as_str());
}
if input.maximum_page_size != 0 {
object.key("maximumPageSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.maximum_page_size).into()),
);
}
if input.reverse_order {
object.key("reverseOrder").boolean(input.reverse_order);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_closed_workflow_executions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListClosedWorkflowExecutionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_54) = &input.domain {
object.key("domain").string(var_54.as_str());
}
if let Some(var_55) = &input.start_time_filter {
#[allow(unused_mut)]
let mut object_56 = object.key("startTimeFilter").start_object();
crate::json_ser::serialize_structure_crate_model_execution_time_filter(
&mut object_56,
var_55,
)?;
object_56.finish();
}
if let Some(var_57) = &input.close_time_filter {
#[allow(unused_mut)]
let mut object_58 = object.key("closeTimeFilter").start_object();
crate::json_ser::serialize_structure_crate_model_execution_time_filter(
&mut object_58,
var_57,
)?;
object_58.finish();
}
if let Some(var_59) = &input.execution_filter {
#[allow(unused_mut)]
let mut object_60 = object.key("executionFilter").start_object();
crate::json_ser::serialize_structure_crate_model_workflow_execution_filter(
&mut object_60,
var_59,
)?;
object_60.finish();
}
if let Some(var_61) = &input.close_status_filter {
#[allow(unused_mut)]
let mut object_62 = object.key("closeStatusFilter").start_object();
crate::json_ser::serialize_structure_crate_model_close_status_filter(
&mut object_62,
var_61,
)?;
object_62.finish();
}
if let Some(var_63) = &input.type_filter {
#[allow(unused_mut)]
let mut object_64 = object.key("typeFilter").start_object();
crate::json_ser::serialize_structure_crate_model_workflow_type_filter(
&mut object_64,
var_63,
)?;
object_64.finish();
}
if let Some(var_65) = &input.tag_filter {
#[allow(unused_mut)]
let mut object_66 = object.key("tagFilter").start_object();
crate::json_ser::serialize_structure_crate_model_tag_filter(&mut object_66, var_65)?;
object_66.finish();
}
if let Some(var_67) = &input.next_page_token {
object.key("nextPageToken").string(var_67.as_str());
}
if input.maximum_page_size != 0 {
object.key("maximumPageSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.maximum_page_size).into()),
);
}
if input.reverse_order {
object.key("reverseOrder").boolean(input.reverse_order);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_domains_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListDomainsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_68) = &input.next_page_token {
object.key("nextPageToken").string(var_68.as_str());
}
if let Some(var_69) = &input.registration_status {
object.key("registrationStatus").string(var_69.as_str());
}
if input.maximum_page_size != 0 {
object.key("maximumPageSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.maximum_page_size).into()),
);
}
if input.reverse_order {
object.key("reverseOrder").boolean(input.reverse_order);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_open_workflow_executions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListOpenWorkflowExecutionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_70) = &input.domain {
object.key("domain").string(var_70.as_str());
}
if let Some(var_71) = &input.start_time_filter {
#[allow(unused_mut)]
let mut object_72 = object.key("startTimeFilter").start_object();
crate::json_ser::serialize_structure_crate_model_execution_time_filter(
&mut object_72,
var_71,
)?;
object_72.finish();
}
if let Some(var_73) = &input.type_filter {
#[allow(unused_mut)]
let mut object_74 = object.key("typeFilter").start_object();
crate::json_ser::serialize_structure_crate_model_workflow_type_filter(
&mut object_74,
var_73,
)?;
object_74.finish();
}
if let Some(var_75) = &input.tag_filter {
#[allow(unused_mut)]
let mut object_76 = object.key("tagFilter").start_object();
crate::json_ser::serialize_structure_crate_model_tag_filter(&mut object_76, var_75)?;
object_76.finish();
}
if let Some(var_77) = &input.next_page_token {
object.key("nextPageToken").string(var_77.as_str());
}
if input.maximum_page_size != 0 {
object.key("maximumPageSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.maximum_page_size).into()),
);
}
if input.reverse_order {
object.key("reverseOrder").boolean(input.reverse_order);
}
if let Some(var_78) = &input.execution_filter {
#[allow(unused_mut)]
let mut object_79 = object.key("executionFilter").start_object();
crate::json_ser::serialize_structure_crate_model_workflow_execution_filter(
&mut object_79,
var_78,
)?;
object_79.finish();
}
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_80) = &input.resource_arn {
object.key("resourceArn").string(var_80.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_workflow_types_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListWorkflowTypesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_81) = &input.domain {
object.key("domain").string(var_81.as_str());
}
if let Some(var_82) = &input.name {
object.key("name").string(var_82.as_str());
}
if let Some(var_83) = &input.registration_status {
object.key("registrationStatus").string(var_83.as_str());
}
if let Some(var_84) = &input.next_page_token {
object.key("nextPageToken").string(var_84.as_str());
}
if input.maximum_page_size != 0 {
object.key("maximumPageSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.maximum_page_size).into()),
);
}
if input.reverse_order {
object.key("reverseOrder").boolean(input.reverse_order);
}
Ok(())
}
pub fn serialize_structure_crate_input_poll_for_activity_task_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PollForActivityTaskInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_85) = &input.domain {
object.key("domain").string(var_85.as_str());
}
if let Some(var_86) = &input.task_list {
#[allow(unused_mut)]
let mut object_87 = object.key("taskList").start_object();
crate::json_ser::serialize_structure_crate_model_task_list(&mut object_87, var_86)?;
object_87.finish();
}
if let Some(var_88) = &input.identity {
object.key("identity").string(var_88.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_poll_for_decision_task_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PollForDecisionTaskInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_89) = &input.domain {
object.key("domain").string(var_89.as_str());
}
if let Some(var_90) = &input.task_list {
#[allow(unused_mut)]
let mut object_91 = object.key("taskList").start_object();
crate::json_ser::serialize_structure_crate_model_task_list(&mut object_91, var_90)?;
object_91.finish();
}
if let Some(var_92) = &input.identity {
object.key("identity").string(var_92.as_str());
}
if let Some(var_93) = &input.next_page_token {
object.key("nextPageToken").string(var_93.as_str());
}
if input.maximum_page_size != 0 {
object.key("maximumPageSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.maximum_page_size).into()),
);
}
if input.reverse_order {
object.key("reverseOrder").boolean(input.reverse_order);
}
Ok(())
}
pub fn serialize_structure_crate_input_record_activity_task_heartbeat_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RecordActivityTaskHeartbeatInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_94) = &input.task_token {
object.key("taskToken").string(var_94.as_str());
}
if let Some(var_95) = &input.details {
object.key("details").string(var_95.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_register_activity_type_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RegisterActivityTypeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_96) = &input.domain {
object.key("domain").string(var_96.as_str());
}
if let Some(var_97) = &input.name {
object.key("name").string(var_97.as_str());
}
if let Some(var_98) = &input.version {
object.key("version").string(var_98.as_str());
}
if let Some(var_99) = &input.description {
object.key("description").string(var_99.as_str());
}
if let Some(var_100) = &input.default_task_start_to_close_timeout {
object
.key("defaultTaskStartToCloseTimeout")
.string(var_100.as_str());
}
if let Some(var_101) = &input.default_task_heartbeat_timeout {
object
.key("defaultTaskHeartbeatTimeout")
.string(var_101.as_str());
}
if let Some(var_102) = &input.default_task_list {
#[allow(unused_mut)]
let mut object_103 = object.key("defaultTaskList").start_object();
crate::json_ser::serialize_structure_crate_model_task_list(&mut object_103, var_102)?;
object_103.finish();
}
if let Some(var_104) = &input.default_task_priority {
object.key("defaultTaskPriority").string(var_104.as_str());
}
if let Some(var_105) = &input.default_task_schedule_to_start_timeout {
object
.key("defaultTaskScheduleToStartTimeout")
.string(var_105.as_str());
}
if let Some(var_106) = &input.default_task_schedule_to_close_timeout {
object
.key("defaultTaskScheduleToCloseTimeout")
.string(var_106.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_register_domain_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RegisterDomainInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_107) = &input.name {
object.key("name").string(var_107.as_str());
}
if let Some(var_108) = &input.description {
object.key("description").string(var_108.as_str());
}
if let Some(var_109) = &input.workflow_execution_retention_period_in_days {
object
.key("workflowExecutionRetentionPeriodInDays")
.string(var_109.as_str());
}
if let Some(var_110) = &input.tags {
let mut array_111 = object.key("tags").start_array();
for item_112 in var_110 {
{
#[allow(unused_mut)]
let mut object_113 = array_111.value().start_object();
crate::json_ser::serialize_structure_crate_model_resource_tag(
&mut object_113,
item_112,
)?;
object_113.finish();
}
}
array_111.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_register_workflow_type_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RegisterWorkflowTypeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_114) = &input.domain {
object.key("domain").string(var_114.as_str());
}
if let Some(var_115) = &input.name {
object.key("name").string(var_115.as_str());
}
if let Some(var_116) = &input.version {
object.key("version").string(var_116.as_str());
}
if let Some(var_117) = &input.description {
object.key("description").string(var_117.as_str());
}
if let Some(var_118) = &input.default_task_start_to_close_timeout {
object
.key("defaultTaskStartToCloseTimeout")
.string(var_118.as_str());
}
if let Some(var_119) = &input.default_execution_start_to_close_timeout {
object
.key("defaultExecutionStartToCloseTimeout")
.string(var_119.as_str());
}
if let Some(var_120) = &input.default_task_list {
#[allow(unused_mut)]
let mut object_121 = object.key("defaultTaskList").start_object();
crate::json_ser::serialize_structure_crate_model_task_list(&mut object_121, var_120)?;
object_121.finish();
}
if let Some(var_122) = &input.default_task_priority {
object.key("defaultTaskPriority").string(var_122.as_str());
}
if let Some(var_123) = &input.default_child_policy {
object.key("defaultChildPolicy").string(var_123.as_str());
}
if let Some(var_124) = &input.default_lambda_role {
object.key("defaultLambdaRole").string(var_124.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_request_cancel_workflow_execution_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RequestCancelWorkflowExecutionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_125) = &input.domain {
object.key("domain").string(var_125.as_str());
}
if let Some(var_126) = &input.workflow_id {
object.key("workflowId").string(var_126.as_str());
}
if let Some(var_127) = &input.run_id {
object.key("runId").string(var_127.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_respond_activity_task_canceled_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RespondActivityTaskCanceledInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_128) = &input.task_token {
object.key("taskToken").string(var_128.as_str());
}
if let Some(var_129) = &input.details {
object.key("details").string(var_129.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_respond_activity_task_completed_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RespondActivityTaskCompletedInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_130) = &input.task_token {
object.key("taskToken").string(var_130.as_str());
}
if let Some(var_131) = &input.result {
object.key("result").string(var_131.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_respond_activity_task_failed_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RespondActivityTaskFailedInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_132) = &input.task_token {
object.key("taskToken").string(var_132.as_str());
}
if let Some(var_133) = &input.reason {
object.key("reason").string(var_133.as_str());
}
if let Some(var_134) = &input.details {
object.key("details").string(var_134.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_respond_decision_task_completed_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RespondDecisionTaskCompletedInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_135) = &input.task_token {
object.key("taskToken").string(var_135.as_str());
}
if let Some(var_136) = &input.decisions {
let mut array_137 = object.key("decisions").start_array();
for item_138 in var_136 {
{
#[allow(unused_mut)]
let mut object_139 = array_137.value().start_object();
crate::json_ser::serialize_structure_crate_model_decision(
&mut object_139,
item_138,
)?;
object_139.finish();
}
}
array_137.finish();
}
if let Some(var_140) = &input.execution_context {
object.key("executionContext").string(var_140.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_signal_workflow_execution_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::SignalWorkflowExecutionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_141) = &input.domain {
object.key("domain").string(var_141.as_str());
}
if let Some(var_142) = &input.workflow_id {
object.key("workflowId").string(var_142.as_str());
}
if let Some(var_143) = &input.run_id {
object.key("runId").string(var_143.as_str());
}
if let Some(var_144) = &input.signal_name {
object.key("signalName").string(var_144.as_str());
}
if let Some(var_145) = &input.input {
object.key("input").string(var_145.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_start_workflow_execution_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartWorkflowExecutionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_146) = &input.domain {
object.key("domain").string(var_146.as_str());
}
if let Some(var_147) = &input.workflow_id {
object.key("workflowId").string(var_147.as_str());
}
if let Some(var_148) = &input.workflow_type {
#[allow(unused_mut)]
let mut object_149 = object.key("workflowType").start_object();
crate::json_ser::serialize_structure_crate_model_workflow_type(&mut object_149, var_148)?;
object_149.finish();
}
if let Some(var_150) = &input.task_list {
#[allow(unused_mut)]
let mut object_151 = object.key("taskList").start_object();
crate::json_ser::serialize_structure_crate_model_task_list(&mut object_151, var_150)?;
object_151.finish();
}
if let Some(var_152) = &input.task_priority {
object.key("taskPriority").string(var_152.as_str());
}
if let Some(var_153) = &input.input {
object.key("input").string(var_153.as_str());
}
if let Some(var_154) = &input.execution_start_to_close_timeout {
object
.key("executionStartToCloseTimeout")
.string(var_154.as_str());
}
if let Some(var_155) = &input.tag_list {
let mut array_156 = object.key("tagList").start_array();
for item_157 in var_155 {
{
array_156.value().string(item_157.as_str());
}
}
array_156.finish();
}
if let Some(var_158) = &input.task_start_to_close_timeout {
object
.key("taskStartToCloseTimeout")
.string(var_158.as_str());
}
if let Some(var_159) = &input.child_policy {
object.key("childPolicy").string(var_159.as_str());
}
if let Some(var_160) = &input.lambda_role {
object.key("lambdaRole").string(var_160.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_161) = &input.resource_arn {
object.key("resourceArn").string(var_161.as_str());
}
if let Some(var_162) = &input.tags {
let mut array_163 = object.key("tags").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_resource_tag(
&mut object_165,
item_164,
)?;
object_165.finish();
}
}
array_163.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_terminate_workflow_execution_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::TerminateWorkflowExecutionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_166) = &input.domain {
object.key("domain").string(var_166.as_str());
}
if let Some(var_167) = &input.workflow_id {
object.key("workflowId").string(var_167.as_str());
}
if let Some(var_168) = &input.run_id {
object.key("runId").string(var_168.as_str());
}
if let Some(var_169) = &input.reason {
object.key("reason").string(var_169.as_str());
}
if let Some(var_170) = &input.details {
object.key("details").string(var_170.as_str());
}
if let Some(var_171) = &input.child_policy {
object.key("childPolicy").string(var_171.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_undeprecate_activity_type_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UndeprecateActivityTypeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_172) = &input.domain {
object.key("domain").string(var_172.as_str());
}
if let Some(var_173) = &input.activity_type {
#[allow(unused_mut)]
let mut object_174 = object.key("activityType").start_object();
crate::json_ser::serialize_structure_crate_model_activity_type(&mut object_174, var_173)?;
object_174.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_undeprecate_domain_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UndeprecateDomainInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_175) = &input.name {
object.key("name").string(var_175.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_undeprecate_workflow_type_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UndeprecateWorkflowTypeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_176) = &input.domain {
object.key("domain").string(var_176.as_str());
}
if let Some(var_177) = &input.workflow_type {
#[allow(unused_mut)]
let mut object_178 = object.key("workflowType").start_object();
crate::json_ser::serialize_structure_crate_model_workflow_type(&mut object_178, var_177)?;
object_178.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_179) = &input.resource_arn {
object.key("resourceArn").string(var_179.as_str());
}
if let Some(var_180) = &input.tag_keys {
let mut array_181 = object.key("tagKeys").start_array();
for item_182 in var_180 {
{
array_181.value().string(item_182.as_str());
}
}
array_181.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_execution_time_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ExecutionTimeFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_183) = &input.oldest_date {
object
.key("oldestDate")
.date_time(var_183, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_184) = &input.latest_date {
object
.key("latestDate")
.date_time(var_184, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
Ok(())
}
pub fn serialize_structure_crate_model_workflow_execution_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::WorkflowExecutionFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_185) = &input.workflow_id {
object.key("workflowId").string(var_185.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_workflow_type_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::WorkflowTypeFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_186) = &input.name {
object.key("name").string(var_186.as_str());
}
if let Some(var_187) = &input.version {
object.key("version").string(var_187.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_tag_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TagFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_188) = &input.tag {
object.key("tag").string(var_188.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_close_status_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CloseStatusFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_189) = &input.status {
object.key("status").string(var_189.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_task_list(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TaskList,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_190) = &input.name {
object.key("name").string(var_190.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_activity_type(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ActivityType,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_191) = &input.name {
object.key("name").string(var_191.as_str());
}
if let Some(var_192) = &input.version {
object.key("version").string(var_192.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_workflow_type(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::WorkflowType,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_193) = &input.name {
object.key("name").string(var_193.as_str());
}
if let Some(var_194) = &input.version {
object.key("version").string(var_194.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_workflow_execution(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::WorkflowExecution,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_195) = &input.workflow_id {
object.key("workflowId").string(var_195.as_str());
}
if let Some(var_196) = &input.run_id {
object.key("runId").string(var_196.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_resource_tag(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ResourceTag,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_197) = &input.key {
object.key("key").string(var_197.as_str());
}
if let Some(var_198) = &input.value {
object.key("value").string(var_198.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_decision(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Decision,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_199) = &input.decision_type {
object.key("decisionType").string(var_199.as_str());
}
if let Some(var_200) = &input.schedule_activity_task_decision_attributes {
#[allow(unused_mut)]
let mut object_201 = object
.key("scheduleActivityTaskDecisionAttributes")
.start_object();
crate::json_ser::serialize_structure_crate_model_schedule_activity_task_decision_attributes(&mut object_201, var_200)?;
object_201.finish();
}
if let Some(var_202) = &input.request_cancel_activity_task_decision_attributes {
#[allow(unused_mut)]
let mut object_203 = object
.key("requestCancelActivityTaskDecisionAttributes")
.start_object();
crate::json_ser::serialize_structure_crate_model_request_cancel_activity_task_decision_attributes(&mut object_203, var_202)?;
object_203.finish();
}
if let Some(var_204) = &input.complete_workflow_execution_decision_attributes {
#[allow(unused_mut)]
let mut object_205 = object
.key("completeWorkflowExecutionDecisionAttributes")
.start_object();
crate::json_ser::serialize_structure_crate_model_complete_workflow_execution_decision_attributes(&mut object_205, var_204)?;
object_205.finish();
}
if let Some(var_206) = &input.fail_workflow_execution_decision_attributes {
#[allow(unused_mut)]
let mut object_207 = object
.key("failWorkflowExecutionDecisionAttributes")
.start_object();
crate::json_ser::serialize_structure_crate_model_fail_workflow_execution_decision_attributes(&mut object_207, var_206)?;
object_207.finish();
}
if let Some(var_208) = &input.cancel_workflow_execution_decision_attributes {
#[allow(unused_mut)]
let mut object_209 = object
.key("cancelWorkflowExecutionDecisionAttributes")
.start_object();
crate::json_ser::serialize_structure_crate_model_cancel_workflow_execution_decision_attributes(&mut object_209, var_208)?;
object_209.finish();
}
if let Some(var_210) = &input.continue_as_new_workflow_execution_decision_attributes {
#[allow(unused_mut)]
let mut object_211 = object
.key("continueAsNewWorkflowExecutionDecisionAttributes")
.start_object();
crate::json_ser::serialize_structure_crate_model_continue_as_new_workflow_execution_decision_attributes(&mut object_211, var_210)?;
object_211.finish();
}
if let Some(var_212) = &input.record_marker_decision_attributes {
#[allow(unused_mut)]
let mut object_213 = object.key("recordMarkerDecisionAttributes").start_object();
crate::json_ser::serialize_structure_crate_model_record_marker_decision_attributes(
&mut object_213,
var_212,
)?;
object_213.finish();
}
if let Some(var_214) = &input.start_timer_decision_attributes {
#[allow(unused_mut)]
let mut object_215 = object.key("startTimerDecisionAttributes").start_object();
crate::json_ser::serialize_structure_crate_model_start_timer_decision_attributes(
&mut object_215,
var_214,
)?;
object_215.finish();
}
if let Some(var_216) = &input.cancel_timer_decision_attributes {
#[allow(unused_mut)]
let mut object_217 = object.key("cancelTimerDecisionAttributes").start_object();
crate::json_ser::serialize_structure_crate_model_cancel_timer_decision_attributes(
&mut object_217,
var_216,
)?;
object_217.finish();
}
if let Some(var_218) = &input.signal_external_workflow_execution_decision_attributes {
#[allow(unused_mut)]
let mut object_219 = object
.key("signalExternalWorkflowExecutionDecisionAttributes")
.start_object();
crate::json_ser::serialize_structure_crate_model_signal_external_workflow_execution_decision_attributes(&mut object_219, var_218)?;
object_219.finish();
}
if let Some(var_220) = &input.request_cancel_external_workflow_execution_decision_attributes {
#[allow(unused_mut)]
let mut object_221 = object
.key("requestCancelExternalWorkflowExecutionDecisionAttributes")
.start_object();
crate::json_ser::serialize_structure_crate_model_request_cancel_external_workflow_execution_decision_attributes(&mut object_221, var_220)?;
object_221.finish();
}
if let Some(var_222) = &input.start_child_workflow_execution_decision_attributes {
#[allow(unused_mut)]
let mut object_223 = object
.key("startChildWorkflowExecutionDecisionAttributes")
.start_object();
crate::json_ser::serialize_structure_crate_model_start_child_workflow_execution_decision_attributes(&mut object_223, var_222)?;
object_223.finish();
}
if let Some(var_224) = &input.schedule_lambda_function_decision_attributes {
#[allow(unused_mut)]
let mut object_225 = object
.key("scheduleLambdaFunctionDecisionAttributes")
.start_object();
crate::json_ser::serialize_structure_crate_model_schedule_lambda_function_decision_attributes(&mut object_225, var_224)?;
object_225.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_schedule_activity_task_decision_attributes(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ScheduleActivityTaskDecisionAttributes,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_226) = &input.activity_type {
#[allow(unused_mut)]
let mut object_227 = object.key("activityType").start_object();
crate::json_ser::serialize_structure_crate_model_activity_type(&mut object_227, var_226)?;
object_227.finish();
}
if let Some(var_228) = &input.activity_id {
object.key("activityId").string(var_228.as_str());
}
if let Some(var_229) = &input.control {
object.key("control").string(var_229.as_str());
}
if let Some(var_230) = &input.input {
object.key("input").string(var_230.as_str());
}
if let Some(var_231) = &input.schedule_to_close_timeout {
object
.key("scheduleToCloseTimeout")
.string(var_231.as_str());
}
if let Some(var_232) = &input.task_list {
#[allow(unused_mut)]
let mut object_233 = object.key("taskList").start_object();
crate::json_ser::serialize_structure_crate_model_task_list(&mut object_233, var_232)?;
object_233.finish();
}
if let Some(var_234) = &input.task_priority {
object.key("taskPriority").string(var_234.as_str());
}
if let Some(var_235) = &input.schedule_to_start_timeout {
object
.key("scheduleToStartTimeout")
.string(var_235.as_str());
}
if let Some(var_236) = &input.start_to_close_timeout {
object.key("startToCloseTimeout").string(var_236.as_str());
}
if let Some(var_237) = &input.heartbeat_timeout {
object.key("heartbeatTimeout").string(var_237.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_request_cancel_activity_task_decision_attributes(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RequestCancelActivityTaskDecisionAttributes,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_238) = &input.activity_id {
object.key("activityId").string(var_238.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_complete_workflow_execution_decision_attributes(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CompleteWorkflowExecutionDecisionAttributes,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_239) = &input.result {
object.key("result").string(var_239.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_fail_workflow_execution_decision_attributes(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FailWorkflowExecutionDecisionAttributes,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_240) = &input.reason {
object.key("reason").string(var_240.as_str());
}
if let Some(var_241) = &input.details {
object.key("details").string(var_241.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_cancel_workflow_execution_decision_attributes(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CancelWorkflowExecutionDecisionAttributes,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_242) = &input.details {
object.key("details").string(var_242.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_continue_as_new_workflow_execution_decision_attributes(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ContinueAsNewWorkflowExecutionDecisionAttributes,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_243) = &input.input {
object.key("input").string(var_243.as_str());
}
if let Some(var_244) = &input.execution_start_to_close_timeout {
object
.key("executionStartToCloseTimeout")
.string(var_244.as_str());
}
if let Some(var_245) = &input.task_list {
#[allow(unused_mut)]
let mut object_246 = object.key("taskList").start_object();
crate::json_ser::serialize_structure_crate_model_task_list(&mut object_246, var_245)?;
object_246.finish();
}
if let Some(var_247) = &input.task_priority {
object.key("taskPriority").string(var_247.as_str());
}
if let Some(var_248) = &input.task_start_to_close_timeout {
object
.key("taskStartToCloseTimeout")
.string(var_248.as_str());
}
if let Some(var_249) = &input.child_policy {
object.key("childPolicy").string(var_249.as_str());
}
if let Some(var_250) = &input.tag_list {
let mut array_251 = object.key("tagList").start_array();
for item_252 in var_250 {
{
array_251.value().string(item_252.as_str());
}
}
array_251.finish();
}
if let Some(var_253) = &input.workflow_type_version {
object.key("workflowTypeVersion").string(var_253.as_str());
}
if let Some(var_254) = &input.lambda_role {
object.key("lambdaRole").string(var_254.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_record_marker_decision_attributes(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RecordMarkerDecisionAttributes,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_255) = &input.marker_name {
object.key("markerName").string(var_255.as_str());
}
if let Some(var_256) = &input.details {
object.key("details").string(var_256.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_start_timer_decision_attributes(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StartTimerDecisionAttributes,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_257) = &input.timer_id {
object.key("timerId").string(var_257.as_str());
}
if let Some(var_258) = &input.control {
object.key("control").string(var_258.as_str());
}
if let Some(var_259) = &input.start_to_fire_timeout {
object.key("startToFireTimeout").string(var_259.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_cancel_timer_decision_attributes(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CancelTimerDecisionAttributes,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_260) = &input.timer_id {
object.key("timerId").string(var_260.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_signal_external_workflow_execution_decision_attributes(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SignalExternalWorkflowExecutionDecisionAttributes,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_261) = &input.workflow_id {
object.key("workflowId").string(var_261.as_str());
}
if let Some(var_262) = &input.run_id {
object.key("runId").string(var_262.as_str());
}
if let Some(var_263) = &input.signal_name {
object.key("signalName").string(var_263.as_str());
}
if let Some(var_264) = &input.input {
object.key("input").string(var_264.as_str());
}
if let Some(var_265) = &input.control {
object.key("control").string(var_265.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_request_cancel_external_workflow_execution_decision_attributes(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RequestCancelExternalWorkflowExecutionDecisionAttributes,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_266) = &input.workflow_id {
object.key("workflowId").string(var_266.as_str());
}
if let Some(var_267) = &input.run_id {
object.key("runId").string(var_267.as_str());
}
if let Some(var_268) = &input.control {
object.key("control").string(var_268.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_start_child_workflow_execution_decision_attributes(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StartChildWorkflowExecutionDecisionAttributes,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_269) = &input.workflow_type {
#[allow(unused_mut)]
let mut object_270 = object.key("workflowType").start_object();
crate::json_ser::serialize_structure_crate_model_workflow_type(&mut object_270, var_269)?;
object_270.finish();
}
if let Some(var_271) = &input.workflow_id {
object.key("workflowId").string(var_271.as_str());
}
if let Some(var_272) = &input.control {
object.key("control").string(var_272.as_str());
}
if let Some(var_273) = &input.input {
object.key("input").string(var_273.as_str());
}
if let Some(var_274) = &input.execution_start_to_close_timeout {
object
.key("executionStartToCloseTimeout")
.string(var_274.as_str());
}
if let Some(var_275) = &input.task_list {
#[allow(unused_mut)]
let mut object_276 = object.key("taskList").start_object();
crate::json_ser::serialize_structure_crate_model_task_list(&mut object_276, var_275)?;
object_276.finish();
}
if let Some(var_277) = &input.task_priority {
object.key("taskPriority").string(var_277.as_str());
}
if let Some(var_278) = &input.task_start_to_close_timeout {
object
.key("taskStartToCloseTimeout")
.string(var_278.as_str());
}
if let Some(var_279) = &input.child_policy {
object.key("childPolicy").string(var_279.as_str());
}
if let Some(var_280) = &input.tag_list {
let mut array_281 = object.key("tagList").start_array();
for item_282 in var_280 {
{
array_281.value().string(item_282.as_str());
}
}
array_281.finish();
}
if let Some(var_283) = &input.lambda_role {
object.key("lambdaRole").string(var_283.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_schedule_lambda_function_decision_attributes(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ScheduleLambdaFunctionDecisionAttributes,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_284) = &input.id {
object.key("id").string(var_284.as_str());
}
if let Some(var_285) = &input.name {
object.key("name").string(var_285.as_str());
}
if let Some(var_286) = &input.control {
object.key("control").string(var_286.as_str());
}
if let Some(var_287) = &input.input {
object.key("input").string(var_287.as_str());
}
if let Some(var_288) = &input.start_to_close_timeout {
object.key("startToCloseTimeout").string(var_288.as_str());
}
Ok(())
}