pub fn serialize_structure_crate_input_create_job_template_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateJobTemplateInput,
) -> 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.job_template_data {
#[allow(unused_mut)]
let mut object_3 = object.key("jobTemplateData").start_object();
crate::json_ser::serialize_structure_crate_model_job_template_data(&mut object_3, var_2)?;
object_3.finish();
}
if let Some(var_4) = &input.kms_key_arn {
object.key("kmsKeyArn").string(var_4.as_str());
}
if let Some(var_5) = &input.name {
object.key("name").string(var_5.as_str());
}
if let Some(var_6) = &input.tags {
#[allow(unused_mut)]
let mut object_7 = object.key("tags").start_object();
for (key_8, value_9) in var_6 {
{
object_7.key(key_8.as_str()).string(value_9.as_str());
}
}
object_7.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_managed_endpoint_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateManagedEndpointInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_10) = &input.certificate_arn {
object.key("certificateArn").string(var_10.as_str());
}
if let Some(var_11) = &input.client_token {
object.key("clientToken").string(var_11.as_str());
}
if let Some(var_12) = &input.configuration_overrides {
#[allow(unused_mut)]
let mut object_13 = object.key("configurationOverrides").start_object();
crate::json_ser::serialize_structure_crate_model_configuration_overrides(
&mut object_13,
var_12,
)?;
object_13.finish();
}
if let Some(var_14) = &input.execution_role_arn {
object.key("executionRoleArn").string(var_14.as_str());
}
if let Some(var_15) = &input.name {
object.key("name").string(var_15.as_str());
}
if let Some(var_16) = &input.release_label {
object.key("releaseLabel").string(var_16.as_str());
}
if let Some(var_17) = &input.tags {
#[allow(unused_mut)]
let mut object_18 = object.key("tags").start_object();
for (key_19, value_20) in var_17 {
{
object_18.key(key_19.as_str()).string(value_20.as_str());
}
}
object_18.finish();
}
if let Some(var_21) = &input.r#type {
object.key("type").string(var_21.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_virtual_cluster_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateVirtualClusterInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_22) = &input.client_token {
object.key("clientToken").string(var_22.as_str());
}
if let Some(var_23) = &input.container_provider {
#[allow(unused_mut)]
let mut object_24 = object.key("containerProvider").start_object();
crate::json_ser::serialize_structure_crate_model_container_provider(
&mut object_24,
var_23,
)?;
object_24.finish();
}
if let Some(var_25) = &input.name {
object.key("name").string(var_25.as_str());
}
if let Some(var_26) = &input.tags {
#[allow(unused_mut)]
let mut object_27 = object.key("tags").start_object();
for (key_28, value_29) in var_26 {
{
object_27.key(key_28.as_str()).string(value_29.as_str());
}
}
object_27.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_start_job_run_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartJobRunInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_30) = &input.client_token {
object.key("clientToken").string(var_30.as_str());
}
if let Some(var_31) = &input.configuration_overrides {
#[allow(unused_mut)]
let mut object_32 = object.key("configurationOverrides").start_object();
crate::json_ser::serialize_structure_crate_model_configuration_overrides(
&mut object_32,
var_31,
)?;
object_32.finish();
}
if let Some(var_33) = &input.execution_role_arn {
object.key("executionRoleArn").string(var_33.as_str());
}
if let Some(var_34) = &input.job_driver {
#[allow(unused_mut)]
let mut object_35 = object.key("jobDriver").start_object();
crate::json_ser::serialize_structure_crate_model_job_driver(&mut object_35, var_34)?;
object_35.finish();
}
if let Some(var_36) = &input.job_template_id {
object.key("jobTemplateId").string(var_36.as_str());
}
if let Some(var_37) = &input.job_template_parameters {
#[allow(unused_mut)]
let mut object_38 = object.key("jobTemplateParameters").start_object();
for (key_39, value_40) in var_37 {
{
object_38.key(key_39.as_str()).string(value_40.as_str());
}
}
object_38.finish();
}
if let Some(var_41) = &input.name {
object.key("name").string(var_41.as_str());
}
if let Some(var_42) = &input.release_label {
object.key("releaseLabel").string(var_42.as_str());
}
if let Some(var_43) = &input.tags {
#[allow(unused_mut)]
let mut object_44 = object.key("tags").start_object();
for (key_45, value_46) in var_43 {
{
object_44.key(key_45.as_str()).string(value_46.as_str());
}
}
object_44.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_47) = &input.tags {
#[allow(unused_mut)]
let mut object_48 = object.key("tags").start_object();
for (key_49, value_50) in var_47 {
{
object_48.key(key_49.as_str()).string(value_50.as_str());
}
}
object_48.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_job_template_data(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::JobTemplateData,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_51) = &input.execution_role_arn {
object.key("executionRoleArn").string(var_51.as_str());
}
if let Some(var_52) = &input.release_label {
object.key("releaseLabel").string(var_52.as_str());
}
if let Some(var_53) = &input.configuration_overrides {
#[allow(unused_mut)]
let mut object_54 = object.key("configurationOverrides").start_object();
crate::json_ser::serialize_structure_crate_model_parametric_configuration_overrides(
&mut object_54,
var_53,
)?;
object_54.finish();
}
if let Some(var_55) = &input.job_driver {
#[allow(unused_mut)]
let mut object_56 = object.key("jobDriver").start_object();
crate::json_ser::serialize_structure_crate_model_job_driver(&mut object_56, var_55)?;
object_56.finish();
}
if let Some(var_57) = &input.parameter_configuration {
#[allow(unused_mut)]
let mut object_58 = object.key("parameterConfiguration").start_object();
for (key_59, value_60) in var_57 {
{
#[allow(unused_mut)]
let mut object_61 = object_58.key(key_59.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_template_parameter_configuration(
&mut object_61,
value_60,
)?;
object_61.finish();
}
}
object_58.finish();
}
if let Some(var_62) = &input.job_tags {
#[allow(unused_mut)]
let mut object_63 = object.key("jobTags").start_object();
for (key_64, value_65) in var_62 {
{
object_63.key(key_64.as_str()).string(value_65.as_str());
}
}
object_63.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_configuration_overrides(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ConfigurationOverrides,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_66) = &input.application_configuration {
let mut array_67 = object.key("applicationConfiguration").start_array();
for item_68 in var_66 {
{
#[allow(unused_mut)]
let mut object_69 = array_67.value().start_object();
crate::json_ser::serialize_structure_crate_model_configuration(
&mut object_69,
item_68,
)?;
object_69.finish();
}
}
array_67.finish();
}
if let Some(var_70) = &input.monitoring_configuration {
#[allow(unused_mut)]
let mut object_71 = object.key("monitoringConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_monitoring_configuration(
&mut object_71,
var_70,
)?;
object_71.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_container_provider(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ContainerProvider,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_72) = &input.r#type {
object.key("type").string(var_72.as_str());
}
if let Some(var_73) = &input.id {
object.key("id").string(var_73.as_str());
}
if let Some(var_74) = &input.info {
#[allow(unused_mut)]
let mut object_75 = object.key("info").start_object();
crate::json_ser::serialize_union_crate_model_container_info(&mut object_75, var_74)?;
object_75.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_job_driver(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::JobDriver,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_76) = &input.spark_submit_job_driver {
#[allow(unused_mut)]
let mut object_77 = object.key("sparkSubmitJobDriver").start_object();
crate::json_ser::serialize_structure_crate_model_spark_submit_job_driver(
&mut object_77,
var_76,
)?;
object_77.finish();
}
if let Some(var_78) = &input.spark_sql_job_driver {
#[allow(unused_mut)]
let mut object_79 = object.key("sparkSqlJobDriver").start_object();
crate::json_ser::serialize_structure_crate_model_spark_sql_job_driver(
&mut object_79,
var_78,
)?;
object_79.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_parametric_configuration_overrides(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ParametricConfigurationOverrides,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_80) = &input.application_configuration {
let mut array_81 = object.key("applicationConfiguration").start_array();
for item_82 in var_80 {
{
#[allow(unused_mut)]
let mut object_83 = array_81.value().start_object();
crate::json_ser::serialize_structure_crate_model_configuration(
&mut object_83,
item_82,
)?;
object_83.finish();
}
}
array_81.finish();
}
if let Some(var_84) = &input.monitoring_configuration {
#[allow(unused_mut)]
let mut object_85 = object.key("monitoringConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_parametric_monitoring_configuration(
&mut object_85,
var_84,
)?;
object_85.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_template_parameter_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TemplateParameterConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_86) = &input.r#type {
object.key("type").string(var_86.as_str());
}
if let Some(var_87) = &input.default_value {
object.key("defaultValue").string(var_87.as_str());
}
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_88) = &input.classification {
object.key("classification").string(var_88.as_str());
}
if let Some(var_89) = &input.properties {
#[allow(unused_mut)]
let mut object_90 = object.key("properties").start_object();
for (key_91, value_92) in var_89 {
{
object_90.key(key_91.as_str()).string(value_92.as_str());
}
}
object_90.finish();
}
if let Some(var_93) = &input.configurations {
let mut array_94 = object.key("configurations").start_array();
for item_95 in var_93 {
{
#[allow(unused_mut)]
let mut object_96 = array_94.value().start_object();
crate::json_ser::serialize_structure_crate_model_configuration(
&mut object_96,
item_95,
)?;
object_96.finish();
}
}
array_94.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_monitoring_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MonitoringConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_97) = &input.persistent_app_ui {
object.key("persistentAppUI").string(var_97.as_str());
}
if let Some(var_98) = &input.cloud_watch_monitoring_configuration {
#[allow(unused_mut)]
let mut object_99 = object
.key("cloudWatchMonitoringConfiguration")
.start_object();
crate::json_ser::serialize_structure_crate_model_cloud_watch_monitoring_configuration(
&mut object_99,
var_98,
)?;
object_99.finish();
}
if let Some(var_100) = &input.s3_monitoring_configuration {
#[allow(unused_mut)]
let mut object_101 = object.key("s3MonitoringConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_s3_monitoring_configuration(
&mut object_101,
var_100,
)?;
object_101.finish();
}
Ok(())
}
pub fn serialize_union_crate_model_container_info(
object_75: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ContainerInfo,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
match input {
crate::model::ContainerInfo::EksInfo(inner) => {
#[allow(unused_mut)]
let mut object_102 = object_75.key("eksInfo").start_object();
crate::json_ser::serialize_structure_crate_model_eks_info(&mut object_102, inner)?;
object_102.finish();
}
crate::model::ContainerInfo::Unknown => {
return Err(
aws_smithy_http::operation::error::SerializationError::unknown_variant(
"ContainerInfo",
),
)
}
}
Ok(())
}
pub fn serialize_structure_crate_model_spark_submit_job_driver(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SparkSubmitJobDriver,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_103) = &input.entry_point {
object.key("entryPoint").string(var_103.as_str());
}
if let Some(var_104) = &input.entry_point_arguments {
let mut array_105 = object.key("entryPointArguments").start_array();
for item_106 in var_104 {
{
array_105.value().string(item_106.as_str());
}
}
array_105.finish();
}
if let Some(var_107) = &input.spark_submit_parameters {
object.key("sparkSubmitParameters").string(var_107.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_spark_sql_job_driver(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SparkSqlJobDriver,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_108) = &input.entry_point {
object.key("entryPoint").string(var_108.as_str());
}
if let Some(var_109) = &input.spark_sql_parameters {
object.key("sparkSqlParameters").string(var_109.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_parametric_monitoring_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ParametricMonitoringConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_110) = &input.persistent_app_ui {
object.key("persistentAppUI").string(var_110.as_str());
}
if let Some(var_111) = &input.cloud_watch_monitoring_configuration {
#[allow(unused_mut)]
let mut object_112 = object
.key("cloudWatchMonitoringConfiguration")
.start_object();
crate::json_ser::serialize_structure_crate_model_parametric_cloud_watch_monitoring_configuration(&mut object_112, var_111)?;
object_112.finish();
}
if let Some(var_113) = &input.s3_monitoring_configuration {
#[allow(unused_mut)]
let mut object_114 = object.key("s3MonitoringConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_parametric_s3_monitoring_configuration(
&mut object_114,
var_113,
)?;
object_114.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_cloud_watch_monitoring_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CloudWatchMonitoringConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_115) = &input.log_group_name {
object.key("logGroupName").string(var_115.as_str());
}
if let Some(var_116) = &input.log_stream_name_prefix {
object.key("logStreamNamePrefix").string(var_116.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_s3_monitoring_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::S3MonitoringConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_117) = &input.log_uri {
object.key("logUri").string(var_117.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_eks_info(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EksInfo,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_118) = &input.namespace {
object.key("namespace").string(var_118.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_parametric_cloud_watch_monitoring_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ParametricCloudWatchMonitoringConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_119) = &input.log_group_name {
object.key("logGroupName").string(var_119.as_str());
}
if let Some(var_120) = &input.log_stream_name_prefix {
object.key("logStreamNamePrefix").string(var_120.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_parametric_s3_monitoring_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ParametricS3MonitoringConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_121) = &input.log_uri {
object.key("logUri").string(var_121.as_str());
}
Ok(())
}