pub fn serialize_structure_crate_input_add_instance_fleet_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AddInstanceFleetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.cluster_id {
object.key("ClusterId").string(var_1.as_str());
}
if let Some(var_2) = &input.instance_fleet {
#[allow(unused_mut)]
let mut object_3 = object.key("InstanceFleet").start_object();
crate::json_ser::serialize_structure_crate_model_instance_fleet_config(
&mut object_3,
var_2,
)?;
object_3.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_add_instance_groups_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AddInstanceGroupsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_4) = &input.instance_groups {
let mut array_5 = object.key("InstanceGroups").start_array();
for item_6 in var_4 {
{
#[allow(unused_mut)]
let mut object_7 = array_5.value().start_object();
crate::json_ser::serialize_structure_crate_model_instance_group_config(
&mut object_7,
item_6,
)?;
object_7.finish();
}
}
array_5.finish();
}
if let Some(var_8) = &input.job_flow_id {
object.key("JobFlowId").string(var_8.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_add_job_flow_steps_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AddJobFlowStepsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_9) = &input.job_flow_id {
object.key("JobFlowId").string(var_9.as_str());
}
if let Some(var_10) = &input.steps {
let mut array_11 = object.key("Steps").start_array();
for item_12 in var_10 {
{
#[allow(unused_mut)]
let mut object_13 = array_11.value().start_object();
crate::json_ser::serialize_structure_crate_model_step_config(
&mut object_13,
item_12,
)?;
object_13.finish();
}
}
array_11.finish();
}
if let Some(var_14) = &input.execution_role_arn {
object.key("ExecutionRoleArn").string(var_14.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_add_tags_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AddTagsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_15) = &input.resource_id {
object.key("ResourceId").string(var_15.as_str());
}
if let Some(var_16) = &input.tags {
let mut array_17 = object.key("Tags").start_array();
for item_18 in var_16 {
{
#[allow(unused_mut)]
let mut object_19 = array_17.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_19, item_18)?;
object_19.finish();
}
}
array_17.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_cancel_steps_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CancelStepsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_20) = &input.cluster_id {
object.key("ClusterId").string(var_20.as_str());
}
if let Some(var_21) = &input.step_ids {
let mut array_22 = object.key("StepIds").start_array();
for item_23 in var_21 {
{
array_22.value().string(item_23.as_str());
}
}
array_22.finish();
}
if let Some(var_24) = &input.step_cancellation_option {
object.key("StepCancellationOption").string(var_24.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_security_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateSecurityConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_25) = &input.name {
object.key("Name").string(var_25.as_str());
}
if let Some(var_26) = &input.security_configuration {
object.key("SecurityConfiguration").string(var_26.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_studio_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateStudioInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_27) = &input.name {
object.key("Name").string(var_27.as_str());
}
if let Some(var_28) = &input.description {
object.key("Description").string(var_28.as_str());
}
if let Some(var_29) = &input.auth_mode {
object.key("AuthMode").string(var_29.as_str());
}
if let Some(var_30) = &input.vpc_id {
object.key("VpcId").string(var_30.as_str());
}
if let Some(var_31) = &input.subnet_ids {
let mut array_32 = object.key("SubnetIds").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.service_role {
object.key("ServiceRole").string(var_34.as_str());
}
if let Some(var_35) = &input.user_role {
object.key("UserRole").string(var_35.as_str());
}
if let Some(var_36) = &input.workspace_security_group_id {
object
.key("WorkspaceSecurityGroupId")
.string(var_36.as_str());
}
if let Some(var_37) = &input.engine_security_group_id {
object.key("EngineSecurityGroupId").string(var_37.as_str());
}
if let Some(var_38) = &input.default_s3_location {
object.key("DefaultS3Location").string(var_38.as_str());
}
if let Some(var_39) = &input.idp_auth_url {
object.key("IdpAuthUrl").string(var_39.as_str());
}
if let Some(var_40) = &input.idp_relay_state_parameter_name {
object
.key("IdpRelayStateParameterName")
.string(var_40.as_str());
}
if let Some(var_41) = &input.tags {
let mut array_42 = object.key("Tags").start_array();
for item_43 in var_41 {
{
#[allow(unused_mut)]
let mut object_44 = array_42.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_44, item_43)?;
object_44.finish();
}
}
array_42.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_studio_session_mapping_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateStudioSessionMappingInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_45) = &input.studio_id {
object.key("StudioId").string(var_45.as_str());
}
if let Some(var_46) = &input.identity_id {
object.key("IdentityId").string(var_46.as_str());
}
if let Some(var_47) = &input.identity_name {
object.key("IdentityName").string(var_47.as_str());
}
if let Some(var_48) = &input.identity_type {
object.key("IdentityType").string(var_48.as_str());
}
if let Some(var_49) = &input.session_policy_arn {
object.key("SessionPolicyArn").string(var_49.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_security_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteSecurityConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_50) = &input.name {
object.key("Name").string(var_50.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_studio_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteStudioInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_51) = &input.studio_id {
object.key("StudioId").string(var_51.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_studio_session_mapping_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteStudioSessionMappingInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_52) = &input.studio_id {
object.key("StudioId").string(var_52.as_str());
}
if let Some(var_53) = &input.identity_id {
object.key("IdentityId").string(var_53.as_str());
}
if let Some(var_54) = &input.identity_name {
object.key("IdentityName").string(var_54.as_str());
}
if let Some(var_55) = &input.identity_type {
object.key("IdentityType").string(var_55.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_cluster_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeClusterInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_56) = &input.cluster_id {
object.key("ClusterId").string(var_56.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_job_flows_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeJobFlowsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_57) = &input.created_after {
object
.key("CreatedAfter")
.date_time(var_57, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_58) = &input.created_before {
object
.key("CreatedBefore")
.date_time(var_58, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_59) = &input.job_flow_ids {
let mut array_60 = object.key("JobFlowIds").start_array();
for item_61 in var_59 {
{
array_60.value().string(item_61.as_str());
}
}
array_60.finish();
}
if let Some(var_62) = &input.job_flow_states {
let mut array_63 = object.key("JobFlowStates").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_describe_notebook_execution_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeNotebookExecutionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_65) = &input.notebook_execution_id {
object.key("NotebookExecutionId").string(var_65.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_release_label_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeReleaseLabelInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_66) = &input.release_label {
object.key("ReleaseLabel").string(var_66.as_str());
}
if let Some(var_67) = &input.next_token {
object.key("NextToken").string(var_67.as_str());
}
if let Some(var_68) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_68).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_security_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeSecurityConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_69) = &input.name {
object.key("Name").string(var_69.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_step_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeStepInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_70) = &input.cluster_id {
object.key("ClusterId").string(var_70.as_str());
}
if let Some(var_71) = &input.step_id {
object.key("StepId").string(var_71.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_studio_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeStudioInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_72) = &input.studio_id {
object.key("StudioId").string(var_72.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_auto_termination_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetAutoTerminationPolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_73) = &input.cluster_id {
object.key("ClusterId").string(var_73.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_cluster_session_credentials_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetClusterSessionCredentialsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_74) = &input.cluster_id {
object.key("ClusterId").string(var_74.as_str());
}
if let Some(var_75) = &input.execution_role_arn {
object.key("ExecutionRoleArn").string(var_75.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_managed_scaling_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetManagedScalingPolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_76) = &input.cluster_id {
object.key("ClusterId").string(var_76.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_studio_session_mapping_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetStudioSessionMappingInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_77) = &input.studio_id {
object.key("StudioId").string(var_77.as_str());
}
if let Some(var_78) = &input.identity_id {
object.key("IdentityId").string(var_78.as_str());
}
if let Some(var_79) = &input.identity_name {
object.key("IdentityName").string(var_79.as_str());
}
if let Some(var_80) = &input.identity_type {
object.key("IdentityType").string(var_80.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_bootstrap_actions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListBootstrapActionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_81) = &input.cluster_id {
object.key("ClusterId").string(var_81.as_str());
}
if let Some(var_82) = &input.marker {
object.key("Marker").string(var_82.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_clusters_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListClustersInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_83) = &input.created_after {
object
.key("CreatedAfter")
.date_time(var_83, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_84) = &input.created_before {
object
.key("CreatedBefore")
.date_time(var_84, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_85) = &input.cluster_states {
let mut array_86 = object.key("ClusterStates").start_array();
for item_87 in var_85 {
{
array_86.value().string(item_87.as_str());
}
}
array_86.finish();
}
if let Some(var_88) = &input.marker {
object.key("Marker").string(var_88.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_instance_fleets_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListInstanceFleetsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_89) = &input.cluster_id {
object.key("ClusterId").string(var_89.as_str());
}
if let Some(var_90) = &input.marker {
object.key("Marker").string(var_90.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_instance_groups_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListInstanceGroupsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_91) = &input.cluster_id {
object.key("ClusterId").string(var_91.as_str());
}
if let Some(var_92) = &input.marker {
object.key("Marker").string(var_92.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_instances_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListInstancesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_93) = &input.cluster_id {
object.key("ClusterId").string(var_93.as_str());
}
if let Some(var_94) = &input.instance_group_id {
object.key("InstanceGroupId").string(var_94.as_str());
}
if let Some(var_95) = &input.instance_group_types {
let mut array_96 = object.key("InstanceGroupTypes").start_array();
for item_97 in var_95 {
{
array_96.value().string(item_97.as_str());
}
}
array_96.finish();
}
if let Some(var_98) = &input.instance_fleet_id {
object.key("InstanceFleetId").string(var_98.as_str());
}
if let Some(var_99) = &input.instance_fleet_type {
object.key("InstanceFleetType").string(var_99.as_str());
}
if let Some(var_100) = &input.instance_states {
let mut array_101 = object.key("InstanceStates").start_array();
for item_102 in var_100 {
{
array_101.value().string(item_102.as_str());
}
}
array_101.finish();
}
if let Some(var_103) = &input.marker {
object.key("Marker").string(var_103.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_notebook_executions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListNotebookExecutionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_104) = &input.editor_id {
object.key("EditorId").string(var_104.as_str());
}
if let Some(var_105) = &input.status {
object.key("Status").string(var_105.as_str());
}
if let Some(var_106) = &input.from {
object
.key("From")
.date_time(var_106, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_107) = &input.to {
object
.key("To")
.date_time(var_107, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_108) = &input.marker {
object.key("Marker").string(var_108.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_release_labels_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListReleaseLabelsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_109) = &input.filters {
#[allow(unused_mut)]
let mut object_110 = object.key("Filters").start_object();
crate::json_ser::serialize_structure_crate_model_release_label_filter(
&mut object_110,
var_109,
)?;
object_110.finish();
}
if let Some(var_111) = &input.next_token {
object.key("NextToken").string(var_111.as_str());
}
if let Some(var_112) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_112).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_security_configurations_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListSecurityConfigurationsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_113) = &input.marker {
object.key("Marker").string(var_113.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_steps_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListStepsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_114) = &input.cluster_id {
object.key("ClusterId").string(var_114.as_str());
}
if let Some(var_115) = &input.step_states {
let mut array_116 = object.key("StepStates").start_array();
for item_117 in var_115 {
{
array_116.value().string(item_117.as_str());
}
}
array_116.finish();
}
if let Some(var_118) = &input.step_ids {
let mut array_119 = object.key("StepIds").start_array();
for item_120 in var_118 {
{
array_119.value().string(item_120.as_str());
}
}
array_119.finish();
}
if let Some(var_121) = &input.marker {
object.key("Marker").string(var_121.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_studios_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListStudiosInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_122) = &input.marker {
object.key("Marker").string(var_122.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_studio_session_mappings_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListStudioSessionMappingsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_123) = &input.studio_id {
object.key("StudioId").string(var_123.as_str());
}
if let Some(var_124) = &input.identity_type {
object.key("IdentityType").string(var_124.as_str());
}
if let Some(var_125) = &input.marker {
object.key("Marker").string(var_125.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_modify_cluster_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ModifyClusterInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_126) = &input.cluster_id {
object.key("ClusterId").string(var_126.as_str());
}
if let Some(var_127) = &input.step_concurrency_level {
object.key("StepConcurrencyLevel").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_127).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_modify_instance_fleet_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ModifyInstanceFleetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_128) = &input.cluster_id {
object.key("ClusterId").string(var_128.as_str());
}
if let Some(var_129) = &input.instance_fleet {
#[allow(unused_mut)]
let mut object_130 = object.key("InstanceFleet").start_object();
crate::json_ser::serialize_structure_crate_model_instance_fleet_modify_config(
&mut object_130,
var_129,
)?;
object_130.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_modify_instance_groups_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ModifyInstanceGroupsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_131) = &input.cluster_id {
object.key("ClusterId").string(var_131.as_str());
}
if let Some(var_132) = &input.instance_groups {
let mut array_133 = object.key("InstanceGroups").start_array();
for item_134 in var_132 {
{
#[allow(unused_mut)]
let mut object_135 = array_133.value().start_object();
crate::json_ser::serialize_structure_crate_model_instance_group_modify_config(
&mut object_135,
item_134,
)?;
object_135.finish();
}
}
array_133.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_put_auto_scaling_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutAutoScalingPolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_136) = &input.cluster_id {
object.key("ClusterId").string(var_136.as_str());
}
if let Some(var_137) = &input.instance_group_id {
object.key("InstanceGroupId").string(var_137.as_str());
}
if let Some(var_138) = &input.auto_scaling_policy {
#[allow(unused_mut)]
let mut object_139 = object.key("AutoScalingPolicy").start_object();
crate::json_ser::serialize_structure_crate_model_auto_scaling_policy(
&mut object_139,
var_138,
)?;
object_139.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_put_auto_termination_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutAutoTerminationPolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_140) = &input.cluster_id {
object.key("ClusterId").string(var_140.as_str());
}
if let Some(var_141) = &input.auto_termination_policy {
#[allow(unused_mut)]
let mut object_142 = object.key("AutoTerminationPolicy").start_object();
crate::json_ser::serialize_structure_crate_model_auto_termination_policy(
&mut object_142,
var_141,
)?;
object_142.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_put_block_public_access_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutBlockPublicAccessConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_143) = &input.block_public_access_configuration {
#[allow(unused_mut)]
let mut object_144 = object.key("BlockPublicAccessConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_block_public_access_configuration(
&mut object_144,
var_143,
)?;
object_144.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_put_managed_scaling_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutManagedScalingPolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_145) = &input.cluster_id {
object.key("ClusterId").string(var_145.as_str());
}
if let Some(var_146) = &input.managed_scaling_policy {
#[allow(unused_mut)]
let mut object_147 = object.key("ManagedScalingPolicy").start_object();
crate::json_ser::serialize_structure_crate_model_managed_scaling_policy(
&mut object_147,
var_146,
)?;
object_147.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_remove_auto_scaling_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RemoveAutoScalingPolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_148) = &input.cluster_id {
object.key("ClusterId").string(var_148.as_str());
}
if let Some(var_149) = &input.instance_group_id {
object.key("InstanceGroupId").string(var_149.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_remove_auto_termination_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RemoveAutoTerminationPolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_150) = &input.cluster_id {
object.key("ClusterId").string(var_150.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_remove_managed_scaling_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RemoveManagedScalingPolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_151) = &input.cluster_id {
object.key("ClusterId").string(var_151.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_remove_tags_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RemoveTagsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_152) = &input.resource_id {
object.key("ResourceId").string(var_152.as_str());
}
if let Some(var_153) = &input.tag_keys {
let mut array_154 = object.key("TagKeys").start_array();
for item_155 in var_153 {
{
array_154.value().string(item_155.as_str());
}
}
array_154.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_run_job_flow_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RunJobFlowInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_156) = &input.name {
object.key("Name").string(var_156.as_str());
}
if let Some(var_157) = &input.log_uri {
object.key("LogUri").string(var_157.as_str());
}
if let Some(var_158) = &input.log_encryption_kms_key_id {
object.key("LogEncryptionKmsKeyId").string(var_158.as_str());
}
if let Some(var_159) = &input.additional_info {
object.key("AdditionalInfo").string(var_159.as_str());
}
if let Some(var_160) = &input.ami_version {
object.key("AmiVersion").string(var_160.as_str());
}
if let Some(var_161) = &input.release_label {
object.key("ReleaseLabel").string(var_161.as_str());
}
if let Some(var_162) = &input.instances {
#[allow(unused_mut)]
let mut object_163 = object.key("Instances").start_object();
crate::json_ser::serialize_structure_crate_model_job_flow_instances_config(
&mut object_163,
var_162,
)?;
object_163.finish();
}
if let Some(var_164) = &input.steps {
let mut array_165 = object.key("Steps").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_step_config(
&mut object_167,
item_166,
)?;
object_167.finish();
}
}
array_165.finish();
}
if let Some(var_168) = &input.bootstrap_actions {
let mut array_169 = object.key("BootstrapActions").start_array();
for item_170 in var_168 {
{
#[allow(unused_mut)]
let mut object_171 = array_169.value().start_object();
crate::json_ser::serialize_structure_crate_model_bootstrap_action_config(
&mut object_171,
item_170,
)?;
object_171.finish();
}
}
array_169.finish();
}
if let Some(var_172) = &input.supported_products {
let mut array_173 = object.key("SupportedProducts").start_array();
for item_174 in var_172 {
{
array_173.value().string(item_174.as_str());
}
}
array_173.finish();
}
if let Some(var_175) = &input.new_supported_products {
let mut array_176 = object.key("NewSupportedProducts").start_array();
for item_177 in var_175 {
{
#[allow(unused_mut)]
let mut object_178 = array_176.value().start_object();
crate::json_ser::serialize_structure_crate_model_supported_product_config(
&mut object_178,
item_177,
)?;
object_178.finish();
}
}
array_176.finish();
}
if let Some(var_179) = &input.applications {
let mut array_180 = object.key("Applications").start_array();
for item_181 in var_179 {
{
#[allow(unused_mut)]
let mut object_182 = array_180.value().start_object();
crate::json_ser::serialize_structure_crate_model_application(
&mut object_182,
item_181,
)?;
object_182.finish();
}
}
array_180.finish();
}
if let Some(var_183) = &input.configurations {
let mut array_184 = object.key("Configurations").start_array();
for item_185 in var_183 {
{
#[allow(unused_mut)]
let mut object_186 = array_184.value().start_object();
crate::json_ser::serialize_structure_crate_model_configuration(
&mut object_186,
item_185,
)?;
object_186.finish();
}
}
array_184.finish();
}
if input.visible_to_all_users {
object
.key("VisibleToAllUsers")
.boolean(input.visible_to_all_users);
}
if let Some(var_187) = &input.job_flow_role {
object.key("JobFlowRole").string(var_187.as_str());
}
if let Some(var_188) = &input.service_role {
object.key("ServiceRole").string(var_188.as_str());
}
if let Some(var_189) = &input.tags {
let mut array_190 = object.key("Tags").start_array();
for item_191 in var_189 {
{
#[allow(unused_mut)]
let mut object_192 = array_190.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_192, item_191)?;
object_192.finish();
}
}
array_190.finish();
}
if let Some(var_193) = &input.security_configuration {
object.key("SecurityConfiguration").string(var_193.as_str());
}
if let Some(var_194) = &input.auto_scaling_role {
object.key("AutoScalingRole").string(var_194.as_str());
}
if let Some(var_195) = &input.scale_down_behavior {
object.key("ScaleDownBehavior").string(var_195.as_str());
}
if let Some(var_196) = &input.custom_ami_id {
object.key("CustomAmiId").string(var_196.as_str());
}
if let Some(var_197) = &input.ebs_root_volume_size {
object.key("EbsRootVolumeSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_197).into()),
);
}
if let Some(var_198) = &input.repo_upgrade_on_boot {
object.key("RepoUpgradeOnBoot").string(var_198.as_str());
}
if let Some(var_199) = &input.kerberos_attributes {
#[allow(unused_mut)]
let mut object_200 = object.key("KerberosAttributes").start_object();
crate::json_ser::serialize_structure_crate_model_kerberos_attributes(
&mut object_200,
var_199,
)?;
object_200.finish();
}
if let Some(var_201) = &input.step_concurrency_level {
object.key("StepConcurrencyLevel").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_201).into()),
);
}
if let Some(var_202) = &input.managed_scaling_policy {
#[allow(unused_mut)]
let mut object_203 = object.key("ManagedScalingPolicy").start_object();
crate::json_ser::serialize_structure_crate_model_managed_scaling_policy(
&mut object_203,
var_202,
)?;
object_203.finish();
}
if let Some(var_204) = &input.placement_group_configs {
let mut array_205 = object.key("PlacementGroupConfigs").start_array();
for item_206 in var_204 {
{
#[allow(unused_mut)]
let mut object_207 = array_205.value().start_object();
crate::json_ser::serialize_structure_crate_model_placement_group_config(
&mut object_207,
item_206,
)?;
object_207.finish();
}
}
array_205.finish();
}
if let Some(var_208) = &input.auto_termination_policy {
#[allow(unused_mut)]
let mut object_209 = object.key("AutoTerminationPolicy").start_object();
crate::json_ser::serialize_structure_crate_model_auto_termination_policy(
&mut object_209,
var_208,
)?;
object_209.finish();
}
if let Some(var_210) = &input.os_release_label {
object.key("OSReleaseLabel").string(var_210.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_set_termination_protection_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::SetTerminationProtectionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_211) = &input.job_flow_ids {
let mut array_212 = object.key("JobFlowIds").start_array();
for item_213 in var_211 {
{
array_212.value().string(item_213.as_str());
}
}
array_212.finish();
}
{
object
.key("TerminationProtected")
.boolean(input.termination_protected);
}
Ok(())
}
pub fn serialize_structure_crate_input_set_visible_to_all_users_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::SetVisibleToAllUsersInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_214) = &input.job_flow_ids {
let mut array_215 = object.key("JobFlowIds").start_array();
for item_216 in var_214 {
{
array_215.value().string(item_216.as_str());
}
}
array_215.finish();
}
{
object
.key("VisibleToAllUsers")
.boolean(input.visible_to_all_users);
}
Ok(())
}
pub fn serialize_structure_crate_input_start_notebook_execution_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartNotebookExecutionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_217) = &input.editor_id {
object.key("EditorId").string(var_217.as_str());
}
if let Some(var_218) = &input.relative_path {
object.key("RelativePath").string(var_218.as_str());
}
if let Some(var_219) = &input.notebook_execution_name {
object.key("NotebookExecutionName").string(var_219.as_str());
}
if let Some(var_220) = &input.notebook_params {
object.key("NotebookParams").string(var_220.as_str());
}
if let Some(var_221) = &input.execution_engine {
#[allow(unused_mut)]
let mut object_222 = object.key("ExecutionEngine").start_object();
crate::json_ser::serialize_structure_crate_model_execution_engine_config(
&mut object_222,
var_221,
)?;
object_222.finish();
}
if let Some(var_223) = &input.service_role {
object.key("ServiceRole").string(var_223.as_str());
}
if let Some(var_224) = &input.notebook_instance_security_group_id {
object
.key("NotebookInstanceSecurityGroupId")
.string(var_224.as_str());
}
if let Some(var_225) = &input.tags {
let mut array_226 = object.key("Tags").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_tag(&mut object_228, item_227)?;
object_228.finish();
}
}
array_226.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_stop_notebook_execution_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StopNotebookExecutionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_229) = &input.notebook_execution_id {
object.key("NotebookExecutionId").string(var_229.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_terminate_job_flows_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::TerminateJobFlowsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_230) = &input.job_flow_ids {
let mut array_231 = object.key("JobFlowIds").start_array();
for item_232 in var_230 {
{
array_231.value().string(item_232.as_str());
}
}
array_231.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_studio_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateStudioInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_233) = &input.studio_id {
object.key("StudioId").string(var_233.as_str());
}
if let Some(var_234) = &input.name {
object.key("Name").string(var_234.as_str());
}
if let Some(var_235) = &input.description {
object.key("Description").string(var_235.as_str());
}
if let Some(var_236) = &input.subnet_ids {
let mut array_237 = object.key("SubnetIds").start_array();
for item_238 in var_236 {
{
array_237.value().string(item_238.as_str());
}
}
array_237.finish();
}
if let Some(var_239) = &input.default_s3_location {
object.key("DefaultS3Location").string(var_239.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_studio_session_mapping_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateStudioSessionMappingInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_240) = &input.studio_id {
object.key("StudioId").string(var_240.as_str());
}
if let Some(var_241) = &input.identity_id {
object.key("IdentityId").string(var_241.as_str());
}
if let Some(var_242) = &input.identity_name {
object.key("IdentityName").string(var_242.as_str());
}
if let Some(var_243) = &input.identity_type {
object.key("IdentityType").string(var_243.as_str());
}
if let Some(var_244) = &input.session_policy_arn {
object.key("SessionPolicyArn").string(var_244.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_instance_fleet_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::InstanceFleetConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_245) = &input.name {
object.key("Name").string(var_245.as_str());
}
if let Some(var_246) = &input.instance_fleet_type {
object.key("InstanceFleetType").string(var_246.as_str());
}
if let Some(var_247) = &input.target_on_demand_capacity {
object.key("TargetOnDemandCapacity").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_247).into()),
);
}
if let Some(var_248) = &input.target_spot_capacity {
object.key("TargetSpotCapacity").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_248).into()),
);
}
if let Some(var_249) = &input.instance_type_configs {
let mut array_250 = object.key("InstanceTypeConfigs").start_array();
for item_251 in var_249 {
{
#[allow(unused_mut)]
let mut object_252 = array_250.value().start_object();
crate::json_ser::serialize_structure_crate_model_instance_type_config(
&mut object_252,
item_251,
)?;
object_252.finish();
}
}
array_250.finish();
}
if let Some(var_253) = &input.launch_specifications {
#[allow(unused_mut)]
let mut object_254 = object.key("LaunchSpecifications").start_object();
crate::json_ser::serialize_structure_crate_model_instance_fleet_provisioning_specifications(&mut object_254, var_253)?;
object_254.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_instance_group_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::InstanceGroupConfig,
) -> 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.market {
object.key("Market").string(var_256.as_str());
}
if let Some(var_257) = &input.instance_role {
object.key("InstanceRole").string(var_257.as_str());
}
if let Some(var_258) = &input.bid_price {
object.key("BidPrice").string(var_258.as_str());
}
if let Some(var_259) = &input.instance_type {
object.key("InstanceType").string(var_259.as_str());
}
if let Some(var_260) = &input.instance_count {
object.key("InstanceCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_260).into()),
);
}
if let Some(var_261) = &input.configurations {
let mut array_262 = object.key("Configurations").start_array();
for item_263 in var_261 {
{
#[allow(unused_mut)]
let mut object_264 = array_262.value().start_object();
crate::json_ser::serialize_structure_crate_model_configuration(
&mut object_264,
item_263,
)?;
object_264.finish();
}
}
array_262.finish();
}
if let Some(var_265) = &input.ebs_configuration {
#[allow(unused_mut)]
let mut object_266 = object.key("EbsConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_ebs_configuration(
&mut object_266,
var_265,
)?;
object_266.finish();
}
if let Some(var_267) = &input.auto_scaling_policy {
#[allow(unused_mut)]
let mut object_268 = object.key("AutoScalingPolicy").start_object();
crate::json_ser::serialize_structure_crate_model_auto_scaling_policy(
&mut object_268,
var_267,
)?;
object_268.finish();
}
if let Some(var_269) = &input.custom_ami_id {
object.key("CustomAmiId").string(var_269.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_step_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StepConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_270) = &input.name {
object.key("Name").string(var_270.as_str());
}
if let Some(var_271) = &input.action_on_failure {
object.key("ActionOnFailure").string(var_271.as_str());
}
if let Some(var_272) = &input.hadoop_jar_step {
#[allow(unused_mut)]
let mut object_273 = object.key("HadoopJarStep").start_object();
crate::json_ser::serialize_structure_crate_model_hadoop_jar_step_config(
&mut object_273,
var_272,
)?;
object_273.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_274) = &input.key {
object.key("Key").string(var_274.as_str());
}
if let Some(var_275) = &input.value {
object.key("Value").string(var_275.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_release_label_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ReleaseLabelFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_276) = &input.prefix {
object.key("Prefix").string(var_276.as_str());
}
if let Some(var_277) = &input.application {
object.key("Application").string(var_277.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_instance_fleet_modify_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::InstanceFleetModifyConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_278) = &input.instance_fleet_id {
object.key("InstanceFleetId").string(var_278.as_str());
}
if let Some(var_279) = &input.target_on_demand_capacity {
object.key("TargetOnDemandCapacity").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_279).into()),
);
}
if let Some(var_280) = &input.target_spot_capacity {
object.key("TargetSpotCapacity").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_280).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_instance_group_modify_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::InstanceGroupModifyConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_281) = &input.instance_group_id {
object.key("InstanceGroupId").string(var_281.as_str());
}
if let Some(var_282) = &input.instance_count {
object.key("InstanceCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_282).into()),
);
}
if let Some(var_283) = &input.ec2_instance_ids_to_terminate {
let mut array_284 = object.key("EC2InstanceIdsToTerminate").start_array();
for item_285 in var_283 {
{
array_284.value().string(item_285.as_str());
}
}
array_284.finish();
}
if let Some(var_286) = &input.shrink_policy {
#[allow(unused_mut)]
let mut object_287 = object.key("ShrinkPolicy").start_object();
crate::json_ser::serialize_structure_crate_model_shrink_policy(&mut object_287, var_286)?;
object_287.finish();
}
if let Some(var_288) = &input.reconfiguration_type {
object.key("ReconfigurationType").string(var_288.as_str());
}
if let Some(var_289) = &input.configurations {
let mut array_290 = object.key("Configurations").start_array();
for item_291 in var_289 {
{
#[allow(unused_mut)]
let mut object_292 = array_290.value().start_object();
crate::json_ser::serialize_structure_crate_model_configuration(
&mut object_292,
item_291,
)?;
object_292.finish();
}
}
array_290.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_auto_scaling_policy(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AutoScalingPolicy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_293) = &input.constraints {
#[allow(unused_mut)]
let mut object_294 = object.key("Constraints").start_object();
crate::json_ser::serialize_structure_crate_model_scaling_constraints(
&mut object_294,
var_293,
)?;
object_294.finish();
}
if let Some(var_295) = &input.rules {
let mut array_296 = object.key("Rules").start_array();
for item_297 in var_295 {
{
#[allow(unused_mut)]
let mut object_298 = array_296.value().start_object();
crate::json_ser::serialize_structure_crate_model_scaling_rule(
&mut object_298,
item_297,
)?;
object_298.finish();
}
}
array_296.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_auto_termination_policy(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AutoTerminationPolicy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.idle_timeout != 0 {
object.key("IdleTimeout").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.idle_timeout).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_block_public_access_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BlockPublicAccessConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
{
object
.key("BlockPublicSecurityGroupRules")
.boolean(input.block_public_security_group_rules);
}
if let Some(var_299) = &input.permitted_public_security_group_rule_ranges {
let mut array_300 = object
.key("PermittedPublicSecurityGroupRuleRanges")
.start_array();
for item_301 in var_299 {
{
#[allow(unused_mut)]
let mut object_302 = array_300.value().start_object();
crate::json_ser::serialize_structure_crate_model_port_range(
&mut object_302,
item_301,
)?;
object_302.finish();
}
}
array_300.finish();
}
if let Some(var_303) = &input.classification {
object.key("Classification").string(var_303.as_str());
}
if let Some(var_304) = &input.configurations {
let mut array_305 = object.key("Configurations").start_array();
for item_306 in var_304 {
{
#[allow(unused_mut)]
let mut object_307 = array_305.value().start_object();
crate::json_ser::serialize_structure_crate_model_configuration(
&mut object_307,
item_306,
)?;
object_307.finish();
}
}
array_305.finish();
}
if let Some(var_308) = &input.properties {
#[allow(unused_mut)]
let mut object_309 = object.key("Properties").start_object();
for (key_310, value_311) in var_308 {
{
object_309.key(key_310.as_str()).string(value_311.as_str());
}
}
object_309.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_managed_scaling_policy(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ManagedScalingPolicy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_312) = &input.compute_limits {
#[allow(unused_mut)]
let mut object_313 = object.key("ComputeLimits").start_object();
crate::json_ser::serialize_structure_crate_model_compute_limits(&mut object_313, var_312)?;
object_313.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_job_flow_instances_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::JobFlowInstancesConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_314) = &input.master_instance_type {
object.key("MasterInstanceType").string(var_314.as_str());
}
if let Some(var_315) = &input.slave_instance_type {
object.key("SlaveInstanceType").string(var_315.as_str());
}
if let Some(var_316) = &input.instance_count {
object.key("InstanceCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_316).into()),
);
}
if let Some(var_317) = &input.instance_groups {
let mut array_318 = object.key("InstanceGroups").start_array();
for item_319 in var_317 {
{
#[allow(unused_mut)]
let mut object_320 = array_318.value().start_object();
crate::json_ser::serialize_structure_crate_model_instance_group_config(
&mut object_320,
item_319,
)?;
object_320.finish();
}
}
array_318.finish();
}
if let Some(var_321) = &input.instance_fleets {
let mut array_322 = object.key("InstanceFleets").start_array();
for item_323 in var_321 {
{
#[allow(unused_mut)]
let mut object_324 = array_322.value().start_object();
crate::json_ser::serialize_structure_crate_model_instance_fleet_config(
&mut object_324,
item_323,
)?;
object_324.finish();
}
}
array_322.finish();
}
if let Some(var_325) = &input.ec2_key_name {
object.key("Ec2KeyName").string(var_325.as_str());
}
if let Some(var_326) = &input.placement {
#[allow(unused_mut)]
let mut object_327 = object.key("Placement").start_object();
crate::json_ser::serialize_structure_crate_model_placement_type(&mut object_327, var_326)?;
object_327.finish();
}
if input.keep_job_flow_alive_when_no_steps {
object
.key("KeepJobFlowAliveWhenNoSteps")
.boolean(input.keep_job_flow_alive_when_no_steps);
}
if input.termination_protected {
object
.key("TerminationProtected")
.boolean(input.termination_protected);
}
if let Some(var_328) = &input.hadoop_version {
object.key("HadoopVersion").string(var_328.as_str());
}
if let Some(var_329) = &input.ec2_subnet_id {
object.key("Ec2SubnetId").string(var_329.as_str());
}
if let Some(var_330) = &input.ec2_subnet_ids {
let mut array_331 = object.key("Ec2SubnetIds").start_array();
for item_332 in var_330 {
{
array_331.value().string(item_332.as_str());
}
}
array_331.finish();
}
if let Some(var_333) = &input.emr_managed_master_security_group {
object
.key("EmrManagedMasterSecurityGroup")
.string(var_333.as_str());
}
if let Some(var_334) = &input.emr_managed_slave_security_group {
object
.key("EmrManagedSlaveSecurityGroup")
.string(var_334.as_str());
}
if let Some(var_335) = &input.service_access_security_group {
object
.key("ServiceAccessSecurityGroup")
.string(var_335.as_str());
}
if let Some(var_336) = &input.additional_master_security_groups {
let mut array_337 = object.key("AdditionalMasterSecurityGroups").start_array();
for item_338 in var_336 {
{
array_337.value().string(item_338.as_str());
}
}
array_337.finish();
}
if let Some(var_339) = &input.additional_slave_security_groups {
let mut array_340 = object.key("AdditionalSlaveSecurityGroups").start_array();
for item_341 in var_339 {
{
array_340.value().string(item_341.as_str());
}
}
array_340.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_bootstrap_action_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BootstrapActionConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_342) = &input.name {
object.key("Name").string(var_342.as_str());
}
if let Some(var_343) = &input.script_bootstrap_action {
#[allow(unused_mut)]
let mut object_344 = object.key("ScriptBootstrapAction").start_object();
crate::json_ser::serialize_structure_crate_model_script_bootstrap_action_config(
&mut object_344,
var_343,
)?;
object_344.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_supported_product_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SupportedProductConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_345) = &input.name {
object.key("Name").string(var_345.as_str());
}
if let Some(var_346) = &input.args {
let mut array_347 = object.key("Args").start_array();
for item_348 in var_346 {
{
array_347.value().string(item_348.as_str());
}
}
array_347.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_application(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Application,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_349) = &input.name {
object.key("Name").string(var_349.as_str());
}
if let Some(var_350) = &input.version {
object.key("Version").string(var_350.as_str());
}
if let Some(var_351) = &input.args {
let mut array_352 = object.key("Args").start_array();
for item_353 in var_351 {
{
array_352.value().string(item_353.as_str());
}
}
array_352.finish();
}
if let Some(var_354) = &input.additional_info {
#[allow(unused_mut)]
let mut object_355 = object.key("AdditionalInfo").start_object();
for (key_356, value_357) in var_354 {
{
object_355.key(key_356.as_str()).string(value_357.as_str());
}
}
object_355.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Configuration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_358) = &input.classification {
object.key("Classification").string(var_358.as_str());
}
if let Some(var_359) = &input.configurations {
let mut array_360 = object.key("Configurations").start_array();
for item_361 in var_359 {
{
#[allow(unused_mut)]
let mut object_362 = array_360.value().start_object();
crate::json_ser::serialize_structure_crate_model_configuration(
&mut object_362,
item_361,
)?;
object_362.finish();
}
}
array_360.finish();
}
if let Some(var_363) = &input.properties {
#[allow(unused_mut)]
let mut object_364 = object.key("Properties").start_object();
for (key_365, value_366) in var_363 {
{
object_364.key(key_365.as_str()).string(value_366.as_str());
}
}
object_364.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_kerberos_attributes(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::KerberosAttributes,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_367) = &input.realm {
object.key("Realm").string(var_367.as_str());
}
if let Some(var_368) = &input.kdc_admin_password {
object.key("KdcAdminPassword").string(var_368.as_str());
}
if let Some(var_369) = &input.cross_realm_trust_principal_password {
object
.key("CrossRealmTrustPrincipalPassword")
.string(var_369.as_str());
}
if let Some(var_370) = &input.ad_domain_join_user {
object.key("ADDomainJoinUser").string(var_370.as_str());
}
if let Some(var_371) = &input.ad_domain_join_password {
object.key("ADDomainJoinPassword").string(var_371.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_placement_group_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PlacementGroupConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_372) = &input.instance_role {
object.key("InstanceRole").string(var_372.as_str());
}
if let Some(var_373) = &input.placement_strategy {
object.key("PlacementStrategy").string(var_373.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_execution_engine_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ExecutionEngineConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_374) = &input.id {
object.key("Id").string(var_374.as_str());
}
if let Some(var_375) = &input.r#type {
object.key("Type").string(var_375.as_str());
}
if let Some(var_376) = &input.master_instance_security_group_id {
object
.key("MasterInstanceSecurityGroupId")
.string(var_376.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_instance_type_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::InstanceTypeConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_377) = &input.instance_type {
object.key("InstanceType").string(var_377.as_str());
}
if let Some(var_378) = &input.weighted_capacity {
object.key("WeightedCapacity").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_378).into()),
);
}
if let Some(var_379) = &input.bid_price {
object.key("BidPrice").string(var_379.as_str());
}
if let Some(var_380) = &input.bid_price_as_percentage_of_on_demand_price {
object.key("BidPriceAsPercentageOfOnDemandPrice").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_380).into()),
);
}
if let Some(var_381) = &input.ebs_configuration {
#[allow(unused_mut)]
let mut object_382 = object.key("EbsConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_ebs_configuration(
&mut object_382,
var_381,
)?;
object_382.finish();
}
if let Some(var_383) = &input.configurations {
let mut array_384 = object.key("Configurations").start_array();
for item_385 in var_383 {
{
#[allow(unused_mut)]
let mut object_386 = array_384.value().start_object();
crate::json_ser::serialize_structure_crate_model_configuration(
&mut object_386,
item_385,
)?;
object_386.finish();
}
}
array_384.finish();
}
if let Some(var_387) = &input.custom_ami_id {
object.key("CustomAmiId").string(var_387.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_instance_fleet_provisioning_specifications(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::InstanceFleetProvisioningSpecifications,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_388) = &input.spot_specification {
#[allow(unused_mut)]
let mut object_389 = object.key("SpotSpecification").start_object();
crate::json_ser::serialize_structure_crate_model_spot_provisioning_specification(
&mut object_389,
var_388,
)?;
object_389.finish();
}
if let Some(var_390) = &input.on_demand_specification {
#[allow(unused_mut)]
let mut object_391 = object.key("OnDemandSpecification").start_object();
crate::json_ser::serialize_structure_crate_model_on_demand_provisioning_specification(
&mut object_391,
var_390,
)?;
object_391.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_ebs_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EbsConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_392) = &input.ebs_block_device_configs {
let mut array_393 = object.key("EbsBlockDeviceConfigs").start_array();
for item_394 in var_392 {
{
#[allow(unused_mut)]
let mut object_395 = array_393.value().start_object();
crate::json_ser::serialize_structure_crate_model_ebs_block_device_config(
&mut object_395,
item_394,
)?;
object_395.finish();
}
}
array_393.finish();
}
if let Some(var_396) = &input.ebs_optimized {
object.key("EbsOptimized").boolean(*var_396);
}
Ok(())
}
pub fn serialize_structure_crate_model_hadoop_jar_step_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::HadoopJarStepConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_397) = &input.properties {
let mut array_398 = object.key("Properties").start_array();
for item_399 in var_397 {
{
#[allow(unused_mut)]
let mut object_400 = array_398.value().start_object();
crate::json_ser::serialize_structure_crate_model_key_value(
&mut object_400,
item_399,
)?;
object_400.finish();
}
}
array_398.finish();
}
if let Some(var_401) = &input.jar {
object.key("Jar").string(var_401.as_str());
}
if let Some(var_402) = &input.main_class {
object.key("MainClass").string(var_402.as_str());
}
if let Some(var_403) = &input.args {
let mut array_404 = object.key("Args").start_array();
for item_405 in var_403 {
{
array_404.value().string(item_405.as_str());
}
}
array_404.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_shrink_policy(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ShrinkPolicy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_406) = &input.decommission_timeout {
object.key("DecommissionTimeout").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_406).into()),
);
}
if let Some(var_407) = &input.instance_resize_policy {
#[allow(unused_mut)]
let mut object_408 = object.key("InstanceResizePolicy").start_object();
crate::json_ser::serialize_structure_crate_model_instance_resize_policy(
&mut object_408,
var_407,
)?;
object_408.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_scaling_constraints(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ScalingConstraints,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_409) = &input.min_capacity {
object.key("MinCapacity").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_409).into()),
);
}
if let Some(var_410) = &input.max_capacity {
object.key("MaxCapacity").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_410).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_scaling_rule(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ScalingRule,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_411) = &input.name {
object.key("Name").string(var_411.as_str());
}
if let Some(var_412) = &input.description {
object.key("Description").string(var_412.as_str());
}
if let Some(var_413) = &input.action {
#[allow(unused_mut)]
let mut object_414 = object.key("Action").start_object();
crate::json_ser::serialize_structure_crate_model_scaling_action(&mut object_414, var_413)?;
object_414.finish();
}
if let Some(var_415) = &input.trigger {
#[allow(unused_mut)]
let mut object_416 = object.key("Trigger").start_object();
crate::json_ser::serialize_structure_crate_model_scaling_trigger(&mut object_416, var_415)?;
object_416.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_port_range(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PortRange,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_417) = &input.min_range {
object.key("MinRange").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_417).into()),
);
}
if let Some(var_418) = &input.max_range {
object.key("MaxRange").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_418).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_compute_limits(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ComputeLimits,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_419) = &input.unit_type {
object.key("UnitType").string(var_419.as_str());
}
if let Some(var_420) = &input.minimum_capacity_units {
object.key("MinimumCapacityUnits").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_420).into()),
);
}
if let Some(var_421) = &input.maximum_capacity_units {
object.key("MaximumCapacityUnits").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_421).into()),
);
}
if let Some(var_422) = &input.maximum_on_demand_capacity_units {
object.key("MaximumOnDemandCapacityUnits").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_422).into()),
);
}
if let Some(var_423) = &input.maximum_core_capacity_units {
object.key("MaximumCoreCapacityUnits").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_423).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_placement_type(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PlacementType,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_424) = &input.availability_zone {
object.key("AvailabilityZone").string(var_424.as_str());
}
if let Some(var_425) = &input.availability_zones {
let mut array_426 = object.key("AvailabilityZones").start_array();
for item_427 in var_425 {
{
array_426.value().string(item_427.as_str());
}
}
array_426.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_script_bootstrap_action_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ScriptBootstrapActionConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_428) = &input.path {
object.key("Path").string(var_428.as_str());
}
if let Some(var_429) = &input.args {
let mut array_430 = object.key("Args").start_array();
for item_431 in var_429 {
{
array_430.value().string(item_431.as_str());
}
}
array_430.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_spot_provisioning_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SpotProvisioningSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_432) = &input.timeout_duration_minutes {
object.key("TimeoutDurationMinutes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_432).into()),
);
}
if let Some(var_433) = &input.timeout_action {
object.key("TimeoutAction").string(var_433.as_str());
}
if let Some(var_434) = &input.block_duration_minutes {
object.key("BlockDurationMinutes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_434).into()),
);
}
if let Some(var_435) = &input.allocation_strategy {
object.key("AllocationStrategy").string(var_435.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_on_demand_provisioning_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OnDemandProvisioningSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_436) = &input.allocation_strategy {
object.key("AllocationStrategy").string(var_436.as_str());
}
if let Some(var_437) = &input.capacity_reservation_options {
#[allow(unused_mut)]
let mut object_438 = object.key("CapacityReservationOptions").start_object();
crate::json_ser::serialize_structure_crate_model_on_demand_capacity_reservation_options(
&mut object_438,
var_437,
)?;
object_438.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_ebs_block_device_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EbsBlockDeviceConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_439) = &input.volume_specification {
#[allow(unused_mut)]
let mut object_440 = object.key("VolumeSpecification").start_object();
crate::json_ser::serialize_structure_crate_model_volume_specification(
&mut object_440,
var_439,
)?;
object_440.finish();
}
if let Some(var_441) = &input.volumes_per_instance {
object.key("VolumesPerInstance").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_441).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_key_value(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::KeyValue,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_442) = &input.key {
object.key("Key").string(var_442.as_str());
}
if let Some(var_443) = &input.value {
object.key("Value").string(var_443.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_instance_resize_policy(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::InstanceResizePolicy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_444) = &input.instances_to_terminate {
let mut array_445 = object.key("InstancesToTerminate").start_array();
for item_446 in var_444 {
{
array_445.value().string(item_446.as_str());
}
}
array_445.finish();
}
if let Some(var_447) = &input.instances_to_protect {
let mut array_448 = object.key("InstancesToProtect").start_array();
for item_449 in var_447 {
{
array_448.value().string(item_449.as_str());
}
}
array_448.finish();
}
if let Some(var_450) = &input.instance_termination_timeout {
object.key("InstanceTerminationTimeout").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_450).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_scaling_action(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ScalingAction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_451) = &input.market {
object.key("Market").string(var_451.as_str());
}
if let Some(var_452) = &input.simple_scaling_policy_configuration {
#[allow(unused_mut)]
let mut object_453 = object
.key("SimpleScalingPolicyConfiguration")
.start_object();
crate::json_ser::serialize_structure_crate_model_simple_scaling_policy_configuration(
&mut object_453,
var_452,
)?;
object_453.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_scaling_trigger(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ScalingTrigger,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_454) = &input.cloud_watch_alarm_definition {
#[allow(unused_mut)]
let mut object_455 = object.key("CloudWatchAlarmDefinition").start_object();
crate::json_ser::serialize_structure_crate_model_cloud_watch_alarm_definition(
&mut object_455,
var_454,
)?;
object_455.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_on_demand_capacity_reservation_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OnDemandCapacityReservationOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_456) = &input.usage_strategy {
object.key("UsageStrategy").string(var_456.as_str());
}
if let Some(var_457) = &input.capacity_reservation_preference {
object
.key("CapacityReservationPreference")
.string(var_457.as_str());
}
if let Some(var_458) = &input.capacity_reservation_resource_group_arn {
object
.key("CapacityReservationResourceGroupArn")
.string(var_458.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_volume_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::VolumeSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_459) = &input.volume_type {
object.key("VolumeType").string(var_459.as_str());
}
if let Some(var_460) = &input.iops {
object.key("Iops").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_460).into()),
);
}
if let Some(var_461) = &input.size_in_gb {
object.key("SizeInGB").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_461).into()),
);
}
if let Some(var_462) = &input.throughput {
object.key("Throughput").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_462).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_simple_scaling_policy_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SimpleScalingPolicyConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_463) = &input.adjustment_type {
object.key("AdjustmentType").string(var_463.as_str());
}
if let Some(var_464) = &input.scaling_adjustment {
object.key("ScalingAdjustment").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_464).into()),
);
}
if let Some(var_465) = &input.cool_down {
object.key("CoolDown").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_465).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_cloud_watch_alarm_definition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CloudWatchAlarmDefinition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_466) = &input.comparison_operator {
object.key("ComparisonOperator").string(var_466.as_str());
}
if let Some(var_467) = &input.evaluation_periods {
object.key("EvaluationPeriods").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_467).into()),
);
}
if let Some(var_468) = &input.metric_name {
object.key("MetricName").string(var_468.as_str());
}
if let Some(var_469) = &input.namespace {
object.key("Namespace").string(var_469.as_str());
}
if let Some(var_470) = &input.period {
object.key("Period").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_470).into()),
);
}
if let Some(var_471) = &input.statistic {
object.key("Statistic").string(var_471.as_str());
}
if let Some(var_472) = &input.threshold {
object.key("Threshold").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_472).into()),
);
}
if let Some(var_473) = &input.unit {
object.key("Unit").string(var_473.as_str());
}
if let Some(var_474) = &input.dimensions {
let mut array_475 = object.key("Dimensions").start_array();
for item_476 in var_474 {
{
#[allow(unused_mut)]
let mut object_477 = array_475.value().start_object();
crate::json_ser::serialize_structure_crate_model_metric_dimension(
&mut object_477,
item_476,
)?;
object_477.finish();
}
}
array_475.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_metric_dimension(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MetricDimension,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_478) = &input.key {
object.key("Key").string(var_478.as_str());
}
if let Some(var_479) = &input.value {
object.key("Value").string(var_479.as_str());
}
Ok(())
}