pub fn serialize_structure_crate_input_create_activity_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateActivityInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.name {
object.key("name").string(var_1.as_str());
}
if let Some(var_2) = &input.tags {
let mut array_3 = object.key("tags").start_array();
for item_4 in var_2 {
{
#[allow(unused_mut)]
let mut object_5 = array_3.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_5, item_4)?;
object_5.finish();
}
}
array_3.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_state_machine_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateStateMachineInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_6) = &input.name {
object.key("name").string(var_6.as_str());
}
if let Some(var_7) = &input.definition {
object.key("definition").string(var_7.as_str());
}
if let Some(var_8) = &input.role_arn {
object.key("roleArn").string(var_8.as_str());
}
if let Some(var_9) = &input.r#type {
object.key("type").string(var_9.as_str());
}
if let Some(var_10) = &input.logging_configuration {
#[allow(unused_mut)]
let mut object_11 = object.key("loggingConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_logging_configuration(
&mut object_11,
var_10,
)?;
object_11.finish();
}
if let Some(var_12) = &input.tags {
let mut array_13 = object.key("tags").start_array();
for item_14 in var_12 {
{
#[allow(unused_mut)]
let mut object_15 = array_13.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_15, item_14)?;
object_15.finish();
}
}
array_13.finish();
}
if let Some(var_16) = &input.tracing_configuration {
#[allow(unused_mut)]
let mut object_17 = object.key("tracingConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_tracing_configuration(
&mut object_17,
var_16,
)?;
object_17.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_activity_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteActivityInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_18) = &input.activity_arn {
object.key("activityArn").string(var_18.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_state_machine_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteStateMachineInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_19) = &input.state_machine_arn {
object.key("stateMachineArn").string(var_19.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_activity_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeActivityInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_20) = &input.activity_arn {
object.key("activityArn").string(var_20.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_execution_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeExecutionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_21) = &input.execution_arn {
object.key("executionArn").string(var_21.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_map_run_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeMapRunInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_22) = &input.map_run_arn {
object.key("mapRunArn").string(var_22.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_state_machine_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeStateMachineInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_23) = &input.state_machine_arn {
object.key("stateMachineArn").string(var_23.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_state_machine_for_execution_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeStateMachineForExecutionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_24) = &input.execution_arn {
object.key("executionArn").string(var_24.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_activity_task_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetActivityTaskInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_25) = &input.activity_arn {
object.key("activityArn").string(var_25.as_str());
}
if let Some(var_26) = &input.worker_name {
object.key("workerName").string(var_26.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_execution_history_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetExecutionHistoryInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_27) = &input.execution_arn {
object.key("executionArn").string(var_27.as_str());
}
if input.max_results != 0 {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max_results).into()),
);
}
if input.reverse_order {
object.key("reverseOrder").boolean(input.reverse_order);
}
if let Some(var_28) = &input.next_token {
object.key("nextToken").string(var_28.as_str());
}
if let Some(var_29) = &input.include_execution_data {
object.key("includeExecutionData").boolean(*var_29);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_activities_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListActivitiesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.max_results != 0 {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max_results).into()),
);
}
if let Some(var_30) = &input.next_token {
object.key("nextToken").string(var_30.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_executions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListExecutionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_31) = &input.state_machine_arn {
object.key("stateMachineArn").string(var_31.as_str());
}
if let Some(var_32) = &input.status_filter {
object.key("statusFilter").string(var_32.as_str());
}
if input.max_results != 0 {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max_results).into()),
);
}
if let Some(var_33) = &input.next_token {
object.key("nextToken").string(var_33.as_str());
}
if let Some(var_34) = &input.map_run_arn {
object.key("mapRunArn").string(var_34.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_map_runs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListMapRunsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_35) = &input.execution_arn {
object.key("executionArn").string(var_35.as_str());
}
if input.max_results != 0 {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max_results).into()),
);
}
if let Some(var_36) = &input.next_token {
object.key("nextToken").string(var_36.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_state_machines_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListStateMachinesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.max_results != 0 {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max_results).into()),
);
}
if let Some(var_37) = &input.next_token {
object.key("nextToken").string(var_37.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_tags_for_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListTagsForResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_38) = &input.resource_arn {
object.key("resourceArn").string(var_38.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_send_task_failure_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::SendTaskFailureInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_39) = &input.task_token {
object.key("taskToken").string(var_39.as_str());
}
if let Some(var_40) = &input.error {
object.key("error").string(var_40.as_str());
}
if let Some(var_41) = &input.cause {
object.key("cause").string(var_41.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_send_task_heartbeat_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::SendTaskHeartbeatInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_42) = &input.task_token {
object.key("taskToken").string(var_42.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_send_task_success_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::SendTaskSuccessInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_43) = &input.task_token {
object.key("taskToken").string(var_43.as_str());
}
if let Some(var_44) = &input.output {
object.key("output").string(var_44.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_start_execution_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartExecutionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_45) = &input.state_machine_arn {
object.key("stateMachineArn").string(var_45.as_str());
}
if let Some(var_46) = &input.name {
object.key("name").string(var_46.as_str());
}
if let Some(var_47) = &input.input {
object.key("input").string(var_47.as_str());
}
if let Some(var_48) = &input.trace_header {
object.key("traceHeader").string(var_48.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_start_sync_execution_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartSyncExecutionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_49) = &input.state_machine_arn {
object.key("stateMachineArn").string(var_49.as_str());
}
if let Some(var_50) = &input.name {
object.key("name").string(var_50.as_str());
}
if let Some(var_51) = &input.input {
object.key("input").string(var_51.as_str());
}
if let Some(var_52) = &input.trace_header {
object.key("traceHeader").string(var_52.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_stop_execution_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StopExecutionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_53) = &input.execution_arn {
object.key("executionArn").string(var_53.as_str());
}
if let Some(var_54) = &input.error {
object.key("error").string(var_54.as_str());
}
if let Some(var_55) = &input.cause {
object.key("cause").string(var_55.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_56) = &input.resource_arn {
object.key("resourceArn").string(var_56.as_str());
}
if let Some(var_57) = &input.tags {
let mut array_58 = object.key("tags").start_array();
for item_59 in var_57 {
{
#[allow(unused_mut)]
let mut object_60 = array_58.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_60, item_59)?;
object_60.finish();
}
}
array_58.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_61) = &input.resource_arn {
object.key("resourceArn").string(var_61.as_str());
}
if let Some(var_62) = &input.tag_keys {
let mut array_63 = object.key("tagKeys").start_array();
for item_64 in var_62 {
{
array_63.value().string(item_64.as_str());
}
}
array_63.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_map_run_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateMapRunInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_65) = &input.map_run_arn {
object.key("mapRunArn").string(var_65.as_str());
}
if let Some(var_66) = &input.max_concurrency {
object.key("maxConcurrency").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_66).into()),
);
}
if let Some(var_67) = &input.tolerated_failure_percentage {
object.key("toleratedFailurePercentage").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_67).into()),
);
}
if let Some(var_68) = &input.tolerated_failure_count {
object.key("toleratedFailureCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_68).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_update_state_machine_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateStateMachineInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_69) = &input.state_machine_arn {
object.key("stateMachineArn").string(var_69.as_str());
}
if let Some(var_70) = &input.definition {
object.key("definition").string(var_70.as_str());
}
if let Some(var_71) = &input.role_arn {
object.key("roleArn").string(var_71.as_str());
}
if let Some(var_72) = &input.logging_configuration {
#[allow(unused_mut)]
let mut object_73 = object.key("loggingConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_logging_configuration(
&mut object_73,
var_72,
)?;
object_73.finish();
}
if let Some(var_74) = &input.tracing_configuration {
#[allow(unused_mut)]
let mut object_75 = object.key("tracingConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_tracing_configuration(
&mut object_75,
var_74,
)?;
object_75.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_tag(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Tag,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_76) = &input.key {
object.key("key").string(var_76.as_str());
}
if let Some(var_77) = &input.value {
object.key("value").string(var_77.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_logging_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LoggingConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_78) = &input.level {
object.key("level").string(var_78.as_str());
}
if input.include_execution_data {
object
.key("includeExecutionData")
.boolean(input.include_execution_data);
}
if let Some(var_79) = &input.destinations {
let mut array_80 = object.key("destinations").start_array();
for item_81 in var_79 {
{
#[allow(unused_mut)]
let mut object_82 = array_80.value().start_object();
crate::json_ser::serialize_structure_crate_model_log_destination(
&mut object_82,
item_81,
)?;
object_82.finish();
}
}
array_80.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_tracing_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TracingConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.enabled {
object.key("enabled").boolean(input.enabled);
}
Ok(())
}
pub fn serialize_structure_crate_model_log_destination(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LogDestination,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_83) = &input.cloud_watch_logs_log_group {
#[allow(unused_mut)]
let mut object_84 = object.key("cloudWatchLogsLogGroup").start_object();
crate::json_ser::serialize_structure_crate_model_cloud_watch_logs_log_group(
&mut object_84,
var_83,
)?;
object_84.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_cloud_watch_logs_log_group(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CloudWatchLogsLogGroup,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_85) = &input.log_group_arn {
object.key("logGroupArn").string(var_85.as_str());
}
Ok(())
}