pub fn serialize_structure_crate_input_create_workflow_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateWorkflowInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.application_configuration_id {
object
.key("applicationConfigurationId")
.string(var_1.as_str());
}
if let Some(var_2) = &input.description {
object.key("description").string(var_2.as_str());
}
if let Some(var_3) = &input.input_parameters {
#[allow(unused_mut)]
let mut object_4 = object.key("inputParameters").start_object();
for (key_5, value_6) in var_3 {
{
#[allow(unused_mut)]
let mut object_7 = object_4.key(key_5.as_str()).start_object();
crate::json_ser::serialize_union_crate_model_step_input(&mut object_7, value_6)?;
object_7.finish();
}
}
object_4.finish();
}
if let Some(var_8) = &input.name {
object.key("name").string(var_8.as_str());
}
if let Some(var_9) = &input.step_targets {
let mut array_10 = object.key("stepTargets").start_array();
for item_11 in var_9 {
{
array_10.value().string(item_11.as_str());
}
}
array_10.finish();
}
if let Some(var_12) = &input.tags {
#[allow(unused_mut)]
let mut object_13 = object.key("tags").start_object();
for (key_14, value_15) in var_12 {
{
object_13.key(key_14.as_str()).string(value_15.as_str());
}
}
object_13.finish();
}
if let Some(var_16) = &input.template_id {
object.key("templateId").string(var_16.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_workflow_step_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateWorkflowStepInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_17) = &input.description {
object.key("description").string(var_17.as_str());
}
if let Some(var_18) = &input.name {
object.key("name").string(var_18.as_str());
}
if let Some(var_19) = &input.next {
let mut array_20 = object.key("next").start_array();
for item_21 in var_19 {
{
array_20.value().string(item_21.as_str());
}
}
array_20.finish();
}
if let Some(var_22) = &input.outputs {
let mut array_23 = object.key("outputs").start_array();
for item_24 in var_22 {
{
#[allow(unused_mut)]
let mut object_25 = array_23.value().start_object();
crate::json_ser::serialize_structure_crate_model_workflow_step_output(
&mut object_25,
item_24,
)?;
object_25.finish();
}
}
array_23.finish();
}
if let Some(var_26) = &input.previous {
let mut array_27 = object.key("previous").start_array();
for item_28 in var_26 {
{
array_27.value().string(item_28.as_str());
}
}
array_27.finish();
}
if let Some(var_29) = &input.step_action_type {
object.key("stepActionType").string(var_29.as_str());
}
if let Some(var_30) = &input.step_group_id {
object.key("stepGroupId").string(var_30.as_str());
}
if let Some(var_31) = &input.step_target {
let mut array_32 = object.key("stepTarget").start_array();
for item_33 in var_31 {
{
array_32.value().string(item_33.as_str());
}
}
array_32.finish();
}
if let Some(var_34) = &input.workflow_id {
object.key("workflowId").string(var_34.as_str());
}
if let Some(var_35) = &input.workflow_step_automation_configuration {
#[allow(unused_mut)]
let mut object_36 = object
.key("workflowStepAutomationConfiguration")
.start_object();
crate::json_ser::serialize_structure_crate_model_workflow_step_automation_configuration(
&mut object_36,
var_35,
)?;
object_36.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_workflow_step_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateWorkflowStepGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_37) = &input.description {
object.key("description").string(var_37.as_str());
}
if let Some(var_38) = &input.name {
object.key("name").string(var_38.as_str());
}
if let Some(var_39) = &input.next {
let mut array_40 = object.key("next").start_array();
for item_41 in var_39 {
{
array_40.value().string(item_41.as_str());
}
}
array_40.finish();
}
if let Some(var_42) = &input.previous {
let mut array_43 = object.key("previous").start_array();
for item_44 in var_42 {
{
array_43.value().string(item_44.as_str());
}
}
array_43.finish();
}
if let Some(var_45) = &input.workflow_id {
object.key("workflowId").string(var_45.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_46) = &input.tags {
#[allow(unused_mut)]
let mut object_47 = object.key("tags").start_object();
for (key_48, value_49) in var_46 {
{
object_47.key(key_48.as_str()).string(value_49.as_str());
}
}
object_47.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_workflow_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateWorkflowInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_50) = &input.description {
object.key("description").string(var_50.as_str());
}
if let Some(var_51) = &input.input_parameters {
#[allow(unused_mut)]
let mut object_52 = object.key("inputParameters").start_object();
for (key_53, value_54) in var_51 {
{
#[allow(unused_mut)]
let mut object_55 = object_52.key(key_53.as_str()).start_object();
crate::json_ser::serialize_union_crate_model_step_input(&mut object_55, value_54)?;
object_55.finish();
}
}
object_52.finish();
}
if let Some(var_56) = &input.name {
object.key("name").string(var_56.as_str());
}
if let Some(var_57) = &input.step_targets {
let mut array_58 = object.key("stepTargets").start_array();
for item_59 in var_57 {
{
array_58.value().string(item_59.as_str());
}
}
array_58.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_workflow_step_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateWorkflowStepInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_60) = &input.description {
object.key("description").string(var_60.as_str());
}
if let Some(var_61) = &input.name {
object.key("name").string(var_61.as_str());
}
if let Some(var_62) = &input.next {
let mut array_63 = object.key("next").start_array();
for item_64 in var_62 {
{
array_63.value().string(item_64.as_str());
}
}
array_63.finish();
}
if let Some(var_65) = &input.outputs {
let mut array_66 = object.key("outputs").start_array();
for item_67 in var_65 {
{
#[allow(unused_mut)]
let mut object_68 = array_66.value().start_object();
crate::json_ser::serialize_structure_crate_model_workflow_step_output(
&mut object_68,
item_67,
)?;
object_68.finish();
}
}
array_66.finish();
}
if let Some(var_69) = &input.previous {
let mut array_70 = object.key("previous").start_array();
for item_71 in var_69 {
{
array_70.value().string(item_71.as_str());
}
}
array_70.finish();
}
if let Some(var_72) = &input.status {
object.key("status").string(var_72.as_str());
}
if let Some(var_73) = &input.step_action_type {
object.key("stepActionType").string(var_73.as_str());
}
if let Some(var_74) = &input.step_group_id {
object.key("stepGroupId").string(var_74.as_str());
}
if let Some(var_75) = &input.step_target {
let mut array_76 = object.key("stepTarget").start_array();
for item_77 in var_75 {
{
array_76.value().string(item_77.as_str());
}
}
array_76.finish();
}
if let Some(var_78) = &input.workflow_id {
object.key("workflowId").string(var_78.as_str());
}
if let Some(var_79) = &input.workflow_step_automation_configuration {
#[allow(unused_mut)]
let mut object_80 = object
.key("workflowStepAutomationConfiguration")
.start_object();
crate::json_ser::serialize_structure_crate_model_workflow_step_automation_configuration(
&mut object_80,
var_79,
)?;
object_80.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_workflow_step_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateWorkflowStepGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_81) = &input.description {
object.key("description").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.next {
let mut array_84 = object.key("next").start_array();
for item_85 in var_83 {
{
array_84.value().string(item_85.as_str());
}
}
array_84.finish();
}
if let Some(var_86) = &input.previous {
let mut array_87 = object.key("previous").start_array();
for item_88 in var_86 {
{
array_87.value().string(item_88.as_str());
}
}
array_87.finish();
}
Ok(())
}
pub fn serialize_union_crate_model_step_input(
object_7: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StepInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
match input {
crate::model::StepInput::IntegerValue(inner) => {
object_7.key("integerValue").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*inner).into()),
);
}
crate::model::StepInput::StringValue(inner) => {
object_7.key("stringValue").string(inner.as_str());
}
crate::model::StepInput::ListOfStringsValue(inner) => {
let mut array_89 = object_7.key("listOfStringsValue").start_array();
for item_90 in inner {
{
array_89.value().string(item_90.as_str());
}
}
array_89.finish();
}
crate::model::StepInput::MapOfStringValue(inner) => {
#[allow(unused_mut)]
let mut object_91 = object_7.key("mapOfStringValue").start_object();
for (key_92, value_93) in inner {
{
object_91.key(key_92.as_str()).string(value_93.as_str());
}
}
object_91.finish();
}
crate::model::StepInput::Unknown => {
return Err(
aws_smithy_http::operation::error::SerializationError::unknown_variant("StepInput"),
)
}
}
Ok(())
}
pub fn serialize_structure_crate_model_workflow_step_output(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::WorkflowStepOutput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_94) = &input.name {
object.key("name").string(var_94.as_str());
}
if let Some(var_95) = &input.data_type {
object.key("dataType").string(var_95.as_str());
}
if let Some(var_96) = &input.required {
object.key("required").boolean(*var_96);
}
if let Some(var_97) = &input.value {
#[allow(unused_mut)]
let mut object_98 = object.key("value").start_object();
crate::json_ser::serialize_union_crate_model_workflow_step_output_union(
&mut object_98,
var_97,
)?;
object_98.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_workflow_step_automation_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::WorkflowStepAutomationConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_99) = &input.script_location_s3_bucket {
object.key("scriptLocationS3Bucket").string(var_99.as_str());
}
if let Some(var_100) = &input.script_location_s3_key {
#[allow(unused_mut)]
let mut object_101 = object.key("scriptLocationS3Key").start_object();
crate::json_ser::serialize_structure_crate_model_platform_script_key(
&mut object_101,
var_100,
)?;
object_101.finish();
}
if let Some(var_102) = &input.command {
#[allow(unused_mut)]
let mut object_103 = object.key("command").start_object();
crate::json_ser::serialize_structure_crate_model_platform_command(
&mut object_103,
var_102,
)?;
object_103.finish();
}
if let Some(var_104) = &input.run_environment {
object.key("runEnvironment").string(var_104.as_str());
}
if let Some(var_105) = &input.target_type {
object.key("targetType").string(var_105.as_str());
}
Ok(())
}
pub fn serialize_union_crate_model_workflow_step_output_union(
object_98: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::WorkflowStepOutputUnion,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
match input {
crate::model::WorkflowStepOutputUnion::IntegerValue(inner) => {
object_98.key("integerValue").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*inner).into()),
);
}
crate::model::WorkflowStepOutputUnion::StringValue(inner) => {
object_98.key("stringValue").string(inner.as_str());
}
crate::model::WorkflowStepOutputUnion::ListOfStringValue(inner) => {
let mut array_106 = object_98.key("listOfStringValue").start_array();
for item_107 in inner {
{
array_106.value().string(item_107.as_str());
}
}
array_106.finish();
}
crate::model::WorkflowStepOutputUnion::Unknown => {
return Err(
aws_smithy_http::operation::error::SerializationError::unknown_variant(
"WorkflowStepOutputUnion",
),
)
}
}
Ok(())
}
pub fn serialize_structure_crate_model_platform_script_key(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PlatformScriptKey,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_108) = &input.linux {
object.key("linux").string(var_108.as_str());
}
if let Some(var_109) = &input.windows {
object.key("windows").string(var_109.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_platform_command(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PlatformCommand,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_110) = &input.linux {
object.key("linux").string(var_110.as_str());
}
if let Some(var_111) = &input.windows {
object.key("windows").string(var_111.as_str());
}
Ok(())
}