pub fn serialize_structure_crate_input_create_cluster_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateClusterInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.client_token {
object.key("ClientToken").string(var_1.as_str());
}
if let Some(var_2) = &input.cluster_name {
object.key("ClusterName").string(var_2.as_str());
}
if let Some(var_3) = &input.tags {
#[allow(unused_mut)]
let mut object_4 = object.key("Tags").start_object();
for (key_5, value_6) in var_3 {
{
object_4.key(key_5.as_str()).string(value_6.as_str());
}
}
object_4.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_control_panel_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateControlPanelInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_7) = &input.client_token {
object.key("ClientToken").string(var_7.as_str());
}
if let Some(var_8) = &input.cluster_arn {
object.key("ClusterArn").string(var_8.as_str());
}
if let Some(var_9) = &input.control_panel_name {
object.key("ControlPanelName").string(var_9.as_str());
}
if let Some(var_10) = &input.tags {
#[allow(unused_mut)]
let mut object_11 = object.key("Tags").start_object();
for (key_12, value_13) in var_10 {
{
object_11.key(key_12.as_str()).string(value_13.as_str());
}
}
object_11.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_routing_control_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateRoutingControlInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_14) = &input.client_token {
object.key("ClientToken").string(var_14.as_str());
}
if let Some(var_15) = &input.cluster_arn {
object.key("ClusterArn").string(var_15.as_str());
}
if let Some(var_16) = &input.control_panel_arn {
object.key("ControlPanelArn").string(var_16.as_str());
}
if let Some(var_17) = &input.routing_control_name {
object.key("RoutingControlName").string(var_17.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_safety_rule_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateSafetyRuleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_18) = &input.assertion_rule {
#[allow(unused_mut)]
let mut object_19 = object.key("AssertionRule").start_object();
crate::json_ser::serialize_structure_crate_model_new_assertion_rule(
&mut object_19,
var_18,
)?;
object_19.finish();
}
if let Some(var_20) = &input.client_token {
object.key("ClientToken").string(var_20.as_str());
}
if let Some(var_21) = &input.gating_rule {
#[allow(unused_mut)]
let mut object_22 = object.key("GatingRule").start_object();
crate::json_ser::serialize_structure_crate_model_new_gating_rule(&mut object_22, var_21)?;
object_22.finish();
}
if let Some(var_23) = &input.tags {
#[allow(unused_mut)]
let mut object_24 = object.key("Tags").start_object();
for (key_25, value_26) in var_23 {
{
object_24.key(key_25.as_str()).string(value_26.as_str());
}
}
object_24.finish();
}
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_27) = &input.tags {
#[allow(unused_mut)]
let mut object_28 = object.key("Tags").start_object();
for (key_29, value_30) in var_27 {
{
object_28.key(key_29.as_str()).string(value_30.as_str());
}
}
object_28.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_control_panel_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateControlPanelInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_31) = &input.control_panel_arn {
object.key("ControlPanelArn").string(var_31.as_str());
}
if let Some(var_32) = &input.control_panel_name {
object.key("ControlPanelName").string(var_32.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_routing_control_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateRoutingControlInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_33) = &input.routing_control_arn {
object.key("RoutingControlArn").string(var_33.as_str());
}
if let Some(var_34) = &input.routing_control_name {
object.key("RoutingControlName").string(var_34.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_safety_rule_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateSafetyRuleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_35) = &input.assertion_rule_update {
#[allow(unused_mut)]
let mut object_36 = object.key("AssertionRuleUpdate").start_object();
crate::json_ser::serialize_structure_crate_model_assertion_rule_update(
&mut object_36,
var_35,
)?;
object_36.finish();
}
if let Some(var_37) = &input.gating_rule_update {
#[allow(unused_mut)]
let mut object_38 = object.key("GatingRuleUpdate").start_object();
crate::json_ser::serialize_structure_crate_model_gating_rule_update(
&mut object_38,
var_37,
)?;
object_38.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_new_assertion_rule(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::NewAssertionRule,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_39) = &input.asserted_controls {
let mut array_40 = object.key("AssertedControls").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.control_panel_arn {
object.key("ControlPanelArn").string(var_42.as_str());
}
if let Some(var_43) = &input.name {
object.key("Name").string(var_43.as_str());
}
if let Some(var_44) = &input.rule_config {
#[allow(unused_mut)]
let mut object_45 = object.key("RuleConfig").start_object();
crate::json_ser::serialize_structure_crate_model_rule_config(&mut object_45, var_44)?;
object_45.finish();
}
{
object.key("WaitPeriodMs").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.wait_period_ms).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_new_gating_rule(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::NewGatingRule,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_46) = &input.control_panel_arn {
object.key("ControlPanelArn").string(var_46.as_str());
}
if let Some(var_47) = &input.gating_controls {
let mut array_48 = object.key("GatingControls").start_array();
for item_49 in var_47 {
{
array_48.value().string(item_49.as_str());
}
}
array_48.finish();
}
if let Some(var_50) = &input.name {
object.key("Name").string(var_50.as_str());
}
if let Some(var_51) = &input.rule_config {
#[allow(unused_mut)]
let mut object_52 = object.key("RuleConfig").start_object();
crate::json_ser::serialize_structure_crate_model_rule_config(&mut object_52, var_51)?;
object_52.finish();
}
if let Some(var_53) = &input.target_controls {
let mut array_54 = object.key("TargetControls").start_array();
for item_55 in var_53 {
{
array_54.value().string(item_55.as_str());
}
}
array_54.finish();
}
{
object.key("WaitPeriodMs").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.wait_period_ms).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_assertion_rule_update(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AssertionRuleUpdate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_56) = &input.name {
object.key("Name").string(var_56.as_str());
}
if let Some(var_57) = &input.safety_rule_arn {
object.key("SafetyRuleArn").string(var_57.as_str());
}
{
object.key("WaitPeriodMs").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.wait_period_ms).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_gating_rule_update(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GatingRuleUpdate,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_58) = &input.name {
object.key("Name").string(var_58.as_str());
}
if let Some(var_59) = &input.safety_rule_arn {
object.key("SafetyRuleArn").string(var_59.as_str());
}
{
object.key("WaitPeriodMs").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.wait_period_ms).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_rule_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RuleConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
{
object.key("Inverted").boolean(input.inverted);
}
{
object.key("Threshold").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.threshold).into()),
);
}
if let Some(var_60) = &input.r#type {
object.key("Type").string(var_60.as_str());
}
Ok(())
}