pub fn serialize_structure_crate_input_batch_delete_read_set_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchDeleteReadSetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.ids {
let mut array_2 = object.key("ids").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_annotation_store_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateAnnotationStoreInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_4) = &input.description {
object.key("description").string(var_4.as_str());
}
if let Some(var_5) = &input.name {
object.key("name").string(var_5.as_str());
}
if let Some(var_6) = &input.reference {
#[allow(unused_mut)]
let mut object_7 = object.key("reference").start_object();
crate::json_ser::serialize_union_crate_model_reference_item(&mut object_7, var_6)?;
object_7.finish();
}
if let Some(var_8) = &input.sse_config {
#[allow(unused_mut)]
let mut object_9 = object.key("sseConfig").start_object();
crate::json_ser::serialize_structure_crate_model_sse_config(&mut object_9, var_8)?;
object_9.finish();
}
if let Some(var_10) = &input.store_format {
object.key("storeFormat").string(var_10.as_str());
}
if let Some(var_11) = &input.store_options {
#[allow(unused_mut)]
let mut object_12 = object.key("storeOptions").start_object();
crate::json_ser::serialize_union_crate_model_store_options(&mut object_12, var_11)?;
object_12.finish();
}
if let Some(var_13) = &input.tags {
#[allow(unused_mut)]
let mut object_14 = object.key("tags").start_object();
for (key_15, value_16) in var_13 {
{
object_14.key(key_15.as_str()).string(value_16.as_str());
}
}
object_14.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_reference_store_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateReferenceStoreInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_17) = &input.client_token {
object.key("clientToken").string(var_17.as_str());
}
if let Some(var_18) = &input.description {
object.key("description").string(var_18.as_str());
}
if let Some(var_19) = &input.name {
object.key("name").string(var_19.as_str());
}
if let Some(var_20) = &input.sse_config {
#[allow(unused_mut)]
let mut object_21 = object.key("sseConfig").start_object();
crate::json_ser::serialize_structure_crate_model_sse_config(&mut object_21, var_20)?;
object_21.finish();
}
if let Some(var_22) = &input.tags {
#[allow(unused_mut)]
let mut object_23 = object.key("tags").start_object();
for (key_24, value_25) in var_22 {
{
object_23.key(key_24.as_str()).string(value_25.as_str());
}
}
object_23.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_run_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateRunGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_26) = &input.max_cpus {
object.key("maxCpus").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_26).into()),
);
}
if let Some(var_27) = &input.max_duration {
object.key("maxDuration").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_27).into()),
);
}
if let Some(var_28) = &input.max_runs {
object.key("maxRuns").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_28).into()),
);
}
if let Some(var_29) = &input.name {
object.key("name").string(var_29.as_str());
}
if let Some(var_30) = &input.request_id {
object.key("requestId").string(var_30.as_str());
}
if let Some(var_31) = &input.tags {
#[allow(unused_mut)]
let mut object_32 = object.key("tags").start_object();
for (key_33, value_34) in var_31 {
{
object_32.key(key_33.as_str()).string(value_34.as_str());
}
}
object_32.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_sequence_store_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateSequenceStoreInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_35) = &input.client_token {
object.key("clientToken").string(var_35.as_str());
}
if let Some(var_36) = &input.description {
object.key("description").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.sse_config {
#[allow(unused_mut)]
let mut object_39 = object.key("sseConfig").start_object();
crate::json_ser::serialize_structure_crate_model_sse_config(&mut object_39, var_38)?;
object_39.finish();
}
if let Some(var_40) = &input.tags {
#[allow(unused_mut)]
let mut object_41 = object.key("tags").start_object();
for (key_42, value_43) in var_40 {
{
object_41.key(key_42.as_str()).string(value_43.as_str());
}
}
object_41.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_variant_store_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateVariantStoreInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_44) = &input.description {
object.key("description").string(var_44.as_str());
}
if let Some(var_45) = &input.name {
object.key("name").string(var_45.as_str());
}
if let Some(var_46) = &input.reference {
#[allow(unused_mut)]
let mut object_47 = object.key("reference").start_object();
crate::json_ser::serialize_union_crate_model_reference_item(&mut object_47, var_46)?;
object_47.finish();
}
if let Some(var_48) = &input.sse_config {
#[allow(unused_mut)]
let mut object_49 = object.key("sseConfig").start_object();
crate::json_ser::serialize_structure_crate_model_sse_config(&mut object_49, var_48)?;
object_49.finish();
}
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_input_create_workflow_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateWorkflowInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_54) = &input.definition_uri {
object.key("definitionUri").string(var_54.as_str());
}
if let Some(var_55) = &input.definition_zip {
object
.key("definitionZip")
.string_unchecked(&aws_smithy_types::base64::encode(var_55));
}
if let Some(var_56) = &input.description {
object.key("description").string(var_56.as_str());
}
if let Some(var_57) = &input.engine {
object.key("engine").string(var_57.as_str());
}
if let Some(var_58) = &input.main {
object.key("main").string(var_58.as_str());
}
if let Some(var_59) = &input.name {
object.key("name").string(var_59.as_str());
}
if let Some(var_60) = &input.parameter_template {
#[allow(unused_mut)]
let mut object_61 = object.key("parameterTemplate").start_object();
for (key_62, value_63) in var_60 {
{
#[allow(unused_mut)]
let mut object_64 = object_61.key(key_62.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_workflow_parameter(
&mut object_64,
value_63,
)?;
object_64.finish();
}
}
object_61.finish();
}
if let Some(var_65) = &input.request_id {
object.key("requestId").string(var_65.as_str());
}
if let Some(var_66) = &input.storage_capacity {
object.key("storageCapacity").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_66).into()),
);
}
if let Some(var_67) = &input.tags {
#[allow(unused_mut)]
let mut object_68 = object.key("tags").start_object();
for (key_69, value_70) in var_67 {
{
object_68.key(key_69.as_str()).string(value_70.as_str());
}
}
object_68.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_annotation_import_jobs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListAnnotationImportJobsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_71) = &input.filter {
#[allow(unused_mut)]
let mut object_72 = object.key("filter").start_object();
crate::json_ser::serialize_structure_crate_model_list_annotation_import_jobs_filter(
&mut object_72,
var_71,
)?;
object_72.finish();
}
if let Some(var_73) = &input.ids {
let mut array_74 = object.key("ids").start_array();
for item_75 in var_73 {
{
array_74.value().string(item_75.as_str());
}
}
array_74.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_annotation_stores_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListAnnotationStoresInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_76) = &input.filter {
#[allow(unused_mut)]
let mut object_77 = object.key("filter").start_object();
crate::json_ser::serialize_structure_crate_model_list_annotation_stores_filter(
&mut object_77,
var_76,
)?;
object_77.finish();
}
if let Some(var_78) = &input.ids {
let mut array_79 = object.key("ids").start_array();
for item_80 in var_78 {
{
array_79.value().string(item_80.as_str());
}
}
array_79.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_read_set_activation_jobs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListReadSetActivationJobsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_81) = &input.filter {
#[allow(unused_mut)]
let mut object_82 = object.key("filter").start_object();
crate::json_ser::serialize_structure_crate_model_activate_read_set_filter(
&mut object_82,
var_81,
)?;
object_82.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_read_set_export_jobs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListReadSetExportJobsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_83) = &input.filter {
#[allow(unused_mut)]
let mut object_84 = object.key("filter").start_object();
crate::json_ser::serialize_structure_crate_model_export_read_set_filter(
&mut object_84,
var_83,
)?;
object_84.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_read_set_import_jobs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListReadSetImportJobsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_85) = &input.filter {
#[allow(unused_mut)]
let mut object_86 = object.key("filter").start_object();
crate::json_ser::serialize_structure_crate_model_import_read_set_filter(
&mut object_86,
var_85,
)?;
object_86.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_read_sets_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListReadSetsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_87) = &input.filter {
#[allow(unused_mut)]
let mut object_88 = object.key("filter").start_object();
crate::json_ser::serialize_structure_crate_model_read_set_filter(&mut object_88, var_87)?;
object_88.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_reference_import_jobs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListReferenceImportJobsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_89) = &input.filter {
#[allow(unused_mut)]
let mut object_90 = object.key("filter").start_object();
crate::json_ser::serialize_structure_crate_model_import_reference_filter(
&mut object_90,
var_89,
)?;
object_90.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_references_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListReferencesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_91) = &input.filter {
#[allow(unused_mut)]
let mut object_92 = object.key("filter").start_object();
crate::json_ser::serialize_structure_crate_model_reference_filter(&mut object_92, var_91)?;
object_92.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_reference_stores_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListReferenceStoresInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_93) = &input.filter {
#[allow(unused_mut)]
let mut object_94 = object.key("filter").start_object();
crate::json_ser::serialize_structure_crate_model_reference_store_filter(
&mut object_94,
var_93,
)?;
object_94.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_sequence_stores_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListSequenceStoresInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_95) = &input.filter {
#[allow(unused_mut)]
let mut object_96 = object.key("filter").start_object();
crate::json_ser::serialize_structure_crate_model_sequence_store_filter(
&mut object_96,
var_95,
)?;
object_96.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_variant_import_jobs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListVariantImportJobsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_97) = &input.filter {
#[allow(unused_mut)]
let mut object_98 = object.key("filter").start_object();
crate::json_ser::serialize_structure_crate_model_list_variant_import_jobs_filter(
&mut object_98,
var_97,
)?;
object_98.finish();
}
if let Some(var_99) = &input.ids {
let mut array_100 = object.key("ids").start_array();
for item_101 in var_99 {
{
array_100.value().string(item_101.as_str());
}
}
array_100.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_variant_stores_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListVariantStoresInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_102) = &input.filter {
#[allow(unused_mut)]
let mut object_103 = object.key("filter").start_object();
crate::json_ser::serialize_structure_crate_model_list_variant_stores_filter(
&mut object_103,
var_102,
)?;
object_103.finish();
}
if let Some(var_104) = &input.ids {
let mut array_105 = object.key("ids").start_array();
for item_106 in var_104 {
{
array_105.value().string(item_106.as_str());
}
}
array_105.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_start_annotation_import_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartAnnotationImportJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_107) = &input.destination_name {
object.key("destinationName").string(var_107.as_str());
}
if let Some(var_108) = &input.format_options {
#[allow(unused_mut)]
let mut object_109 = object.key("formatOptions").start_object();
crate::json_ser::serialize_union_crate_model_format_options(&mut object_109, var_108)?;
object_109.finish();
}
if let Some(var_110) = &input.items {
let mut array_111 = object.key("items").start_array();
for item_112 in var_110 {
{
#[allow(unused_mut)]
let mut object_113 = array_111.value().start_object();
crate::json_ser::serialize_structure_crate_model_annotation_import_item_source(
&mut object_113,
item_112,
)?;
object_113.finish();
}
}
array_111.finish();
}
if let Some(var_114) = &input.role_arn {
object.key("roleArn").string(var_114.as_str());
}
if let Some(var_115) = &input.run_left_normalization {
object.key("runLeftNormalization").boolean(*var_115);
}
Ok(())
}
pub fn serialize_structure_crate_input_start_read_set_activation_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartReadSetActivationJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_116) = &input.client_token {
object.key("clientToken").string(var_116.as_str());
}
if let Some(var_117) = &input.sources {
let mut array_118 = object.key("sources").start_array();
for item_119 in var_117 {
{
#[allow(unused_mut)]
let mut object_120 = array_118.value().start_object();
crate::json_ser::serialize_structure_crate_model_start_read_set_activation_job_source_item(&mut object_120, item_119)?;
object_120.finish();
}
}
array_118.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_start_read_set_export_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartReadSetExportJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_121) = &input.client_token {
object.key("clientToken").string(var_121.as_str());
}
if let Some(var_122) = &input.destination {
object.key("destination").string(var_122.as_str());
}
if let Some(var_123) = &input.role_arn {
object.key("roleArn").string(var_123.as_str());
}
if let Some(var_124) = &input.sources {
let mut array_125 = object.key("sources").start_array();
for item_126 in var_124 {
{
#[allow(unused_mut)]
let mut object_127 = array_125.value().start_object();
crate::json_ser::serialize_structure_crate_model_export_read_set(
&mut object_127,
item_126,
)?;
object_127.finish();
}
}
array_125.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_start_read_set_import_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartReadSetImportJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_128) = &input.client_token {
object.key("clientToken").string(var_128.as_str());
}
if let Some(var_129) = &input.role_arn {
object.key("roleArn").string(var_129.as_str());
}
if let Some(var_130) = &input.sources {
let mut array_131 = object.key("sources").start_array();
for item_132 in var_130 {
{
#[allow(unused_mut)]
let mut object_133 = array_131.value().start_object();
crate::json_ser::serialize_structure_crate_model_start_read_set_import_job_source_item(&mut object_133, item_132)?;
object_133.finish();
}
}
array_131.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_start_reference_import_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartReferenceImportJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_134) = &input.client_token {
object.key("clientToken").string(var_134.as_str());
}
if let Some(var_135) = &input.role_arn {
object.key("roleArn").string(var_135.as_str());
}
if let Some(var_136) = &input.sources {
let mut array_137 = object.key("sources").start_array();
for item_138 in var_136 {
{
#[allow(unused_mut)]
let mut object_139 = array_137.value().start_object();
crate::json_ser::serialize_structure_crate_model_start_reference_import_job_source_item(&mut object_139, item_138)?;
object_139.finish();
}
}
array_137.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_start_run_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartRunInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_140) = &input.log_level {
object.key("logLevel").string(var_140.as_str());
}
if let Some(var_141) = &input.name {
object.key("name").string(var_141.as_str());
}
if let Some(var_142) = &input.output_uri {
object.key("outputUri").string(var_142.as_str());
}
if let Some(var_143) = &input.parameters {
object.key("parameters").document(var_143);
}
if let Some(var_144) = &input.priority {
object.key("priority").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_144).into()),
);
}
if let Some(var_145) = &input.request_id {
object.key("requestId").string(var_145.as_str());
}
if let Some(var_146) = &input.role_arn {
object.key("roleArn").string(var_146.as_str());
}
if let Some(var_147) = &input.run_group_id {
object.key("runGroupId").string(var_147.as_str());
}
if let Some(var_148) = &input.run_id {
object.key("runId").string(var_148.as_str());
}
if let Some(var_149) = &input.storage_capacity {
object.key("storageCapacity").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_149).into()),
);
}
if let Some(var_150) = &input.tags {
#[allow(unused_mut)]
let mut object_151 = object.key("tags").start_object();
for (key_152, value_153) in var_150 {
{
object_151.key(key_152.as_str()).string(value_153.as_str());
}
}
object_151.finish();
}
if let Some(var_154) = &input.workflow_id {
object.key("workflowId").string(var_154.as_str());
}
if let Some(var_155) = &input.workflow_type {
object.key("workflowType").string(var_155.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_start_variant_import_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartVariantImportJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_156) = &input.destination_name {
object.key("destinationName").string(var_156.as_str());
}
if let Some(var_157) = &input.items {
let mut array_158 = object.key("items").start_array();
for item_159 in var_157 {
{
#[allow(unused_mut)]
let mut object_160 = array_158.value().start_object();
crate::json_ser::serialize_structure_crate_model_variant_import_item_source(
&mut object_160,
item_159,
)?;
object_160.finish();
}
}
array_158.finish();
}
if let Some(var_161) = &input.role_arn {
object.key("roleArn").string(var_161.as_str());
}
if let Some(var_162) = &input.run_left_normalization {
object.key("runLeftNormalization").boolean(*var_162);
}
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_163) = &input.tags {
#[allow(unused_mut)]
let mut object_164 = object.key("tags").start_object();
for (key_165, value_166) in var_163 {
{
object_164.key(key_165.as_str()).string(value_166.as_str());
}
}
object_164.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_annotation_store_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateAnnotationStoreInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_167) = &input.description {
object.key("description").string(var_167.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_run_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateRunGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_168) = &input.max_cpus {
object.key("maxCpus").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_168).into()),
);
}
if let Some(var_169) = &input.max_duration {
object.key("maxDuration").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_169).into()),
);
}
if let Some(var_170) = &input.max_runs {
object.key("maxRuns").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_170).into()),
);
}
if let Some(var_171) = &input.name {
object.key("name").string(var_171.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_variant_store_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateVariantStoreInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_172) = &input.description {
object.key("description").string(var_172.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_workflow_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateWorkflowInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_173) = &input.description {
object.key("description").string(var_173.as_str());
}
if let Some(var_174) = &input.name {
object.key("name").string(var_174.as_str());
}
Ok(())
}
pub fn serialize_union_crate_model_reference_item(
object_7: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ReferenceItem,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
match input {
crate::model::ReferenceItem::ReferenceArn(inner) => {
object_7.key("referenceArn").string(inner.as_str());
}
crate::model::ReferenceItem::Unknown => {
return Err(
aws_smithy_http::operation::error::SerializationError::unknown_variant(
"ReferenceItem",
),
)
}
}
Ok(())
}
pub fn serialize_structure_crate_model_sse_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SseConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_175) = &input.r#type {
object.key("type").string(var_175.as_str());
}
if let Some(var_176) = &input.key_arn {
object.key("keyArn").string(var_176.as_str());
}
Ok(())
}
pub fn serialize_union_crate_model_store_options(
object_12: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StoreOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
match input {
crate::model::StoreOptions::TsvStoreOptions(inner) => {
#[allow(unused_mut)]
let mut object_177 = object_12.key("tsvStoreOptions").start_object();
crate::json_ser::serialize_structure_crate_model_tsv_store_options(
&mut object_177,
inner,
)?;
object_177.finish();
}
crate::model::StoreOptions::Unknown => {
return Err(
aws_smithy_http::operation::error::SerializationError::unknown_variant(
"StoreOptions",
),
)
}
}
Ok(())
}
pub fn serialize_structure_crate_model_workflow_parameter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::WorkflowParameter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_178) = &input.description {
object.key("description").string(var_178.as_str());
}
if let Some(var_179) = &input.optional {
object.key("optional").boolean(*var_179);
}
Ok(())
}
pub fn serialize_structure_crate_model_list_annotation_import_jobs_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ListAnnotationImportJobsFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_180) = &input.status {
object.key("status").string(var_180.as_str());
}
if let Some(var_181) = &input.store_name {
object.key("storeName").string(var_181.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_list_annotation_stores_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ListAnnotationStoresFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_182) = &input.status {
object.key("status").string(var_182.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_activate_read_set_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ActivateReadSetFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_183) = &input.status {
object.key("status").string(var_183.as_str());
}
if let Some(var_184) = &input.created_after {
object
.key("createdAfter")
.date_time(var_184, aws_smithy_types::date_time::Format::DateTime)?;
}
if let Some(var_185) = &input.created_before {
object
.key("createdBefore")
.date_time(var_185, aws_smithy_types::date_time::Format::DateTime)?;
}
Ok(())
}
pub fn serialize_structure_crate_model_export_read_set_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ExportReadSetFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_186) = &input.status {
object.key("status").string(var_186.as_str());
}
if let Some(var_187) = &input.created_after {
object
.key("createdAfter")
.date_time(var_187, aws_smithy_types::date_time::Format::DateTime)?;
}
if let Some(var_188) = &input.created_before {
object
.key("createdBefore")
.date_time(var_188, aws_smithy_types::date_time::Format::DateTime)?;
}
Ok(())
}
pub fn serialize_structure_crate_model_import_read_set_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ImportReadSetFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_189) = &input.status {
object.key("status").string(var_189.as_str());
}
if let Some(var_190) = &input.created_after {
object
.key("createdAfter")
.date_time(var_190, aws_smithy_types::date_time::Format::DateTime)?;
}
if let Some(var_191) = &input.created_before {
object
.key("createdBefore")
.date_time(var_191, aws_smithy_types::date_time::Format::DateTime)?;
}
Ok(())
}
pub fn serialize_structure_crate_model_read_set_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ReadSetFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_192) = &input.name {
object.key("name").string(var_192.as_str());
}
if let Some(var_193) = &input.status {
object.key("status").string(var_193.as_str());
}
if let Some(var_194) = &input.reference_arn {
object.key("referenceArn").string(var_194.as_str());
}
if let Some(var_195) = &input.created_after {
object
.key("createdAfter")
.date_time(var_195, aws_smithy_types::date_time::Format::DateTime)?;
}
if let Some(var_196) = &input.created_before {
object
.key("createdBefore")
.date_time(var_196, aws_smithy_types::date_time::Format::DateTime)?;
}
Ok(())
}
pub fn serialize_structure_crate_model_import_reference_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ImportReferenceFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_197) = &input.status {
object.key("status").string(var_197.as_str());
}
if let Some(var_198) = &input.created_after {
object
.key("createdAfter")
.date_time(var_198, aws_smithy_types::date_time::Format::DateTime)?;
}
if let Some(var_199) = &input.created_before {
object
.key("createdBefore")
.date_time(var_199, aws_smithy_types::date_time::Format::DateTime)?;
}
Ok(())
}
pub fn serialize_structure_crate_model_reference_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ReferenceFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_200) = &input.name {
object.key("name").string(var_200.as_str());
}
if let Some(var_201) = &input.md5 {
object.key("md5").string(var_201.as_str());
}
if let Some(var_202) = &input.created_after {
object
.key("createdAfter")
.date_time(var_202, aws_smithy_types::date_time::Format::DateTime)?;
}
if let Some(var_203) = &input.created_before {
object
.key("createdBefore")
.date_time(var_203, aws_smithy_types::date_time::Format::DateTime)?;
}
Ok(())
}
pub fn serialize_structure_crate_model_reference_store_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ReferenceStoreFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_204) = &input.name {
object.key("name").string(var_204.as_str());
}
if let Some(var_205) = &input.created_after {
object
.key("createdAfter")
.date_time(var_205, aws_smithy_types::date_time::Format::DateTime)?;
}
if let Some(var_206) = &input.created_before {
object
.key("createdBefore")
.date_time(var_206, aws_smithy_types::date_time::Format::DateTime)?;
}
Ok(())
}
pub fn serialize_structure_crate_model_sequence_store_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SequenceStoreFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_207) = &input.name {
object.key("name").string(var_207.as_str());
}
if let Some(var_208) = &input.created_after {
object
.key("createdAfter")
.date_time(var_208, aws_smithy_types::date_time::Format::DateTime)?;
}
if let Some(var_209) = &input.created_before {
object
.key("createdBefore")
.date_time(var_209, aws_smithy_types::date_time::Format::DateTime)?;
}
Ok(())
}
pub fn serialize_structure_crate_model_list_variant_import_jobs_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ListVariantImportJobsFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_210) = &input.status {
object.key("status").string(var_210.as_str());
}
if let Some(var_211) = &input.store_name {
object.key("storeName").string(var_211.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_list_variant_stores_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ListVariantStoresFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_212) = &input.status {
object.key("status").string(var_212.as_str());
}
Ok(())
}
pub fn serialize_union_crate_model_format_options(
object_109: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FormatOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
match input {
crate::model::FormatOptions::TsvOptions(inner) => {
#[allow(unused_mut)]
let mut object_213 = object_109.key("tsvOptions").start_object();
crate::json_ser::serialize_structure_crate_model_tsv_options(&mut object_213, inner)?;
object_213.finish();
}
crate::model::FormatOptions::VcfOptions(inner) => {
#[allow(unused_mut)]
let mut object_214 = object_109.key("vcfOptions").start_object();
crate::json_ser::serialize_structure_crate_model_vcf_options(&mut object_214, inner)?;
object_214.finish();
}
crate::model::FormatOptions::Unknown => {
return Err(
aws_smithy_http::operation::error::SerializationError::unknown_variant(
"FormatOptions",
),
)
}
}
Ok(())
}
pub fn serialize_structure_crate_model_annotation_import_item_source(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AnnotationImportItemSource,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_215) = &input.source {
object.key("source").string(var_215.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_start_read_set_activation_job_source_item(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StartReadSetActivationJobSourceItem,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_216) = &input.read_set_id {
object.key("readSetId").string(var_216.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_export_read_set(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ExportReadSet,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_217) = &input.read_set_id {
object.key("readSetId").string(var_217.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_start_read_set_import_job_source_item(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StartReadSetImportJobSourceItem,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_218) = &input.source_files {
#[allow(unused_mut)]
let mut object_219 = object.key("sourceFiles").start_object();
crate::json_ser::serialize_structure_crate_model_source_files(&mut object_219, var_218)?;
object_219.finish();
}
if let Some(var_220) = &input.source_file_type {
object.key("sourceFileType").string(var_220.as_str());
}
if let Some(var_221) = &input.subject_id {
object.key("subjectId").string(var_221.as_str());
}
if let Some(var_222) = &input.sample_id {
object.key("sampleId").string(var_222.as_str());
}
if let Some(var_223) = &input.generated_from {
object.key("generatedFrom").string(var_223.as_str());
}
if let Some(var_224) = &input.reference_arn {
object.key("referenceArn").string(var_224.as_str());
}
if let Some(var_225) = &input.name {
object.key("name").string(var_225.as_str());
}
if let Some(var_226) = &input.description {
object.key("description").string(var_226.as_str());
}
if let Some(var_227) = &input.tags {
#[allow(unused_mut)]
let mut object_228 = object.key("tags").start_object();
for (key_229, value_230) in var_227 {
{
object_228.key(key_229.as_str()).string(value_230.as_str());
}
}
object_228.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_start_reference_import_job_source_item(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StartReferenceImportJobSourceItem,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_231) = &input.source_file {
object.key("sourceFile").string(var_231.as_str());
}
if let Some(var_232) = &input.name {
object.key("name").string(var_232.as_str());
}
if let Some(var_233) = &input.description {
object.key("description").string(var_233.as_str());
}
if let Some(var_234) = &input.tags {
#[allow(unused_mut)]
let mut object_235 = object.key("tags").start_object();
for (key_236, value_237) in var_234 {
{
object_235.key(key_236.as_str()).string(value_237.as_str());
}
}
object_235.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_variant_import_item_source(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::VariantImportItemSource,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_238) = &input.source {
object.key("source").string(var_238.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_tsv_store_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TsvStoreOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_239) = &input.annotation_type {
object.key("annotationType").string(var_239.as_str());
}
if let Some(var_240) = &input.format_to_header {
#[allow(unused_mut)]
let mut object_241 = object.key("formatToHeader").start_object();
for (key_242, value_243) in var_240 {
{
object_241.key(key_242.as_str()).string(value_243.as_str());
}
}
object_241.finish();
}
if let Some(var_244) = &input.schema {
let mut array_245 = object.key("schema").start_array();
for item_246 in var_244 {
{
#[allow(unused_mut)]
let mut object_247 = array_245.value().start_object();
for (key_248, value_249) in item_246 {
{
object_247.key(key_248.as_str()).string(value_249.as_str());
}
}
object_247.finish();
}
}
array_245.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_tsv_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TsvOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_250) = &input.read_options {
#[allow(unused_mut)]
let mut object_251 = object.key("readOptions").start_object();
crate::json_ser::serialize_structure_crate_model_read_options(&mut object_251, var_250)?;
object_251.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_vcf_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::VcfOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_252) = &input.ignore_qual_field {
object.key("ignoreQualField").boolean(*var_252);
}
if let Some(var_253) = &input.ignore_filter_field {
object.key("ignoreFilterField").boolean(*var_253);
}
Ok(())
}
pub fn serialize_structure_crate_model_source_files(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SourceFiles,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_254) = &input.source1 {
object.key("source1").string(var_254.as_str());
}
if let Some(var_255) = &input.source2 {
object.key("source2").string(var_255.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_read_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ReadOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_256) = &input.sep {
object.key("sep").string(var_256.as_str());
}
if let Some(var_257) = &input.encoding {
object.key("encoding").string(var_257.as_str());
}
if let Some(var_258) = &input.quote {
object.key("quote").string(var_258.as_str());
}
if input.quote_all {
object.key("quoteAll").boolean(input.quote_all);
}
if let Some(var_259) = &input.escape {
object.key("escape").string(var_259.as_str());
}
if input.escape_quotes {
object.key("escapeQuotes").boolean(input.escape_quotes);
}
if let Some(var_260) = &input.comment {
object.key("comment").string(var_260.as_str());
}
if input.header {
object.key("header").boolean(input.header);
}
if let Some(var_261) = &input.line_sep {
object.key("lineSep").string(var_261.as_str());
}
Ok(())
}