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_1) = &input.tags {
let mut array_2 = object.key("Tags").start_array();
for item_3 in var_1 {
{
#[allow(unused_mut)]
let mut object_4 = array_2.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_4, item_3)?;
object_4.finish();
}
}
array_2.finish();
}
if let Some(var_5) = &input.resource_id {
object.key("ResourceId").string(var_5.as_str());
}
if let Some(var_6) = &input.resource_type {
object.key("ResourceType").string(var_6.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_batch_prediction_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateBatchPredictionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_7) = &input.batch_prediction_id {
object.key("BatchPredictionId").string(var_7.as_str());
}
if let Some(var_8) = &input.batch_prediction_name {
object.key("BatchPredictionName").string(var_8.as_str());
}
if let Some(var_9) = &input.ml_model_id {
object.key("MLModelId").string(var_9.as_str());
}
if let Some(var_10) = &input.batch_prediction_data_source_id {
object
.key("BatchPredictionDataSourceId")
.string(var_10.as_str());
}
if let Some(var_11) = &input.output_uri {
object.key("OutputUri").string(var_11.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_data_source_from_rds_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateDataSourceFromRdsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_12) = &input.data_source_id {
object.key("DataSourceId").string(var_12.as_str());
}
if let Some(var_13) = &input.data_source_name {
object.key("DataSourceName").string(var_13.as_str());
}
if let Some(var_14) = &input.rds_data {
#[allow(unused_mut)]
let mut object_15 = object.key("RDSData").start_object();
crate::json_ser::serialize_structure_crate_model_rds_data_spec(&mut object_15, var_14)?;
object_15.finish();
}
if let Some(var_16) = &input.role_arn {
object.key("RoleARN").string(var_16.as_str());
}
if input.compute_statistics {
object
.key("ComputeStatistics")
.boolean(input.compute_statistics);
}
Ok(())
}
pub fn serialize_structure_crate_input_create_data_source_from_redshift_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateDataSourceFromRedshiftInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_17) = &input.data_source_id {
object.key("DataSourceId").string(var_17.as_str());
}
if let Some(var_18) = &input.data_source_name {
object.key("DataSourceName").string(var_18.as_str());
}
if let Some(var_19) = &input.data_spec {
#[allow(unused_mut)]
let mut object_20 = object.key("DataSpec").start_object();
crate::json_ser::serialize_structure_crate_model_redshift_data_spec(
&mut object_20,
var_19,
)?;
object_20.finish();
}
if let Some(var_21) = &input.role_arn {
object.key("RoleARN").string(var_21.as_str());
}
if input.compute_statistics {
object
.key("ComputeStatistics")
.boolean(input.compute_statistics);
}
Ok(())
}
pub fn serialize_structure_crate_input_create_data_source_from_s3_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateDataSourceFromS3Input,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_22) = &input.data_source_id {
object.key("DataSourceId").string(var_22.as_str());
}
if let Some(var_23) = &input.data_source_name {
object.key("DataSourceName").string(var_23.as_str());
}
if let Some(var_24) = &input.data_spec {
#[allow(unused_mut)]
let mut object_25 = object.key("DataSpec").start_object();
crate::json_ser::serialize_structure_crate_model_s3_data_spec(&mut object_25, var_24)?;
object_25.finish();
}
if input.compute_statistics {
object
.key("ComputeStatistics")
.boolean(input.compute_statistics);
}
Ok(())
}
pub fn serialize_structure_crate_input_create_evaluation_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateEvaluationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_26) = &input.evaluation_id {
object.key("EvaluationId").string(var_26.as_str());
}
if let Some(var_27) = &input.evaluation_name {
object.key("EvaluationName").string(var_27.as_str());
}
if let Some(var_28) = &input.ml_model_id {
object.key("MLModelId").string(var_28.as_str());
}
if let Some(var_29) = &input.evaluation_data_source_id {
object.key("EvaluationDataSourceId").string(var_29.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_ml_model_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateMlModelInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_30) = &input.ml_model_id {
object.key("MLModelId").string(var_30.as_str());
}
if let Some(var_31) = &input.ml_model_name {
object.key("MLModelName").string(var_31.as_str());
}
if let Some(var_32) = &input.ml_model_type {
object.key("MLModelType").string(var_32.as_str());
}
if let Some(var_33) = &input.parameters {
#[allow(unused_mut)]
let mut object_34 = object.key("Parameters").start_object();
for (key_35, value_36) in var_33 {
{
object_34.key(key_35.as_str()).string(value_36.as_str());
}
}
object_34.finish();
}
if let Some(var_37) = &input.training_data_source_id {
object.key("TrainingDataSourceId").string(var_37.as_str());
}
if let Some(var_38) = &input.recipe {
object.key("Recipe").string(var_38.as_str());
}
if let Some(var_39) = &input.recipe_uri {
object.key("RecipeUri").string(var_39.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_realtime_endpoint_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateRealtimeEndpointInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_40) = &input.ml_model_id {
object.key("MLModelId").string(var_40.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_batch_prediction_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteBatchPredictionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_41) = &input.batch_prediction_id {
object.key("BatchPredictionId").string(var_41.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_data_source_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteDataSourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_42) = &input.data_source_id {
object.key("DataSourceId").string(var_42.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_evaluation_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteEvaluationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_43) = &input.evaluation_id {
object.key("EvaluationId").string(var_43.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_ml_model_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteMlModelInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_44) = &input.ml_model_id {
object.key("MLModelId").string(var_44.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_realtime_endpoint_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteRealtimeEndpointInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_45) = &input.ml_model_id {
object.key("MLModelId").string(var_45.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_tags_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteTagsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_46) = &input.tag_keys {
let mut array_47 = object.key("TagKeys").start_array();
for item_48 in var_46 {
{
array_47.value().string(item_48.as_str());
}
}
array_47.finish();
}
if let Some(var_49) = &input.resource_id {
object.key("ResourceId").string(var_49.as_str());
}
if let Some(var_50) = &input.resource_type {
object.key("ResourceType").string(var_50.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_batch_predictions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeBatchPredictionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_51) = &input.filter_variable {
object.key("FilterVariable").string(var_51.as_str());
}
if let Some(var_52) = &input.eq {
object.key("EQ").string(var_52.as_str());
}
if let Some(var_53) = &input.gt {
object.key("GT").string(var_53.as_str());
}
if let Some(var_54) = &input.lt {
object.key("LT").string(var_54.as_str());
}
if let Some(var_55) = &input.ge {
object.key("GE").string(var_55.as_str());
}
if let Some(var_56) = &input.le {
object.key("LE").string(var_56.as_str());
}
if let Some(var_57) = &input.ne {
object.key("NE").string(var_57.as_str());
}
if let Some(var_58) = &input.prefix {
object.key("Prefix").string(var_58.as_str());
}
if let Some(var_59) = &input.sort_order {
object.key("SortOrder").string(var_59.as_str());
}
if let Some(var_60) = &input.next_token {
object.key("NextToken").string(var_60.as_str());
}
if let Some(var_61) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_61).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_data_sources_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeDataSourcesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_62) = &input.filter_variable {
object.key("FilterVariable").string(var_62.as_str());
}
if let Some(var_63) = &input.eq {
object.key("EQ").string(var_63.as_str());
}
if let Some(var_64) = &input.gt {
object.key("GT").string(var_64.as_str());
}
if let Some(var_65) = &input.lt {
object.key("LT").string(var_65.as_str());
}
if let Some(var_66) = &input.ge {
object.key("GE").string(var_66.as_str());
}
if let Some(var_67) = &input.le {
object.key("LE").string(var_67.as_str());
}
if let Some(var_68) = &input.ne {
object.key("NE").string(var_68.as_str());
}
if let Some(var_69) = &input.prefix {
object.key("Prefix").string(var_69.as_str());
}
if let Some(var_70) = &input.sort_order {
object.key("SortOrder").string(var_70.as_str());
}
if let Some(var_71) = &input.next_token {
object.key("NextToken").string(var_71.as_str());
}
if let Some(var_72) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_72).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_evaluations_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeEvaluationsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_73) = &input.filter_variable {
object.key("FilterVariable").string(var_73.as_str());
}
if let Some(var_74) = &input.eq {
object.key("EQ").string(var_74.as_str());
}
if let Some(var_75) = &input.gt {
object.key("GT").string(var_75.as_str());
}
if let Some(var_76) = &input.lt {
object.key("LT").string(var_76.as_str());
}
if let Some(var_77) = &input.ge {
object.key("GE").string(var_77.as_str());
}
if let Some(var_78) = &input.le {
object.key("LE").string(var_78.as_str());
}
if let Some(var_79) = &input.ne {
object.key("NE").string(var_79.as_str());
}
if let Some(var_80) = &input.prefix {
object.key("Prefix").string(var_80.as_str());
}
if let Some(var_81) = &input.sort_order {
object.key("SortOrder").string(var_81.as_str());
}
if let Some(var_82) = &input.next_token {
object.key("NextToken").string(var_82.as_str());
}
if let Some(var_83) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_83).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_ml_models_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeMlModelsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_84) = &input.filter_variable {
object.key("FilterVariable").string(var_84.as_str());
}
if let Some(var_85) = &input.eq {
object.key("EQ").string(var_85.as_str());
}
if let Some(var_86) = &input.gt {
object.key("GT").string(var_86.as_str());
}
if let Some(var_87) = &input.lt {
object.key("LT").string(var_87.as_str());
}
if let Some(var_88) = &input.ge {
object.key("GE").string(var_88.as_str());
}
if let Some(var_89) = &input.le {
object.key("LE").string(var_89.as_str());
}
if let Some(var_90) = &input.ne {
object.key("NE").string(var_90.as_str());
}
if let Some(var_91) = &input.prefix {
object.key("Prefix").string(var_91.as_str());
}
if let Some(var_92) = &input.sort_order {
object.key("SortOrder").string(var_92.as_str());
}
if let Some(var_93) = &input.next_token {
object.key("NextToken").string(var_93.as_str());
}
if let Some(var_94) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_94).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_tags_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeTagsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_95) = &input.resource_id {
object.key("ResourceId").string(var_95.as_str());
}
if let Some(var_96) = &input.resource_type {
object.key("ResourceType").string(var_96.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_batch_prediction_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetBatchPredictionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_97) = &input.batch_prediction_id {
object.key("BatchPredictionId").string(var_97.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_data_source_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetDataSourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_98) = &input.data_source_id {
object.key("DataSourceId").string(var_98.as_str());
}
if input.verbose {
object.key("Verbose").boolean(input.verbose);
}
Ok(())
}
pub fn serialize_structure_crate_input_get_evaluation_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetEvaluationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_99) = &input.evaluation_id {
object.key("EvaluationId").string(var_99.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_ml_model_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetMlModelInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_100) = &input.ml_model_id {
object.key("MLModelId").string(var_100.as_str());
}
if input.verbose {
object.key("Verbose").boolean(input.verbose);
}
Ok(())
}
pub fn serialize_structure_crate_input_predict_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PredictInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_101) = &input.ml_model_id {
object.key("MLModelId").string(var_101.as_str());
}
if let Some(var_102) = &input.record {
#[allow(unused_mut)]
let mut object_103 = object.key("Record").start_object();
for (key_104, value_105) in var_102 {
{
object_103.key(key_104.as_str()).string(value_105.as_str());
}
}
object_103.finish();
}
if let Some(var_106) = &input.predict_endpoint {
object.key("PredictEndpoint").string(var_106.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_batch_prediction_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateBatchPredictionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_107) = &input.batch_prediction_id {
object.key("BatchPredictionId").string(var_107.as_str());
}
if let Some(var_108) = &input.batch_prediction_name {
object.key("BatchPredictionName").string(var_108.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_data_source_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateDataSourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_109) = &input.data_source_id {
object.key("DataSourceId").string(var_109.as_str());
}
if let Some(var_110) = &input.data_source_name {
object.key("DataSourceName").string(var_110.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_evaluation_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateEvaluationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_111) = &input.evaluation_id {
object.key("EvaluationId").string(var_111.as_str());
}
if let Some(var_112) = &input.evaluation_name {
object.key("EvaluationName").string(var_112.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_ml_model_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateMlModelInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_113) = &input.ml_model_id {
object.key("MLModelId").string(var_113.as_str());
}
if let Some(var_114) = &input.ml_model_name {
object.key("MLModelName").string(var_114.as_str());
}
if let Some(var_115) = &input.score_threshold {
object.key("ScoreThreshold").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_115).into()),
);
}
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_116) = &input.key {
object.key("Key").string(var_116.as_str());
}
if let Some(var_117) = &input.value {
object.key("Value").string(var_117.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_rds_data_spec(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RdsDataSpec,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_118) = &input.database_information {
#[allow(unused_mut)]
let mut object_119 = object.key("DatabaseInformation").start_object();
crate::json_ser::serialize_structure_crate_model_rds_database(&mut object_119, var_118)?;
object_119.finish();
}
if let Some(var_120) = &input.select_sql_query {
object.key("SelectSqlQuery").string(var_120.as_str());
}
if let Some(var_121) = &input.database_credentials {
#[allow(unused_mut)]
let mut object_122 = object.key("DatabaseCredentials").start_object();
crate::json_ser::serialize_structure_crate_model_rds_database_credentials(
&mut object_122,
var_121,
)?;
object_122.finish();
}
if let Some(var_123) = &input.s3_staging_location {
object.key("S3StagingLocation").string(var_123.as_str());
}
if let Some(var_124) = &input.data_rearrangement {
object.key("DataRearrangement").string(var_124.as_str());
}
if let Some(var_125) = &input.data_schema {
object.key("DataSchema").string(var_125.as_str());
}
if let Some(var_126) = &input.data_schema_uri {
object.key("DataSchemaUri").string(var_126.as_str());
}
if let Some(var_127) = &input.resource_role {
object.key("ResourceRole").string(var_127.as_str());
}
if let Some(var_128) = &input.service_role {
object.key("ServiceRole").string(var_128.as_str());
}
if let Some(var_129) = &input.subnet_id {
object.key("SubnetId").string(var_129.as_str());
}
if let Some(var_130) = &input.security_group_ids {
let mut array_131 = object.key("SecurityGroupIds").start_array();
for item_132 in var_130 {
{
array_131.value().string(item_132.as_str());
}
}
array_131.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_redshift_data_spec(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RedshiftDataSpec,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_133) = &input.database_information {
#[allow(unused_mut)]
let mut object_134 = object.key("DatabaseInformation").start_object();
crate::json_ser::serialize_structure_crate_model_redshift_database(
&mut object_134,
var_133,
)?;
object_134.finish();
}
if let Some(var_135) = &input.select_sql_query {
object.key("SelectSqlQuery").string(var_135.as_str());
}
if let Some(var_136) = &input.database_credentials {
#[allow(unused_mut)]
let mut object_137 = object.key("DatabaseCredentials").start_object();
crate::json_ser::serialize_structure_crate_model_redshift_database_credentials(
&mut object_137,
var_136,
)?;
object_137.finish();
}
if let Some(var_138) = &input.s3_staging_location {
object.key("S3StagingLocation").string(var_138.as_str());
}
if let Some(var_139) = &input.data_rearrangement {
object.key("DataRearrangement").string(var_139.as_str());
}
if let Some(var_140) = &input.data_schema {
object.key("DataSchema").string(var_140.as_str());
}
if let Some(var_141) = &input.data_schema_uri {
object.key("DataSchemaUri").string(var_141.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_s3_data_spec(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::S3DataSpec,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_142) = &input.data_location_s3 {
object.key("DataLocationS3").string(var_142.as_str());
}
if let Some(var_143) = &input.data_rearrangement {
object.key("DataRearrangement").string(var_143.as_str());
}
if let Some(var_144) = &input.data_schema {
object.key("DataSchema").string(var_144.as_str());
}
if let Some(var_145) = &input.data_schema_location_s3 {
object.key("DataSchemaLocationS3").string(var_145.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_rds_database(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RdsDatabase,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_146) = &input.instance_identifier {
object.key("InstanceIdentifier").string(var_146.as_str());
}
if let Some(var_147) = &input.database_name {
object.key("DatabaseName").string(var_147.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_rds_database_credentials(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RdsDatabaseCredentials,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_148) = &input.username {
object.key("Username").string(var_148.as_str());
}
if let Some(var_149) = &input.password {
object.key("Password").string(var_149.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_redshift_database(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RedshiftDatabase,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_150) = &input.database_name {
object.key("DatabaseName").string(var_150.as_str());
}
if let Some(var_151) = &input.cluster_identifier {
object.key("ClusterIdentifier").string(var_151.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_redshift_database_credentials(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RedshiftDatabaseCredentials,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_152) = &input.username {
object.key("Username").string(var_152.as_str());
}
if let Some(var_153) = &input.password {
object.key("Password").string(var_153.as_str());
}
Ok(())
}