pub fn serialize_structure_crate_input_export_earth_observation_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ExportEarthObservationJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.arn {
object.key("Arn").string(var_1.as_str());
}
if let Some(var_2) = &input.execution_role_arn {
object.key("ExecutionRoleArn").string(var_2.as_str());
}
if let Some(var_3) = &input.export_source_images {
object.key("ExportSourceImages").boolean(*var_3);
}
if let Some(var_4) = &input.output_config {
#[allow(unused_mut)]
let mut object_5 = object.key("OutputConfig").start_object();
crate::json_ser::serialize_structure_crate_model_output_config_input(&mut object_5, var_4)?;
object_5.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_export_vector_enrichment_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ExportVectorEnrichmentJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_6) = &input.arn {
object.key("Arn").string(var_6.as_str());
}
if let Some(var_7) = &input.execution_role_arn {
object.key("ExecutionRoleArn").string(var_7.as_str());
}
if let Some(var_8) = &input.output_config {
#[allow(unused_mut)]
let mut object_9 = object.key("OutputConfig").start_object();
crate::json_ser::serialize_structure_crate_model_export_vector_enrichment_job_output_config(&mut object_9, var_8)?;
object_9.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_earth_observation_jobs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListEarthObservationJobsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_10) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_10).into()),
);
}
if let Some(var_11) = &input.next_token {
object.key("NextToken").string(var_11.as_str());
}
if let Some(var_12) = &input.sort_by {
object.key("SortBy").string(var_12.as_str());
}
if let Some(var_13) = &input.sort_order {
object.key("SortOrder").string(var_13.as_str());
}
if let Some(var_14) = &input.status_equals {
object.key("StatusEquals").string(var_14.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_vector_enrichment_jobs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListVectorEnrichmentJobsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_15) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_15).into()),
);
}
if let Some(var_16) = &input.next_token {
object.key("NextToken").string(var_16.as_str());
}
if let Some(var_17) = &input.sort_by {
object.key("SortBy").string(var_17.as_str());
}
if let Some(var_18) = &input.sort_order {
object.key("SortOrder").string(var_18.as_str());
}
if let Some(var_19) = &input.status_equals {
object.key("StatusEquals").string(var_19.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_search_raster_data_collection_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::SearchRasterDataCollectionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_20) = &input.arn {
object.key("Arn").string(var_20.as_str());
}
if let Some(var_21) = &input.next_token {
object.key("NextToken").string(var_21.as_str());
}
if let Some(var_22) = &input.raster_data_collection_query {
#[allow(unused_mut)]
let mut object_23 = object.key("RasterDataCollectionQuery").start_object();
crate::json_ser::serialize_structure_crate_model_raster_data_collection_query_with_band_filter_input(&mut object_23, var_22)?;
object_23.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_start_earth_observation_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartEarthObservationJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_24) = &input.client_token {
object.key("ClientToken").string(var_24.as_str());
}
if let Some(var_25) = &input.execution_role_arn {
object.key("ExecutionRoleArn").string(var_25.as_str());
}
if let Some(var_26) = &input.input_config {
#[allow(unused_mut)]
let mut object_27 = object.key("InputConfig").start_object();
crate::json_ser::serialize_structure_crate_model_input_config_input(
&mut object_27,
var_26,
)?;
object_27.finish();
}
if let Some(var_28) = &input.job_config {
#[allow(unused_mut)]
let mut object_29 = object.key("JobConfig").start_object();
crate::json_ser::serialize_union_crate_model_job_config_input(&mut object_29, var_28)?;
object_29.finish();
}
if let Some(var_30) = &input.kms_key_id {
object.key("KmsKeyId").string(var_30.as_str());
}
if let Some(var_31) = &input.name {
object.key("Name").string(var_31.as_str());
}
if let Some(var_32) = &input.tags {
#[allow(unused_mut)]
let mut object_33 = object.key("Tags").start_object();
for (key_34, value_35) in var_32 {
{
object_33.key(key_34.as_str()).string(value_35.as_str());
}
}
object_33.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_start_vector_enrichment_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartVectorEnrichmentJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_36) = &input.client_token {
object.key("ClientToken").string(var_36.as_str());
}
if let Some(var_37) = &input.execution_role_arn {
object.key("ExecutionRoleArn").string(var_37.as_str());
}
if let Some(var_38) = &input.input_config {
#[allow(unused_mut)]
let mut object_39 = object.key("InputConfig").start_object();
crate::json_ser::serialize_structure_crate_model_vector_enrichment_job_input_config(
&mut object_39,
var_38,
)?;
object_39.finish();
}
if let Some(var_40) = &input.job_config {
#[allow(unused_mut)]
let mut object_41 = object.key("JobConfig").start_object();
crate::json_ser::serialize_union_crate_model_vector_enrichment_job_config(
&mut object_41,
var_40,
)?;
object_41.finish();
}
if let Some(var_42) = &input.kms_key_id {
object.key("KmsKeyId").string(var_42.as_str());
}
if let Some(var_43) = &input.name {
object.key("Name").string(var_43.as_str());
}
if let Some(var_44) = &input.tags {
#[allow(unused_mut)]
let mut object_45 = object.key("Tags").start_object();
for (key_46, value_47) in var_44 {
{
object_45.key(key_46.as_str()).string(value_47.as_str());
}
}
object_45.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_stop_earth_observation_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StopEarthObservationJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_48) = &input.arn {
object.key("Arn").string(var_48.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_stop_vector_enrichment_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StopVectorEnrichmentJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_49) = &input.arn {
object.key("Arn").string(var_49.as_str());
}
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_50) = &input.tags {
#[allow(unused_mut)]
let mut object_51 = object.key("Tags").start_object();
for (key_52, value_53) in var_50 {
{
object_51.key(key_52.as_str()).string(value_53.as_str());
}
}
object_51.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_output_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OutputConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_54) = &input.s3_data {
#[allow(unused_mut)]
let mut object_55 = object.key("S3Data").start_object();
crate::json_ser::serialize_structure_crate_model_export_s3_data_input(
&mut object_55,
var_54,
)?;
object_55.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_export_vector_enrichment_job_output_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ExportVectorEnrichmentJobOutputConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_56) = &input.s3_data {
#[allow(unused_mut)]
let mut object_57 = object.key("S3Data").start_object();
crate::json_ser::serialize_structure_crate_model_vector_enrichment_job_s3_data(
&mut object_57,
var_56,
)?;
object_57.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_raster_data_collection_query_with_band_filter_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RasterDataCollectionQueryWithBandFilterInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_58) = &input.time_range_filter {
#[allow(unused_mut)]
let mut object_59 = object.key("TimeRangeFilter").start_object();
crate::json_ser::serialize_structure_crate_model_time_range_filter_input(
&mut object_59,
var_58,
)?;
object_59.finish();
}
if let Some(var_60) = &input.area_of_interest {
#[allow(unused_mut)]
let mut object_61 = object.key("AreaOfInterest").start_object();
crate::json_ser::serialize_union_crate_model_area_of_interest(&mut object_61, var_60)?;
object_61.finish();
}
if let Some(var_62) = &input.property_filters {
#[allow(unused_mut)]
let mut object_63 = object.key("PropertyFilters").start_object();
crate::json_ser::serialize_structure_crate_model_property_filters(&mut object_63, var_62)?;
object_63.finish();
}
if let Some(var_64) = &input.band_filter {
let mut array_65 = object.key("BandFilter").start_array();
for item_66 in var_64 {
{
array_65.value().string(item_66.as_str());
}
}
array_65.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_input_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::InputConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_67) = &input.previous_earth_observation_job_arn {
object
.key("PreviousEarthObservationJobArn")
.string(var_67.as_str());
}
if let Some(var_68) = &input.data_source_config {
#[allow(unused_mut)]
let mut object_69 = object.key("DataSourceConfig").start_object();
crate::json_ser::serialize_union_crate_model_eoj_data_source_config_input(
&mut object_69,
var_68,
)?;
object_69.finish();
}
if let Some(var_70) = &input.raster_data_collection_query {
#[allow(unused_mut)]
let mut object_71 = object.key("RasterDataCollectionQuery").start_object();
crate::json_ser::serialize_structure_crate_model_raster_data_collection_query_input(
&mut object_71,
var_70,
)?;
object_71.finish();
}
Ok(())
}
pub fn serialize_union_crate_model_job_config_input(
object_29: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::JobConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
match input {
crate::model::JobConfigInput::BandMathConfig(inner) => {
#[allow(unused_mut)]
let mut object_72 = object_29.key("BandMathConfig").start_object();
crate::json_ser::serialize_structure_crate_model_band_math_config_input(
&mut object_72,
inner,
)?;
object_72.finish();
}
crate::model::JobConfigInput::ResamplingConfig(inner) => {
#[allow(unused_mut)]
let mut object_73 = object_29.key("ResamplingConfig").start_object();
crate::json_ser::serialize_structure_crate_model_resampling_config_input(
&mut object_73,
inner,
)?;
object_73.finish();
}
crate::model::JobConfigInput::TemporalStatisticsConfig(inner) => {
#[allow(unused_mut)]
let mut object_74 = object_29.key("TemporalStatisticsConfig").start_object();
crate::json_ser::serialize_structure_crate_model_temporal_statistics_config_input(
&mut object_74,
inner,
)?;
object_74.finish();
}
crate::model::JobConfigInput::CloudRemovalConfig(inner) => {
#[allow(unused_mut)]
let mut object_75 = object_29.key("CloudRemovalConfig").start_object();
crate::json_ser::serialize_structure_crate_model_cloud_removal_config_input(
&mut object_75,
inner,
)?;
object_75.finish();
}
crate::model::JobConfigInput::ZonalStatisticsConfig(inner) => {
#[allow(unused_mut)]
let mut object_76 = object_29.key("ZonalStatisticsConfig").start_object();
crate::json_ser::serialize_structure_crate_model_zonal_statistics_config_input(
&mut object_76,
inner,
)?;
object_76.finish();
}
crate::model::JobConfigInput::GeoMosaicConfig(inner) => {
#[allow(unused_mut)]
let mut object_77 = object_29.key("GeoMosaicConfig").start_object();
crate::json_ser::serialize_structure_crate_model_geo_mosaic_config_input(
&mut object_77,
inner,
)?;
object_77.finish();
}
crate::model::JobConfigInput::StackConfig(inner) => {
#[allow(unused_mut)]
let mut object_78 = object_29.key("StackConfig").start_object();
crate::json_ser::serialize_structure_crate_model_stack_config_input(
&mut object_78,
inner,
)?;
object_78.finish();
}
crate::model::JobConfigInput::CloudMaskingConfig(inner) => {
#[allow(unused_mut)]
let mut object_79 = object_29.key("CloudMaskingConfig").start_object();
crate::json_ser::serialize_structure_crate_model_cloud_masking_config_input(
&mut object_79,
inner,
)?;
object_79.finish();
}
crate::model::JobConfigInput::LandCoverSegmentationConfig(inner) => {
#[allow(unused_mut)]
let mut object_80 = object_29.key("LandCoverSegmentationConfig").start_object();
crate::json_ser::serialize_structure_crate_model_land_cover_segmentation_config_input(
&mut object_80,
inner,
)?;
object_80.finish();
}
crate::model::JobConfigInput::Unknown => {
return Err(
aws_smithy_http::operation::error::SerializationError::unknown_variant(
"JobConfigInput",
),
)
}
}
Ok(())
}
pub fn serialize_structure_crate_model_vector_enrichment_job_input_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::VectorEnrichmentJobInputConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_81) = &input.document_type {
object.key("DocumentType").string(var_81.as_str());
}
if let Some(var_82) = &input.data_source_config {
#[allow(unused_mut)]
let mut object_83 = object.key("DataSourceConfig").start_object();
crate::json_ser::serialize_union_crate_model_vector_enrichment_job_data_source_config_input(&mut object_83, var_82)?;
object_83.finish();
}
Ok(())
}
pub fn serialize_union_crate_model_vector_enrichment_job_config(
object_41: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::VectorEnrichmentJobConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
match input {
crate::model::VectorEnrichmentJobConfig::ReverseGeocodingConfig(inner) => {
#[allow(unused_mut)]
let mut object_84 = object_41.key("ReverseGeocodingConfig").start_object();
crate::json_ser::serialize_structure_crate_model_reverse_geocoding_config(
&mut object_84,
inner,
)?;
object_84.finish();
}
crate::model::VectorEnrichmentJobConfig::MapMatchingConfig(inner) => {
#[allow(unused_mut)]
let mut object_85 = object_41.key("MapMatchingConfig").start_object();
crate::json_ser::serialize_structure_crate_model_map_matching_config(
&mut object_85,
inner,
)?;
object_85.finish();
}
crate::model::VectorEnrichmentJobConfig::Unknown => {
return Err(
aws_smithy_http::operation::error::SerializationError::unknown_variant(
"VectorEnrichmentJobConfig",
),
)
}
}
Ok(())
}
pub fn serialize_structure_crate_model_export_s3_data_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ExportS3DataInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_86) = &input.s3_uri {
object.key("S3Uri").string(var_86.as_str());
}
if let Some(var_87) = &input.kms_key_id {
object.key("KmsKeyId").string(var_87.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_vector_enrichment_job_s3_data(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::VectorEnrichmentJobS3Data,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_88) = &input.s3_uri {
object.key("S3Uri").string(var_88.as_str());
}
if let Some(var_89) = &input.kms_key_id {
object.key("KmsKeyId").string(var_89.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_time_range_filter_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TimeRangeFilterInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_90) = &input.start_time {
object
.key("StartTime")
.date_time(var_90, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_91) = &input.end_time {
object
.key("EndTime")
.date_time(var_91, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
Ok(())
}
pub fn serialize_union_crate_model_area_of_interest(
object_61: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AreaOfInterest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
match input {
crate::model::AreaOfInterest::AreaOfInterestGeometry(inner) => {
#[allow(unused_mut)]
let mut object_92 = object_61.key("AreaOfInterestGeometry").start_object();
crate::json_ser::serialize_union_crate_model_area_of_interest_geometry(
&mut object_92,
inner,
)?;
object_92.finish();
}
crate::model::AreaOfInterest::Unknown => {
return Err(
aws_smithy_http::operation::error::SerializationError::unknown_variant(
"AreaOfInterest",
),
)
}
}
Ok(())
}
pub fn serialize_structure_crate_model_property_filters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PropertyFilters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_93) = &input.properties {
let mut array_94 = object.key("Properties").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_property_filter(
&mut object_96,
item_95,
)?;
object_96.finish();
}
}
array_94.finish();
}
if let Some(var_97) = &input.logical_operator {
object.key("LogicalOperator").string(var_97.as_str());
}
Ok(())
}
pub fn serialize_union_crate_model_eoj_data_source_config_input(
object_69: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EojDataSourceConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
match input {
crate::model::EojDataSourceConfigInput::S3Data(inner) => {
#[allow(unused_mut)]
let mut object_98 = object_69.key("S3Data").start_object();
crate::json_ser::serialize_structure_crate_model_s3_data_input(&mut object_98, inner)?;
object_98.finish();
}
crate::model::EojDataSourceConfigInput::Unknown => {
return Err(
aws_smithy_http::operation::error::SerializationError::unknown_variant(
"EojDataSourceConfigInput",
),
)
}
}
Ok(())
}
pub fn serialize_structure_crate_model_raster_data_collection_query_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RasterDataCollectionQueryInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_99) = &input.raster_data_collection_arn {
object
.key("RasterDataCollectionArn")
.string(var_99.as_str());
}
if let Some(var_100) = &input.time_range_filter {
#[allow(unused_mut)]
let mut object_101 = object.key("TimeRangeFilter").start_object();
crate::json_ser::serialize_structure_crate_model_time_range_filter_input(
&mut object_101,
var_100,
)?;
object_101.finish();
}
if let Some(var_102) = &input.area_of_interest {
#[allow(unused_mut)]
let mut object_103 = object.key("AreaOfInterest").start_object();
crate::json_ser::serialize_union_crate_model_area_of_interest(&mut object_103, var_102)?;
object_103.finish();
}
if let Some(var_104) = &input.property_filters {
#[allow(unused_mut)]
let mut object_105 = object.key("PropertyFilters").start_object();
crate::json_ser::serialize_structure_crate_model_property_filters(
&mut object_105,
var_104,
)?;
object_105.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_band_math_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BandMathConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_106) = &input.predefined_indices {
let mut array_107 = object.key("PredefinedIndices").start_array();
for item_108 in var_106 {
{
array_107.value().string(item_108.as_str());
}
}
array_107.finish();
}
if let Some(var_109) = &input.custom_indices {
#[allow(unused_mut)]
let mut object_110 = object.key("CustomIndices").start_object();
crate::json_ser::serialize_structure_crate_model_custom_indices_input(
&mut object_110,
var_109,
)?;
object_110.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_resampling_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ResamplingConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_111) = &input.output_resolution {
#[allow(unused_mut)]
let mut object_112 = object.key("OutputResolution").start_object();
crate::json_ser::serialize_structure_crate_model_output_resolution_resampling_input(
&mut object_112,
var_111,
)?;
object_112.finish();
}
if let Some(var_113) = &input.algorithm_name {
object.key("AlgorithmName").string(var_113.as_str());
}
if let Some(var_114) = &input.target_bands {
let mut array_115 = object.key("TargetBands").start_array();
for item_116 in var_114 {
{
array_115.value().string(item_116.as_str());
}
}
array_115.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_temporal_statistics_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TemporalStatisticsConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_117) = &input.group_by {
object.key("GroupBy").string(var_117.as_str());
}
if let Some(var_118) = &input.statistics {
let mut array_119 = object.key("Statistics").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.target_bands {
let mut array_122 = object.key("TargetBands").start_array();
for item_123 in var_121 {
{
array_122.value().string(item_123.as_str());
}
}
array_122.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_cloud_removal_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CloudRemovalConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_124) = &input.algorithm_name {
object.key("AlgorithmName").string(var_124.as_str());
}
if let Some(var_125) = &input.interpolation_value {
object.key("InterpolationValue").string(var_125.as_str());
}
if let Some(var_126) = &input.target_bands {
let mut array_127 = object.key("TargetBands").start_array();
for item_128 in var_126 {
{
array_127.value().string(item_128.as_str());
}
}
array_127.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_zonal_statistics_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ZonalStatisticsConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_129) = &input.zone_s3_path {
object.key("ZoneS3Path").string(var_129.as_str());
}
if let Some(var_130) = &input.statistics {
let mut array_131 = object.key("Statistics").start_array();
for item_132 in var_130 {
{
array_131.value().string(item_132.as_str());
}
}
array_131.finish();
}
if let Some(var_133) = &input.target_bands {
let mut array_134 = object.key("TargetBands").start_array();
for item_135 in var_133 {
{
array_134.value().string(item_135.as_str());
}
}
array_134.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_geo_mosaic_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GeoMosaicConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_136) = &input.algorithm_name {
object.key("AlgorithmName").string(var_136.as_str());
}
if let Some(var_137) = &input.target_bands {
let mut array_138 = object.key("TargetBands").start_array();
for item_139 in var_137 {
{
array_138.value().string(item_139.as_str());
}
}
array_138.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_stack_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StackConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_140) = &input.output_resolution {
#[allow(unused_mut)]
let mut object_141 = object.key("OutputResolution").start_object();
crate::json_ser::serialize_structure_crate_model_output_resolution_stack_input(
&mut object_141,
var_140,
)?;
object_141.finish();
}
if let Some(var_142) = &input.target_bands {
let mut array_143 = object.key("TargetBands").start_array();
for item_144 in var_142 {
{
array_143.value().string(item_144.as_str());
}
}
array_143.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_cloud_masking_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CloudMaskingConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
let (_, _) = (object, input);
Ok(())
}
pub fn serialize_structure_crate_model_land_cover_segmentation_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LandCoverSegmentationConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
let (_, _) = (object, input);
Ok(())
}
pub fn serialize_union_crate_model_vector_enrichment_job_data_source_config_input(
object_83: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::VectorEnrichmentJobDataSourceConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
match input {
crate::model::VectorEnrichmentJobDataSourceConfigInput::S3Data(inner) => {
#[allow(unused_mut)]
let mut object_145 = object_83.key("S3Data").start_object();
crate::json_ser::serialize_structure_crate_model_vector_enrichment_job_s3_data(
&mut object_145,
inner,
)?;
object_145.finish();
}
crate::model::VectorEnrichmentJobDataSourceConfigInput::Unknown => {
return Err(
aws_smithy_http::operation::error::SerializationError::unknown_variant(
"VectorEnrichmentJobDataSourceConfigInput",
),
)
}
}
Ok(())
}
pub fn serialize_structure_crate_model_reverse_geocoding_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ReverseGeocodingConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_146) = &input.y_attribute_name {
object.key("YAttributeName").string(var_146.as_str());
}
if let Some(var_147) = &input.x_attribute_name {
object.key("XAttributeName").string(var_147.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_map_matching_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MapMatchingConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_148) = &input.id_attribute_name {
object.key("IdAttributeName").string(var_148.as_str());
}
if let Some(var_149) = &input.y_attribute_name {
object.key("YAttributeName").string(var_149.as_str());
}
if let Some(var_150) = &input.x_attribute_name {
object.key("XAttributeName").string(var_150.as_str());
}
if let Some(var_151) = &input.timestamp_attribute_name {
object
.key("TimestampAttributeName")
.string(var_151.as_str());
}
Ok(())
}
pub fn serialize_union_crate_model_area_of_interest_geometry(
object_92: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AreaOfInterestGeometry,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
match input {
crate::model::AreaOfInterestGeometry::PolygonGeometry(inner) => {
#[allow(unused_mut)]
let mut object_152 = object_92.key("PolygonGeometry").start_object();
crate::json_ser::serialize_structure_crate_model_polygon_geometry_input(
&mut object_152,
inner,
)?;
object_152.finish();
}
crate::model::AreaOfInterestGeometry::MultiPolygonGeometry(inner) => {
#[allow(unused_mut)]
let mut object_153 = object_92.key("MultiPolygonGeometry").start_object();
crate::json_ser::serialize_structure_crate_model_multi_polygon_geometry_input(
&mut object_153,
inner,
)?;
object_153.finish();
}
crate::model::AreaOfInterestGeometry::Unknown => {
return Err(
aws_smithy_http::operation::error::SerializationError::unknown_variant(
"AreaOfInterestGeometry",
),
)
}
}
Ok(())
}
pub fn serialize_structure_crate_model_property_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PropertyFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_154) = &input.property {
#[allow(unused_mut)]
let mut object_155 = object.key("Property").start_object();
crate::json_ser::serialize_union_crate_model_property(&mut object_155, var_154)?;
object_155.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_s3_data_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::S3DataInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_156) = &input.s3_uri {
object.key("S3Uri").string(var_156.as_str());
}
if let Some(var_157) = &input.metadata_provider {
object.key("MetadataProvider").string(var_157.as_str());
}
if let Some(var_158) = &input.kms_key_id {
object.key("KmsKeyId").string(var_158.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_custom_indices_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CustomIndicesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_159) = &input.operations {
let mut array_160 = object.key("Operations").start_array();
for item_161 in var_159 {
{
#[allow(unused_mut)]
let mut object_162 = array_160.value().start_object();
crate::json_ser::serialize_structure_crate_model_operation(
&mut object_162,
item_161,
)?;
object_162.finish();
}
}
array_160.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_output_resolution_resampling_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OutputResolutionResamplingInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_163) = &input.user_defined {
#[allow(unused_mut)]
let mut object_164 = object.key("UserDefined").start_object();
crate::json_ser::serialize_structure_crate_model_user_defined(&mut object_164, var_163)?;
object_164.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_output_resolution_stack_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OutputResolutionStackInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_165) = &input.predefined {
object.key("Predefined").string(var_165.as_str());
}
if let Some(var_166) = &input.user_defined {
#[allow(unused_mut)]
let mut object_167 = object.key("UserDefined").start_object();
crate::json_ser::serialize_structure_crate_model_user_defined(&mut object_167, var_166)?;
object_167.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_polygon_geometry_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PolygonGeometryInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_168) = &input.coordinates {
let mut array_169 = object.key("Coordinates").start_array();
for item_170 in var_168 {
{
let mut array_171 = array_169.value().start_array();
for item_172 in item_170 {
{
let mut array_173 = array_171.value().start_array();
for item_174 in item_172 {
{
array_173.value().number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*item_174).into()),
);
}
}
array_173.finish();
}
}
array_171.finish();
}
}
array_169.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_multi_polygon_geometry_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MultiPolygonGeometryInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_175) = &input.coordinates {
let mut array_176 = object.key("Coordinates").start_array();
for item_177 in var_175 {
{
let mut array_178 = array_176.value().start_array();
for item_179 in item_177 {
{
let mut array_180 = array_178.value().start_array();
for item_181 in item_179 {
{
let mut array_182 = array_180.value().start_array();
for item_183 in item_181 {
{
array_182.value().number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*item_183).into()),
);
}
}
array_182.finish();
}
}
array_180.finish();
}
}
array_178.finish();
}
}
array_176.finish();
}
Ok(())
}
pub fn serialize_union_crate_model_property(
object_155: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Property,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
match input {
crate::model::Property::EoCloudCover(inner) => {
#[allow(unused_mut)]
let mut object_184 = object_155.key("EoCloudCover").start_object();
crate::json_ser::serialize_structure_crate_model_eo_cloud_cover_input(
&mut object_184,
inner,
)?;
object_184.finish();
}
crate::model::Property::ViewOffNadir(inner) => {
#[allow(unused_mut)]
let mut object_185 = object_155.key("ViewOffNadir").start_object();
crate::json_ser::serialize_structure_crate_model_view_off_nadir_input(
&mut object_185,
inner,
)?;
object_185.finish();
}
crate::model::Property::ViewSunAzimuth(inner) => {
#[allow(unused_mut)]
let mut object_186 = object_155.key("ViewSunAzimuth").start_object();
crate::json_ser::serialize_structure_crate_model_view_sun_azimuth_input(
&mut object_186,
inner,
)?;
object_186.finish();
}
crate::model::Property::ViewSunElevation(inner) => {
#[allow(unused_mut)]
let mut object_187 = object_155.key("ViewSunElevation").start_object();
crate::json_ser::serialize_structure_crate_model_view_sun_elevation_input(
&mut object_187,
inner,
)?;
object_187.finish();
}
crate::model::Property::Platform(inner) => {
#[allow(unused_mut)]
let mut object_188 = object_155.key("Platform").start_object();
crate::json_ser::serialize_structure_crate_model_platform_input(
&mut object_188,
inner,
)?;
object_188.finish();
}
crate::model::Property::LandsatCloudCoverLand(inner) => {
#[allow(unused_mut)]
let mut object_189 = object_155.key("LandsatCloudCoverLand").start_object();
crate::json_ser::serialize_structure_crate_model_landsat_cloud_cover_land_input(
&mut object_189,
inner,
)?;
object_189.finish();
}
crate::model::Property::Unknown => {
return Err(
aws_smithy_http::operation::error::SerializationError::unknown_variant("Property"),
)
}
}
Ok(())
}
pub fn serialize_structure_crate_model_operation(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Operation,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_190) = &input.name {
object.key("Name").string(var_190.as_str());
}
if let Some(var_191) = &input.equation {
object.key("Equation").string(var_191.as_str());
}
if let Some(var_192) = &input.output_type {
object.key("OutputType").string(var_192.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_user_defined(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UserDefined,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_193) = &input.value {
object.key("Value").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_193).into()),
);
}
if let Some(var_194) = &input.unit {
object.key("Unit").string(var_194.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_eo_cloud_cover_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EoCloudCoverInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_195) = &input.lower_bound {
object.key("LowerBound").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_195).into()),
);
}
if let Some(var_196) = &input.upper_bound {
object.key("UpperBound").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_196).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_view_off_nadir_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ViewOffNadirInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_197) = &input.lower_bound {
object.key("LowerBound").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_197).into()),
);
}
if let Some(var_198) = &input.upper_bound {
object.key("UpperBound").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_198).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_view_sun_azimuth_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ViewSunAzimuthInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_199) = &input.lower_bound {
object.key("LowerBound").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_199).into()),
);
}
if let Some(var_200) = &input.upper_bound {
object.key("UpperBound").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_200).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_view_sun_elevation_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ViewSunElevationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_201) = &input.lower_bound {
object.key("LowerBound").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_201).into()),
);
}
if let Some(var_202) = &input.upper_bound {
object.key("UpperBound").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_202).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_platform_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PlatformInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_203) = &input.value {
object.key("Value").string(var_203.as_str());
}
if let Some(var_204) = &input.comparison_operator {
object.key("ComparisonOperator").string(var_204.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_landsat_cloud_cover_land_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LandsatCloudCoverLandInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_205) = &input.lower_bound {
object.key("LowerBound").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_205).into()),
);
}
if let Some(var_206) = &input.upper_bound {
object.key("UpperBound").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_206).into()),
);
}
Ok(())
}