pub fn serialize_structure_crate_input_batch_delete_recipe_version_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchDeleteRecipeVersionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.recipe_versions {
let mut array_2 = object.key("RecipeVersions").start_array();
for item_3 in var_1 {
{
array_2.value().string(item_3.as_str());
}
}
array_2.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_dataset_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateDatasetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_4) = &input.format {
object.key("Format").string(var_4.as_str());
}
if let Some(var_5) = &input.format_options {
#[allow(unused_mut)]
let mut object_6 = object.key("FormatOptions").start_object();
crate::json_ser::serialize_structure_crate_model_format_options(&mut object_6, var_5)?;
object_6.finish();
}
if let Some(var_7) = &input.input {
#[allow(unused_mut)]
let mut object_8 = object.key("Input").start_object();
crate::json_ser::serialize_structure_crate_model_input(&mut object_8, var_7)?;
object_8.finish();
}
if let Some(var_9) = &input.name {
object.key("Name").string(var_9.as_str());
}
if let Some(var_10) = &input.path_options {
#[allow(unused_mut)]
let mut object_11 = object.key("PathOptions").start_object();
crate::json_ser::serialize_structure_crate_model_path_options(&mut object_11, var_10)?;
object_11.finish();
}
if let Some(var_12) = &input.tags {
#[allow(unused_mut)]
let mut object_13 = object.key("Tags").start_object();
for (key_14, value_15) in var_12 {
{
object_13.key(key_14.as_str()).string(value_15.as_str());
}
}
object_13.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_profile_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateProfileJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_16) = &input.configuration {
#[allow(unused_mut)]
let mut object_17 = object.key("Configuration").start_object();
crate::json_ser::serialize_structure_crate_model_profile_configuration(
&mut object_17,
var_16,
)?;
object_17.finish();
}
if let Some(var_18) = &input.dataset_name {
object.key("DatasetName").string(var_18.as_str());
}
if let Some(var_19) = &input.encryption_key_arn {
object.key("EncryptionKeyArn").string(var_19.as_str());
}
if let Some(var_20) = &input.encryption_mode {
object.key("EncryptionMode").string(var_20.as_str());
}
if let Some(var_21) = &input.job_sample {
#[allow(unused_mut)]
let mut object_22 = object.key("JobSample").start_object();
crate::json_ser::serialize_structure_crate_model_job_sample(&mut object_22, var_21)?;
object_22.finish();
}
if let Some(var_23) = &input.log_subscription {
object.key("LogSubscription").string(var_23.as_str());
}
if input.max_capacity != 0 {
object.key("MaxCapacity").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max_capacity).into()),
);
}
if input.max_retries != 0 {
object.key("MaxRetries").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max_retries).into()),
);
}
if let Some(var_24) = &input.name {
object.key("Name").string(var_24.as_str());
}
if let Some(var_25) = &input.output_location {
#[allow(unused_mut)]
let mut object_26 = object.key("OutputLocation").start_object();
crate::json_ser::serialize_structure_crate_model_s3_location(&mut object_26, var_25)?;
object_26.finish();
}
if let Some(var_27) = &input.role_arn {
object.key("RoleArn").string(var_27.as_str());
}
if let Some(var_28) = &input.tags {
#[allow(unused_mut)]
let mut object_29 = object.key("Tags").start_object();
for (key_30, value_31) in var_28 {
{
object_29.key(key_30.as_str()).string(value_31.as_str());
}
}
object_29.finish();
}
if input.timeout != 0 {
object.key("Timeout").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.timeout).into()),
);
}
if let Some(var_32) = &input.validation_configurations {
let mut array_33 = object.key("ValidationConfigurations").start_array();
for item_34 in var_32 {
{
#[allow(unused_mut)]
let mut object_35 = array_33.value().start_object();
crate::json_ser::serialize_structure_crate_model_validation_configuration(
&mut object_35,
item_34,
)?;
object_35.finish();
}
}
array_33.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_project_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateProjectInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_36) = &input.dataset_name {
object.key("DatasetName").string(var_36.as_str());
}
if let Some(var_37) = &input.name {
object.key("Name").string(var_37.as_str());
}
if let Some(var_38) = &input.recipe_name {
object.key("RecipeName").string(var_38.as_str());
}
if let Some(var_39) = &input.role_arn {
object.key("RoleArn").string(var_39.as_str());
}
if let Some(var_40) = &input.sample {
#[allow(unused_mut)]
let mut object_41 = object.key("Sample").start_object();
crate::json_ser::serialize_structure_crate_model_sample(&mut object_41, var_40)?;
object_41.finish();
}
if let Some(var_42) = &input.tags {
#[allow(unused_mut)]
let mut object_43 = object.key("Tags").start_object();
for (key_44, value_45) in var_42 {
{
object_43.key(key_44.as_str()).string(value_45.as_str());
}
}
object_43.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_recipe_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateRecipeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_46) = &input.description {
object.key("Description").string(var_46.as_str());
}
if let Some(var_47) = &input.name {
object.key("Name").string(var_47.as_str());
}
if let Some(var_48) = &input.steps {
let mut array_49 = object.key("Steps").start_array();
for item_50 in var_48 {
{
#[allow(unused_mut)]
let mut object_51 = array_49.value().start_object();
crate::json_ser::serialize_structure_crate_model_recipe_step(
&mut object_51,
item_50,
)?;
object_51.finish();
}
}
array_49.finish();
}
if let Some(var_52) = &input.tags {
#[allow(unused_mut)]
let mut object_53 = object.key("Tags").start_object();
for (key_54, value_55) in var_52 {
{
object_53.key(key_54.as_str()).string(value_55.as_str());
}
}
object_53.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_recipe_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateRecipeJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_56) = &input.data_catalog_outputs {
let mut array_57 = object.key("DataCatalogOutputs").start_array();
for item_58 in var_56 {
{
#[allow(unused_mut)]
let mut object_59 = array_57.value().start_object();
crate::json_ser::serialize_structure_crate_model_data_catalog_output(
&mut object_59,
item_58,
)?;
object_59.finish();
}
}
array_57.finish();
}
if let Some(var_60) = &input.database_outputs {
let mut array_61 = object.key("DatabaseOutputs").start_array();
for item_62 in var_60 {
{
#[allow(unused_mut)]
let mut object_63 = array_61.value().start_object();
crate::json_ser::serialize_structure_crate_model_database_output(
&mut object_63,
item_62,
)?;
object_63.finish();
}
}
array_61.finish();
}
if let Some(var_64) = &input.dataset_name {
object.key("DatasetName").string(var_64.as_str());
}
if let Some(var_65) = &input.encryption_key_arn {
object.key("EncryptionKeyArn").string(var_65.as_str());
}
if let Some(var_66) = &input.encryption_mode {
object.key("EncryptionMode").string(var_66.as_str());
}
if let Some(var_67) = &input.log_subscription {
object.key("LogSubscription").string(var_67.as_str());
}
if input.max_capacity != 0 {
object.key("MaxCapacity").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max_capacity).into()),
);
}
if input.max_retries != 0 {
object.key("MaxRetries").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max_retries).into()),
);
}
if let Some(var_68) = &input.name {
object.key("Name").string(var_68.as_str());
}
if let Some(var_69) = &input.outputs {
let mut array_70 = object.key("Outputs").start_array();
for item_71 in var_69 {
{
#[allow(unused_mut)]
let mut object_72 = array_70.value().start_object();
crate::json_ser::serialize_structure_crate_model_output(&mut object_72, item_71)?;
object_72.finish();
}
}
array_70.finish();
}
if let Some(var_73) = &input.project_name {
object.key("ProjectName").string(var_73.as_str());
}
if let Some(var_74) = &input.recipe_reference {
#[allow(unused_mut)]
let mut object_75 = object.key("RecipeReference").start_object();
crate::json_ser::serialize_structure_crate_model_recipe_reference(&mut object_75, var_74)?;
object_75.finish();
}
if let Some(var_76) = &input.role_arn {
object.key("RoleArn").string(var_76.as_str());
}
if let Some(var_77) = &input.tags {
#[allow(unused_mut)]
let mut object_78 = object.key("Tags").start_object();
for (key_79, value_80) in var_77 {
{
object_78.key(key_79.as_str()).string(value_80.as_str());
}
}
object_78.finish();
}
if input.timeout != 0 {
object.key("Timeout").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.timeout).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_create_ruleset_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateRulesetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_81) = &input.description {
object.key("Description").string(var_81.as_str());
}
if let Some(var_82) = &input.name {
object.key("Name").string(var_82.as_str());
}
if let Some(var_83) = &input.rules {
let mut array_84 = object.key("Rules").start_array();
for item_85 in var_83 {
{
#[allow(unused_mut)]
let mut object_86 = array_84.value().start_object();
crate::json_ser::serialize_structure_crate_model_rule(&mut object_86, item_85)?;
object_86.finish();
}
}
array_84.finish();
}
if let Some(var_87) = &input.tags {
#[allow(unused_mut)]
let mut object_88 = object.key("Tags").start_object();
for (key_89, value_90) in var_87 {
{
object_88.key(key_89.as_str()).string(value_90.as_str());
}
}
object_88.finish();
}
if let Some(var_91) = &input.target_arn {
object.key("TargetArn").string(var_91.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_schedule_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateScheduleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_92) = &input.cron_expression {
object.key("CronExpression").string(var_92.as_str());
}
if let Some(var_93) = &input.job_names {
let mut array_94 = object.key("JobNames").start_array();
for item_95 in var_93 {
{
array_94.value().string(item_95.as_str());
}
}
array_94.finish();
}
if let Some(var_96) = &input.name {
object.key("Name").string(var_96.as_str());
}
if let Some(var_97) = &input.tags {
#[allow(unused_mut)]
let mut object_98 = object.key("Tags").start_object();
for (key_99, value_100) in var_97 {
{
object_98.key(key_99.as_str()).string(value_100.as_str());
}
}
object_98.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_publish_recipe_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PublishRecipeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_101) = &input.description {
object.key("Description").string(var_101.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_send_project_session_action_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::SendProjectSessionActionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_102) = &input.client_session_id {
object.key("ClientSessionId").string(var_102.as_str());
}
if input.preview {
object.key("Preview").boolean(input.preview);
}
if let Some(var_103) = &input.recipe_step {
#[allow(unused_mut)]
let mut object_104 = object.key("RecipeStep").start_object();
crate::json_ser::serialize_structure_crate_model_recipe_step(&mut object_104, var_103)?;
object_104.finish();
}
if let Some(var_105) = &input.step_index {
object.key("StepIndex").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_105).into()),
);
}
if let Some(var_106) = &input.view_frame {
#[allow(unused_mut)]
let mut object_107 = object.key("ViewFrame").start_object();
crate::json_ser::serialize_structure_crate_model_view_frame(&mut object_107, var_106)?;
object_107.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_start_project_session_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartProjectSessionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.assume_control {
object.key("AssumeControl").boolean(input.assume_control);
}
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_108) = &input.tags {
#[allow(unused_mut)]
let mut object_109 = object.key("Tags").start_object();
for (key_110, value_111) in var_108 {
{
object_109.key(key_110.as_str()).string(value_111.as_str());
}
}
object_109.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_dataset_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateDatasetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_112) = &input.format {
object.key("Format").string(var_112.as_str());
}
if let Some(var_113) = &input.format_options {
#[allow(unused_mut)]
let mut object_114 = object.key("FormatOptions").start_object();
crate::json_ser::serialize_structure_crate_model_format_options(&mut object_114, var_113)?;
object_114.finish();
}
if let Some(var_115) = &input.input {
#[allow(unused_mut)]
let mut object_116 = object.key("Input").start_object();
crate::json_ser::serialize_structure_crate_model_input(&mut object_116, var_115)?;
object_116.finish();
}
if let Some(var_117) = &input.path_options {
#[allow(unused_mut)]
let mut object_118 = object.key("PathOptions").start_object();
crate::json_ser::serialize_structure_crate_model_path_options(&mut object_118, var_117)?;
object_118.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_profile_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateProfileJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_119) = &input.configuration {
#[allow(unused_mut)]
let mut object_120 = object.key("Configuration").start_object();
crate::json_ser::serialize_structure_crate_model_profile_configuration(
&mut object_120,
var_119,
)?;
object_120.finish();
}
if let Some(var_121) = &input.encryption_key_arn {
object.key("EncryptionKeyArn").string(var_121.as_str());
}
if let Some(var_122) = &input.encryption_mode {
object.key("EncryptionMode").string(var_122.as_str());
}
if let Some(var_123) = &input.job_sample {
#[allow(unused_mut)]
let mut object_124 = object.key("JobSample").start_object();
crate::json_ser::serialize_structure_crate_model_job_sample(&mut object_124, var_123)?;
object_124.finish();
}
if let Some(var_125) = &input.log_subscription {
object.key("LogSubscription").string(var_125.as_str());
}
if input.max_capacity != 0 {
object.key("MaxCapacity").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max_capacity).into()),
);
}
if input.max_retries != 0 {
object.key("MaxRetries").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max_retries).into()),
);
}
if let Some(var_126) = &input.output_location {
#[allow(unused_mut)]
let mut object_127 = object.key("OutputLocation").start_object();
crate::json_ser::serialize_structure_crate_model_s3_location(&mut object_127, var_126)?;
object_127.finish();
}
if let Some(var_128) = &input.role_arn {
object.key("RoleArn").string(var_128.as_str());
}
if input.timeout != 0 {
object.key("Timeout").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.timeout).into()),
);
}
if let Some(var_129) = &input.validation_configurations {
let mut array_130 = object.key("ValidationConfigurations").start_array();
for item_131 in var_129 {
{
#[allow(unused_mut)]
let mut object_132 = array_130.value().start_object();
crate::json_ser::serialize_structure_crate_model_validation_configuration(
&mut object_132,
item_131,
)?;
object_132.finish();
}
}
array_130.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_project_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateProjectInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_133) = &input.role_arn {
object.key("RoleArn").string(var_133.as_str());
}
if let Some(var_134) = &input.sample {
#[allow(unused_mut)]
let mut object_135 = object.key("Sample").start_object();
crate::json_ser::serialize_structure_crate_model_sample(&mut object_135, var_134)?;
object_135.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_recipe_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateRecipeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_136) = &input.description {
object.key("Description").string(var_136.as_str());
}
if let Some(var_137) = &input.steps {
let mut array_138 = object.key("Steps").start_array();
for item_139 in var_137 {
{
#[allow(unused_mut)]
let mut object_140 = array_138.value().start_object();
crate::json_ser::serialize_structure_crate_model_recipe_step(
&mut object_140,
item_139,
)?;
object_140.finish();
}
}
array_138.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_recipe_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateRecipeJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_141) = &input.data_catalog_outputs {
let mut array_142 = object.key("DataCatalogOutputs").start_array();
for item_143 in var_141 {
{
#[allow(unused_mut)]
let mut object_144 = array_142.value().start_object();
crate::json_ser::serialize_structure_crate_model_data_catalog_output(
&mut object_144,
item_143,
)?;
object_144.finish();
}
}
array_142.finish();
}
if let Some(var_145) = &input.database_outputs {
let mut array_146 = object.key("DatabaseOutputs").start_array();
for item_147 in var_145 {
{
#[allow(unused_mut)]
let mut object_148 = array_146.value().start_object();
crate::json_ser::serialize_structure_crate_model_database_output(
&mut object_148,
item_147,
)?;
object_148.finish();
}
}
array_146.finish();
}
if let Some(var_149) = &input.encryption_key_arn {
object.key("EncryptionKeyArn").string(var_149.as_str());
}
if let Some(var_150) = &input.encryption_mode {
object.key("EncryptionMode").string(var_150.as_str());
}
if let Some(var_151) = &input.log_subscription {
object.key("LogSubscription").string(var_151.as_str());
}
if input.max_capacity != 0 {
object.key("MaxCapacity").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max_capacity).into()),
);
}
if input.max_retries != 0 {
object.key("MaxRetries").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max_retries).into()),
);
}
if let Some(var_152) = &input.outputs {
let mut array_153 = object.key("Outputs").start_array();
for item_154 in var_152 {
{
#[allow(unused_mut)]
let mut object_155 = array_153.value().start_object();
crate::json_ser::serialize_structure_crate_model_output(&mut object_155, item_154)?;
object_155.finish();
}
}
array_153.finish();
}
if let Some(var_156) = &input.role_arn {
object.key("RoleArn").string(var_156.as_str());
}
if input.timeout != 0 {
object.key("Timeout").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.timeout).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_update_ruleset_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateRulesetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_157) = &input.description {
object.key("Description").string(var_157.as_str());
}
if let Some(var_158) = &input.rules {
let mut array_159 = object.key("Rules").start_array();
for item_160 in var_158 {
{
#[allow(unused_mut)]
let mut object_161 = array_159.value().start_object();
crate::json_ser::serialize_structure_crate_model_rule(&mut object_161, item_160)?;
object_161.finish();
}
}
array_159.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_schedule_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateScheduleInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_162) = &input.cron_expression {
object.key("CronExpression").string(var_162.as_str());
}
if let Some(var_163) = &input.job_names {
let mut array_164 = object.key("JobNames").start_array();
for item_165 in var_163 {
{
array_164.value().string(item_165.as_str());
}
}
array_164.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_format_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FormatOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_166) = &input.json {
#[allow(unused_mut)]
let mut object_167 = object.key("Json").start_object();
crate::json_ser::serialize_structure_crate_model_json_options(&mut object_167, var_166)?;
object_167.finish();
}
if let Some(var_168) = &input.excel {
#[allow(unused_mut)]
let mut object_169 = object.key("Excel").start_object();
crate::json_ser::serialize_structure_crate_model_excel_options(&mut object_169, var_168)?;
object_169.finish();
}
if let Some(var_170) = &input.csv {
#[allow(unused_mut)]
let mut object_171 = object.key("Csv").start_object();
crate::json_ser::serialize_structure_crate_model_csv_options(&mut object_171, var_170)?;
object_171.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Input,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_172) = &input.s3_input_definition {
#[allow(unused_mut)]
let mut object_173 = object.key("S3InputDefinition").start_object();
crate::json_ser::serialize_structure_crate_model_s3_location(&mut object_173, var_172)?;
object_173.finish();
}
if let Some(var_174) = &input.data_catalog_input_definition {
#[allow(unused_mut)]
let mut object_175 = object.key("DataCatalogInputDefinition").start_object();
crate::json_ser::serialize_structure_crate_model_data_catalog_input_definition(
&mut object_175,
var_174,
)?;
object_175.finish();
}
if let Some(var_176) = &input.database_input_definition {
#[allow(unused_mut)]
let mut object_177 = object.key("DatabaseInputDefinition").start_object();
crate::json_ser::serialize_structure_crate_model_database_input_definition(
&mut object_177,
var_176,
)?;
object_177.finish();
}
if let Some(var_178) = &input.metadata {
#[allow(unused_mut)]
let mut object_179 = object.key("Metadata").start_object();
crate::json_ser::serialize_structure_crate_model_metadata(&mut object_179, var_178)?;
object_179.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_path_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PathOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_180) = &input.last_modified_date_condition {
#[allow(unused_mut)]
let mut object_181 = object.key("LastModifiedDateCondition").start_object();
crate::json_ser::serialize_structure_crate_model_filter_expression(
&mut object_181,
var_180,
)?;
object_181.finish();
}
if let Some(var_182) = &input.files_limit {
#[allow(unused_mut)]
let mut object_183 = object.key("FilesLimit").start_object();
crate::json_ser::serialize_structure_crate_model_files_limit(&mut object_183, var_182)?;
object_183.finish();
}
if let Some(var_184) = &input.parameters {
#[allow(unused_mut)]
let mut object_185 = object.key("Parameters").start_object();
for (key_186, value_187) in var_184 {
{
#[allow(unused_mut)]
let mut object_188 = object_185.key(key_186.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_dataset_parameter(
&mut object_188,
value_187,
)?;
object_188.finish();
}
}
object_185.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_profile_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ProfileConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_189) = &input.dataset_statistics_configuration {
#[allow(unused_mut)]
let mut object_190 = object.key("DatasetStatisticsConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_statistics_configuration(
&mut object_190,
var_189,
)?;
object_190.finish();
}
if let Some(var_191) = &input.profile_columns {
let mut array_192 = object.key("ProfileColumns").start_array();
for item_193 in var_191 {
{
#[allow(unused_mut)]
let mut object_194 = array_192.value().start_object();
crate::json_ser::serialize_structure_crate_model_column_selector(
&mut object_194,
item_193,
)?;
object_194.finish();
}
}
array_192.finish();
}
if let Some(var_195) = &input.column_statistics_configurations {
let mut array_196 = object.key("ColumnStatisticsConfigurations").start_array();
for item_197 in var_195 {
{
#[allow(unused_mut)]
let mut object_198 = array_196.value().start_object();
crate::json_ser::serialize_structure_crate_model_column_statistics_configuration(
&mut object_198,
item_197,
)?;
object_198.finish();
}
}
array_196.finish();
}
if let Some(var_199) = &input.entity_detector_configuration {
#[allow(unused_mut)]
let mut object_200 = object.key("EntityDetectorConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_entity_detector_configuration(
&mut object_200,
var_199,
)?;
object_200.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_job_sample(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::JobSample,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_201) = &input.mode {
object.key("Mode").string(var_201.as_str());
}
if let Some(var_202) = &input.size {
object.key("Size").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_202).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_s3_location(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::S3Location,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_203) = &input.bucket {
object.key("Bucket").string(var_203.as_str());
}
if let Some(var_204) = &input.key {
object.key("Key").string(var_204.as_str());
}
if let Some(var_205) = &input.bucket_owner {
object.key("BucketOwner").string(var_205.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_validation_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ValidationConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_206) = &input.ruleset_arn {
object.key("RulesetArn").string(var_206.as_str());
}
if let Some(var_207) = &input.validation_mode {
object.key("ValidationMode").string(var_207.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_sample(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Sample,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_208) = &input.size {
object.key("Size").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_208).into()),
);
}
if let Some(var_209) = &input.r#type {
object.key("Type").string(var_209.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_recipe_step(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RecipeStep,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_210) = &input.action {
#[allow(unused_mut)]
let mut object_211 = object.key("Action").start_object();
crate::json_ser::serialize_structure_crate_model_recipe_action(&mut object_211, var_210)?;
object_211.finish();
}
if let Some(var_212) = &input.condition_expressions {
let mut array_213 = object.key("ConditionExpressions").start_array();
for item_214 in var_212 {
{
#[allow(unused_mut)]
let mut object_215 = array_213.value().start_object();
crate::json_ser::serialize_structure_crate_model_condition_expression(
&mut object_215,
item_214,
)?;
object_215.finish();
}
}
array_213.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_data_catalog_output(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DataCatalogOutput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_216) = &input.catalog_id {
object.key("CatalogId").string(var_216.as_str());
}
if let Some(var_217) = &input.database_name {
object.key("DatabaseName").string(var_217.as_str());
}
if let Some(var_218) = &input.table_name {
object.key("TableName").string(var_218.as_str());
}
if let Some(var_219) = &input.s3_options {
#[allow(unused_mut)]
let mut object_220 = object.key("S3Options").start_object();
crate::json_ser::serialize_structure_crate_model_s3_table_output_options(
&mut object_220,
var_219,
)?;
object_220.finish();
}
if let Some(var_221) = &input.database_options {
#[allow(unused_mut)]
let mut object_222 = object.key("DatabaseOptions").start_object();
crate::json_ser::serialize_structure_crate_model_database_table_output_options(
&mut object_222,
var_221,
)?;
object_222.finish();
}
if input.overwrite {
object.key("Overwrite").boolean(input.overwrite);
}
Ok(())
}
pub fn serialize_structure_crate_model_database_output(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DatabaseOutput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_223) = &input.glue_connection_name {
object.key("GlueConnectionName").string(var_223.as_str());
}
if let Some(var_224) = &input.database_options {
#[allow(unused_mut)]
let mut object_225 = object.key("DatabaseOptions").start_object();
crate::json_ser::serialize_structure_crate_model_database_table_output_options(
&mut object_225,
var_224,
)?;
object_225.finish();
}
if let Some(var_226) = &input.database_output_mode {
object.key("DatabaseOutputMode").string(var_226.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_output(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Output,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_227) = &input.compression_format {
object.key("CompressionFormat").string(var_227.as_str());
}
if let Some(var_228) = &input.format {
object.key("Format").string(var_228.as_str());
}
if let Some(var_229) = &input.partition_columns {
let mut array_230 = object.key("PartitionColumns").start_array();
for item_231 in var_229 {
{
array_230.value().string(item_231.as_str());
}
}
array_230.finish();
}
if let Some(var_232) = &input.location {
#[allow(unused_mut)]
let mut object_233 = object.key("Location").start_object();
crate::json_ser::serialize_structure_crate_model_s3_location(&mut object_233, var_232)?;
object_233.finish();
}
if input.overwrite {
object.key("Overwrite").boolean(input.overwrite);
}
if let Some(var_234) = &input.format_options {
#[allow(unused_mut)]
let mut object_235 = object.key("FormatOptions").start_object();
crate::json_ser::serialize_structure_crate_model_output_format_options(
&mut object_235,
var_234,
)?;
object_235.finish();
}
if let Some(var_236) = &input.max_output_files {
object.key("MaxOutputFiles").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_236).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_recipe_reference(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RecipeReference,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_237) = &input.name {
object.key("Name").string(var_237.as_str());
}
if let Some(var_238) = &input.recipe_version {
object.key("RecipeVersion").string(var_238.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_rule(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Rule,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_239) = &input.name {
object.key("Name").string(var_239.as_str());
}
if input.disabled {
object.key("Disabled").boolean(input.disabled);
}
if let Some(var_240) = &input.check_expression {
object.key("CheckExpression").string(var_240.as_str());
}
if let Some(var_241) = &input.substitution_map {
#[allow(unused_mut)]
let mut object_242 = object.key("SubstitutionMap").start_object();
for (key_243, value_244) in var_241 {
{
object_242.key(key_243.as_str()).string(value_244.as_str());
}
}
object_242.finish();
}
if let Some(var_245) = &input.threshold {
#[allow(unused_mut)]
let mut object_246 = object.key("Threshold").start_object();
crate::json_ser::serialize_structure_crate_model_threshold(&mut object_246, var_245)?;
object_246.finish();
}
if let Some(var_247) = &input.column_selectors {
let mut array_248 = object.key("ColumnSelectors").start_array();
for item_249 in var_247 {
{
#[allow(unused_mut)]
let mut object_250 = array_248.value().start_object();
crate::json_ser::serialize_structure_crate_model_column_selector(
&mut object_250,
item_249,
)?;
object_250.finish();
}
}
array_248.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_view_frame(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ViewFrame,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_251) = &input.start_column_index {
object.key("StartColumnIndex").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_251).into()),
);
}
if let Some(var_252) = &input.column_range {
object.key("ColumnRange").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_252).into()),
);
}
if let Some(var_253) = &input.hidden_columns {
let mut array_254 = object.key("HiddenColumns").start_array();
for item_255 in var_253 {
{
array_254.value().string(item_255.as_str());
}
}
array_254.finish();
}
if let Some(var_256) = &input.start_row_index {
object.key("StartRowIndex").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_256).into()),
);
}
if let Some(var_257) = &input.row_range {
object.key("RowRange").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_257).into()),
);
}
if let Some(var_258) = &input.analytics {
object.key("Analytics").string(var_258.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_json_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::JsonOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.multi_line {
object.key("MultiLine").boolean(input.multi_line);
}
Ok(())
}
pub fn serialize_structure_crate_model_excel_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ExcelOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_259) = &input.sheet_names {
let mut array_260 = object.key("SheetNames").start_array();
for item_261 in var_259 {
{
array_260.value().string(item_261.as_str());
}
}
array_260.finish();
}
if let Some(var_262) = &input.sheet_indexes {
let mut array_263 = object.key("SheetIndexes").start_array();
for item_264 in var_262 {
{
array_263.value().number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*item_264).into()),
);
}
}
array_263.finish();
}
if let Some(var_265) = &input.header_row {
object.key("HeaderRow").boolean(*var_265);
}
Ok(())
}
pub fn serialize_structure_crate_model_csv_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CsvOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_266) = &input.delimiter {
object.key("Delimiter").string(var_266.as_str());
}
if let Some(var_267) = &input.header_row {
object.key("HeaderRow").boolean(*var_267);
}
Ok(())
}
pub fn serialize_structure_crate_model_data_catalog_input_definition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DataCatalogInputDefinition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_268) = &input.catalog_id {
object.key("CatalogId").string(var_268.as_str());
}
if let Some(var_269) = &input.database_name {
object.key("DatabaseName").string(var_269.as_str());
}
if let Some(var_270) = &input.table_name {
object.key("TableName").string(var_270.as_str());
}
if let Some(var_271) = &input.temp_directory {
#[allow(unused_mut)]
let mut object_272 = object.key("TempDirectory").start_object();
crate::json_ser::serialize_structure_crate_model_s3_location(&mut object_272, var_271)?;
object_272.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_database_input_definition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DatabaseInputDefinition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_273) = &input.glue_connection_name {
object.key("GlueConnectionName").string(var_273.as_str());
}
if let Some(var_274) = &input.database_table_name {
object.key("DatabaseTableName").string(var_274.as_str());
}
if let Some(var_275) = &input.temp_directory {
#[allow(unused_mut)]
let mut object_276 = object.key("TempDirectory").start_object();
crate::json_ser::serialize_structure_crate_model_s3_location(&mut object_276, var_275)?;
object_276.finish();
}
if let Some(var_277) = &input.query_string {
object.key("QueryString").string(var_277.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_metadata(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Metadata,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_278) = &input.source_arn {
object.key("SourceArn").string(var_278.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_filter_expression(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FilterExpression,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_279) = &input.expression {
object.key("Expression").string(var_279.as_str());
}
if let Some(var_280) = &input.values_map {
#[allow(unused_mut)]
let mut object_281 = object.key("ValuesMap").start_object();
for (key_282, value_283) in var_280 {
{
object_281.key(key_282.as_str()).string(value_283.as_str());
}
}
object_281.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_files_limit(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FilesLimit,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
{
object.key("MaxFiles").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max_files).into()),
);
}
if let Some(var_284) = &input.ordered_by {
object.key("OrderedBy").string(var_284.as_str());
}
if let Some(var_285) = &input.order {
object.key("Order").string(var_285.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_dataset_parameter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DatasetParameter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_286) = &input.name {
object.key("Name").string(var_286.as_str());
}
if let Some(var_287) = &input.r#type {
object.key("Type").string(var_287.as_str());
}
if let Some(var_288) = &input.datetime_options {
#[allow(unused_mut)]
let mut object_289 = object.key("DatetimeOptions").start_object();
crate::json_ser::serialize_structure_crate_model_datetime_options(
&mut object_289,
var_288,
)?;
object_289.finish();
}
if input.create_column {
object.key("CreateColumn").boolean(input.create_column);
}
if let Some(var_290) = &input.filter {
#[allow(unused_mut)]
let mut object_291 = object.key("Filter").start_object();
crate::json_ser::serialize_structure_crate_model_filter_expression(
&mut object_291,
var_290,
)?;
object_291.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_statistics_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StatisticsConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_292) = &input.included_statistics {
let mut array_293 = object.key("IncludedStatistics").start_array();
for item_294 in var_292 {
{
array_293.value().string(item_294.as_str());
}
}
array_293.finish();
}
if let Some(var_295) = &input.overrides {
let mut array_296 = object.key("Overrides").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_statistic_override(
&mut object_298,
item_297,
)?;
object_298.finish();
}
}
array_296.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_column_selector(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ColumnSelector,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_299) = &input.regex {
object.key("Regex").string(var_299.as_str());
}
if let Some(var_300) = &input.name {
object.key("Name").string(var_300.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_column_statistics_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ColumnStatisticsConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_301) = &input.selectors {
let mut array_302 = object.key("Selectors").start_array();
for item_303 in var_301 {
{
#[allow(unused_mut)]
let mut object_304 = array_302.value().start_object();
crate::json_ser::serialize_structure_crate_model_column_selector(
&mut object_304,
item_303,
)?;
object_304.finish();
}
}
array_302.finish();
}
if let Some(var_305) = &input.statistics {
#[allow(unused_mut)]
let mut object_306 = object.key("Statistics").start_object();
crate::json_ser::serialize_structure_crate_model_statistics_configuration(
&mut object_306,
var_305,
)?;
object_306.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_entity_detector_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EntityDetectorConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_307) = &input.entity_types {
let mut array_308 = object.key("EntityTypes").start_array();
for item_309 in var_307 {
{
array_308.value().string(item_309.as_str());
}
}
array_308.finish();
}
if let Some(var_310) = &input.allowed_statistics {
let mut array_311 = object.key("AllowedStatistics").start_array();
for item_312 in var_310 {
{
#[allow(unused_mut)]
let mut object_313 = array_311.value().start_object();
crate::json_ser::serialize_structure_crate_model_allowed_statistics(
&mut object_313,
item_312,
)?;
object_313.finish();
}
}
array_311.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_recipe_action(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RecipeAction,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_314) = &input.operation {
object.key("Operation").string(var_314.as_str());
}
if let Some(var_315) = &input.parameters {
#[allow(unused_mut)]
let mut object_316 = object.key("Parameters").start_object();
for (key_317, value_318) in var_315 {
{
object_316.key(key_317.as_str()).string(value_318.as_str());
}
}
object_316.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_condition_expression(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ConditionExpression,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_319) = &input.condition {
object.key("Condition").string(var_319.as_str());
}
if let Some(var_320) = &input.value {
object.key("Value").string(var_320.as_str());
}
if let Some(var_321) = &input.target_column {
object.key("TargetColumn").string(var_321.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_s3_table_output_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::S3TableOutputOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_322) = &input.location {
#[allow(unused_mut)]
let mut object_323 = object.key("Location").start_object();
crate::json_ser::serialize_structure_crate_model_s3_location(&mut object_323, var_322)?;
object_323.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_database_table_output_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DatabaseTableOutputOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_324) = &input.temp_directory {
#[allow(unused_mut)]
let mut object_325 = object.key("TempDirectory").start_object();
crate::json_ser::serialize_structure_crate_model_s3_location(&mut object_325, var_324)?;
object_325.finish();
}
if let Some(var_326) = &input.table_name {
object.key("TableName").string(var_326.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_output_format_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OutputFormatOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_327) = &input.csv {
#[allow(unused_mut)]
let mut object_328 = object.key("Csv").start_object();
crate::json_ser::serialize_structure_crate_model_csv_output_options(
&mut object_328,
var_327,
)?;
object_328.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_threshold(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Threshold,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
{
object.key("Value").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((input.value).into()),
);
}
if let Some(var_329) = &input.r#type {
object.key("Type").string(var_329.as_str());
}
if let Some(var_330) = &input.unit {
object.key("Unit").string(var_330.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_datetime_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DatetimeOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_331) = &input.format {
object.key("Format").string(var_331.as_str());
}
if let Some(var_332) = &input.timezone_offset {
object.key("TimezoneOffset").string(var_332.as_str());
}
if let Some(var_333) = &input.locale_code {
object.key("LocaleCode").string(var_333.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_statistic_override(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StatisticOverride,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_334) = &input.statistic {
object.key("Statistic").string(var_334.as_str());
}
if let Some(var_335) = &input.parameters {
#[allow(unused_mut)]
let mut object_336 = object.key("Parameters").start_object();
for (key_337, value_338) in var_335 {
{
object_336.key(key_337.as_str()).string(value_338.as_str());
}
}
object_336.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_allowed_statistics(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AllowedStatistics,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_339) = &input.statistics {
let mut array_340 = object.key("Statistics").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_csv_output_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CsvOutputOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_342) = &input.delimiter {
object.key("Delimiter").string(var_342.as_str());
}
Ok(())
}