pub fn serialize_structure_crate_input_create_data_set_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateDataSetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.asset_type {
object.key("AssetType").string(var_1.as_str());
}
if let Some(var_2) = &input.description {
object.key("Description").string(var_2.as_str());
}
if let Some(var_3) = &input.name {
object.key("Name").string(var_3.as_str());
}
if let Some(var_4) = &input.tags {
#[allow(unused_mut)]
let mut object_5 = object.key("Tags").start_object();
for (key_6, value_7) in var_4 {
{
object_5.key(key_6.as_str()).string(value_7.as_str());
}
}
object_5.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_event_action_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateEventActionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_8) = &input.action {
#[allow(unused_mut)]
let mut object_9 = object.key("Action").start_object();
crate::json_ser::serialize_structure_crate_model_action(&mut object_9, var_8)?;
object_9.finish();
}
if let Some(var_10) = &input.event {
#[allow(unused_mut)]
let mut object_11 = object.key("Event").start_object();
crate::json_ser::serialize_structure_crate_model_event(&mut object_11, var_10)?;
object_11.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_job_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateJobInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_12) = &input.details {
#[allow(unused_mut)]
let mut object_13 = object.key("Details").start_object();
crate::json_ser::serialize_structure_crate_model_request_details(&mut object_13, var_12)?;
object_13.finish();
}
if let Some(var_14) = &input.r#type {
object.key("Type").string(var_14.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_revision_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateRevisionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_15) = &input.comment {
object.key("Comment").string(var_15.as_str());
}
if let Some(var_16) = &input.tags {
#[allow(unused_mut)]
let mut object_17 = object.key("Tags").start_object();
for (key_18, value_19) in var_16 {
{
object_17.key(key_18.as_str()).string(value_19.as_str());
}
}
object_17.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_revoke_revision_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RevokeRevisionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_20) = &input.revocation_comment {
object.key("RevocationComment").string(var_20.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_21) = &input.tags {
#[allow(unused_mut)]
let mut object_22 = object.key("tags").start_object();
for (key_23, value_24) in var_21 {
{
object_22.key(key_23.as_str()).string(value_24.as_str());
}
}
object_22.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_asset_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateAssetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_25) = &input.name {
object.key("Name").string(var_25.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_data_set_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateDataSetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_26) = &input.description {
object.key("Description").string(var_26.as_str());
}
if let Some(var_27) = &input.name {
object.key("Name").string(var_27.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_event_action_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateEventActionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_28) = &input.action {
#[allow(unused_mut)]
let mut object_29 = object.key("Action").start_object();
crate::json_ser::serialize_structure_crate_model_action(&mut object_29, var_28)?;
object_29.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_revision_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateRevisionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_30) = &input.comment {
object.key("Comment").string(var_30.as_str());
}
if input.finalized {
object.key("Finalized").boolean(input.finalized);
}
Ok(())
}
pub fn serialize_structure_crate_model_action(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Action,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_31) = &input.export_revision_to_s3 {
#[allow(unused_mut)]
let mut object_32 = object.key("ExportRevisionToS3").start_object();
crate::json_ser::serialize_structure_crate_model_auto_export_revision_to_s3_request_details(&mut object_32, var_31)?;
object_32.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_event(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Event,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_33) = &input.revision_published {
#[allow(unused_mut)]
let mut object_34 = object.key("RevisionPublished").start_object();
crate::json_ser::serialize_structure_crate_model_revision_published(
&mut object_34,
var_33,
)?;
object_34.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_request_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RequestDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_35) = &input.export_asset_to_signed_url {
#[allow(unused_mut)]
let mut object_36 = object.key("ExportAssetToSignedUrl").start_object();
crate::json_ser::serialize_structure_crate_model_export_asset_to_signed_url_request_details(&mut object_36, var_35)?;
object_36.finish();
}
if let Some(var_37) = &input.export_assets_to_s3 {
#[allow(unused_mut)]
let mut object_38 = object.key("ExportAssetsToS3").start_object();
crate::json_ser::serialize_structure_crate_model_export_assets_to_s3_request_details(
&mut object_38,
var_37,
)?;
object_38.finish();
}
if let Some(var_39) = &input.export_revisions_to_s3 {
#[allow(unused_mut)]
let mut object_40 = object.key("ExportRevisionsToS3").start_object();
crate::json_ser::serialize_structure_crate_model_export_revisions_to_s3_request_details(
&mut object_40,
var_39,
)?;
object_40.finish();
}
if let Some(var_41) = &input.import_asset_from_signed_url {
#[allow(unused_mut)]
let mut object_42 = object.key("ImportAssetFromSignedUrl").start_object();
crate::json_ser::serialize_structure_crate_model_import_asset_from_signed_url_request_details(&mut object_42, var_41)?;
object_42.finish();
}
if let Some(var_43) = &input.import_assets_from_s3 {
#[allow(unused_mut)]
let mut object_44 = object.key("ImportAssetsFromS3").start_object();
crate::json_ser::serialize_structure_crate_model_import_assets_from_s3_request_details(
&mut object_44,
var_43,
)?;
object_44.finish();
}
if let Some(var_45) = &input.import_assets_from_redshift_data_shares {
#[allow(unused_mut)]
let mut object_46 = object
.key("ImportAssetsFromRedshiftDataShares")
.start_object();
crate::json_ser::serialize_structure_crate_model_import_assets_from_redshift_data_shares_request_details(&mut object_46, var_45)?;
object_46.finish();
}
if let Some(var_47) = &input.import_asset_from_api_gateway_api {
#[allow(unused_mut)]
let mut object_48 = object.key("ImportAssetFromApiGatewayApi").start_object();
crate::json_ser::serialize_structure_crate_model_import_asset_from_api_gateway_api_request_details(&mut object_48, var_47)?;
object_48.finish();
}
if let Some(var_49) = &input.create_s3_data_access_from_s3_bucket {
#[allow(unused_mut)]
let mut object_50 = object.key("CreateS3DataAccessFromS3Bucket").start_object();
crate::json_ser::serialize_structure_crate_model_create_s3_data_access_from_s3_bucket_request_details(&mut object_50, var_49)?;
object_50.finish();
}
if let Some(var_51) = &input.import_assets_from_lake_formation_tag_policy {
#[allow(unused_mut)]
let mut object_52 = object
.key("ImportAssetsFromLakeFormationTagPolicy")
.start_object();
crate::json_ser::serialize_structure_crate_model_import_assets_from_lake_formation_tag_policy_request_details(&mut object_52, var_51)?;
object_52.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_auto_export_revision_to_s3_request_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AutoExportRevisionToS3RequestDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_53) = &input.encryption {
#[allow(unused_mut)]
let mut object_54 = object.key("Encryption").start_object();
crate::json_ser::serialize_structure_crate_model_export_server_side_encryption(
&mut object_54,
var_53,
)?;
object_54.finish();
}
if let Some(var_55) = &input.revision_destination {
#[allow(unused_mut)]
let mut object_56 = object.key("RevisionDestination").start_object();
crate::json_ser::serialize_structure_crate_model_auto_export_revision_destination_entry(
&mut object_56,
var_55,
)?;
object_56.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_revision_published(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RevisionPublished,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_57) = &input.data_set_id {
object.key("DataSetId").string(var_57.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_export_asset_to_signed_url_request_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ExportAssetToSignedUrlRequestDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_58) = &input.asset_id {
object.key("AssetId").string(var_58.as_str());
}
if let Some(var_59) = &input.data_set_id {
object.key("DataSetId").string(var_59.as_str());
}
if let Some(var_60) = &input.revision_id {
object.key("RevisionId").string(var_60.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_export_assets_to_s3_request_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ExportAssetsToS3RequestDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_61) = &input.asset_destinations {
let mut array_62 = object.key("AssetDestinations").start_array();
for item_63 in var_61 {
{
#[allow(unused_mut)]
let mut object_64 = array_62.value().start_object();
crate::json_ser::serialize_structure_crate_model_asset_destination_entry(
&mut object_64,
item_63,
)?;
object_64.finish();
}
}
array_62.finish();
}
if let Some(var_65) = &input.data_set_id {
object.key("DataSetId").string(var_65.as_str());
}
if let Some(var_66) = &input.encryption {
#[allow(unused_mut)]
let mut object_67 = object.key("Encryption").start_object();
crate::json_ser::serialize_structure_crate_model_export_server_side_encryption(
&mut object_67,
var_66,
)?;
object_67.finish();
}
if let Some(var_68) = &input.revision_id {
object.key("RevisionId").string(var_68.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_export_revisions_to_s3_request_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ExportRevisionsToS3RequestDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_69) = &input.data_set_id {
object.key("DataSetId").string(var_69.as_str());
}
if let Some(var_70) = &input.encryption {
#[allow(unused_mut)]
let mut object_71 = object.key("Encryption").start_object();
crate::json_ser::serialize_structure_crate_model_export_server_side_encryption(
&mut object_71,
var_70,
)?;
object_71.finish();
}
if let Some(var_72) = &input.revision_destinations {
let mut array_73 = object.key("RevisionDestinations").start_array();
for item_74 in var_72 {
{
#[allow(unused_mut)]
let mut object_75 = array_73.value().start_object();
crate::json_ser::serialize_structure_crate_model_revision_destination_entry(
&mut object_75,
item_74,
)?;
object_75.finish();
}
}
array_73.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_import_asset_from_signed_url_request_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ImportAssetFromSignedUrlRequestDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_76) = &input.asset_name {
object.key("AssetName").string(var_76.as_str());
}
if let Some(var_77) = &input.data_set_id {
object.key("DataSetId").string(var_77.as_str());
}
if let Some(var_78) = &input.md5_hash {
object.key("Md5Hash").string(var_78.as_str());
}
if let Some(var_79) = &input.revision_id {
object.key("RevisionId").string(var_79.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_import_assets_from_s3_request_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ImportAssetsFromS3RequestDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_80) = &input.asset_sources {
let mut array_81 = object.key("AssetSources").start_array();
for item_82 in var_80 {
{
#[allow(unused_mut)]
let mut object_83 = array_81.value().start_object();
crate::json_ser::serialize_structure_crate_model_asset_source_entry(
&mut object_83,
item_82,
)?;
object_83.finish();
}
}
array_81.finish();
}
if let Some(var_84) = &input.data_set_id {
object.key("DataSetId").string(var_84.as_str());
}
if let Some(var_85) = &input.revision_id {
object.key("RevisionId").string(var_85.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_import_assets_from_redshift_data_shares_request_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ImportAssetsFromRedshiftDataSharesRequestDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_86) = &input.asset_sources {
let mut array_87 = object.key("AssetSources").start_array();
for item_88 in var_86 {
{
#[allow(unused_mut)]
let mut object_89 = array_87.value().start_object();
crate::json_ser::serialize_structure_crate_model_redshift_data_share_asset_source_entry(&mut object_89, item_88)?;
object_89.finish();
}
}
array_87.finish();
}
if let Some(var_90) = &input.data_set_id {
object.key("DataSetId").string(var_90.as_str());
}
if let Some(var_91) = &input.revision_id {
object.key("RevisionId").string(var_91.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_import_asset_from_api_gateway_api_request_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ImportAssetFromApiGatewayApiRequestDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_92) = &input.api_description {
object.key("ApiDescription").string(var_92.as_str());
}
if let Some(var_93) = &input.api_id {
object.key("ApiId").string(var_93.as_str());
}
if let Some(var_94) = &input.api_key {
object.key("ApiKey").string(var_94.as_str());
}
if let Some(var_95) = &input.api_name {
object.key("ApiName").string(var_95.as_str());
}
if let Some(var_96) = &input.api_specification_md5_hash {
object
.key("ApiSpecificationMd5Hash")
.string(var_96.as_str());
}
if let Some(var_97) = &input.data_set_id {
object.key("DataSetId").string(var_97.as_str());
}
if let Some(var_98) = &input.protocol_type {
object.key("ProtocolType").string(var_98.as_str());
}
if let Some(var_99) = &input.revision_id {
object.key("RevisionId").string(var_99.as_str());
}
if let Some(var_100) = &input.stage {
object.key("Stage").string(var_100.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_create_s3_data_access_from_s3_bucket_request_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CreateS3DataAccessFromS3BucketRequestDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_101) = &input.asset_source {
#[allow(unused_mut)]
let mut object_102 = object.key("AssetSource").start_object();
crate::json_ser::serialize_structure_crate_model_s3_data_access_asset_source_entry(
&mut object_102,
var_101,
)?;
object_102.finish();
}
if let Some(var_103) = &input.data_set_id {
object.key("DataSetId").string(var_103.as_str());
}
if let Some(var_104) = &input.revision_id {
object.key("RevisionId").string(var_104.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_import_assets_from_lake_formation_tag_policy_request_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ImportAssetsFromLakeFormationTagPolicyRequestDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_105) = &input.catalog_id {
object.key("CatalogId").string(var_105.as_str());
}
if let Some(var_106) = &input.database {
#[allow(unused_mut)]
let mut object_107 = object.key("Database").start_object();
crate::json_ser::serialize_structure_crate_model_database_lf_tag_policy_and_permissions(
&mut object_107,
var_106,
)?;
object_107.finish();
}
if let Some(var_108) = &input.table {
#[allow(unused_mut)]
let mut object_109 = object.key("Table").start_object();
crate::json_ser::serialize_structure_crate_model_table_lf_tag_policy_and_permissions(
&mut object_109,
var_108,
)?;
object_109.finish();
}
if let Some(var_110) = &input.role_arn {
object.key("RoleArn").string(var_110.as_str());
}
if let Some(var_111) = &input.data_set_id {
object.key("DataSetId").string(var_111.as_str());
}
if let Some(var_112) = &input.revision_id {
object.key("RevisionId").string(var_112.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_export_server_side_encryption(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ExportServerSideEncryption,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_113) = &input.kms_key_arn {
object.key("KmsKeyArn").string(var_113.as_str());
}
if let Some(var_114) = &input.r#type {
object.key("Type").string(var_114.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_auto_export_revision_destination_entry(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AutoExportRevisionDestinationEntry,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_115) = &input.bucket {
object.key("Bucket").string(var_115.as_str());
}
if let Some(var_116) = &input.key_pattern {
object.key("KeyPattern").string(var_116.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_asset_destination_entry(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AssetDestinationEntry,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_117) = &input.asset_id {
object.key("AssetId").string(var_117.as_str());
}
if let Some(var_118) = &input.bucket {
object.key("Bucket").string(var_118.as_str());
}
if let Some(var_119) = &input.key {
object.key("Key").string(var_119.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_revision_destination_entry(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RevisionDestinationEntry,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_120) = &input.bucket {
object.key("Bucket").string(var_120.as_str());
}
if let Some(var_121) = &input.key_pattern {
object.key("KeyPattern").string(var_121.as_str());
}
if let Some(var_122) = &input.revision_id {
object.key("RevisionId").string(var_122.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_asset_source_entry(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AssetSourceEntry,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_123) = &input.bucket {
object.key("Bucket").string(var_123.as_str());
}
if let Some(var_124) = &input.key {
object.key("Key").string(var_124.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_redshift_data_share_asset_source_entry(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RedshiftDataShareAssetSourceEntry,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_125) = &input.data_share_arn {
object.key("DataShareArn").string(var_125.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_s3_data_access_asset_source_entry(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::S3DataAccessAssetSourceEntry,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_126) = &input.bucket {
object.key("Bucket").string(var_126.as_str());
}
if let Some(var_127) = &input.key_prefixes {
let mut array_128 = object.key("KeyPrefixes").start_array();
for item_129 in var_127 {
{
array_128.value().string(item_129.as_str());
}
}
array_128.finish();
}
if let Some(var_130) = &input.keys {
let mut array_131 = object.key("Keys").start_array();
for item_132 in var_130 {
{
array_131.value().string(item_132.as_str());
}
}
array_131.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_database_lf_tag_policy_and_permissions(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DatabaseLfTagPolicyAndPermissions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_133) = &input.expression {
let mut array_134 = object.key("Expression").start_array();
for item_135 in var_133 {
{
#[allow(unused_mut)]
let mut object_136 = array_134.value().start_object();
crate::json_ser::serialize_structure_crate_model_lf_tag(&mut object_136, item_135)?;
object_136.finish();
}
}
array_134.finish();
}
if let Some(var_137) = &input.permissions {
let mut array_138 = object.key("Permissions").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_table_lf_tag_policy_and_permissions(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TableLfTagPolicyAndPermissions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_140) = &input.expression {
let mut array_141 = object.key("Expression").start_array();
for item_142 in var_140 {
{
#[allow(unused_mut)]
let mut object_143 = array_141.value().start_object();
crate::json_ser::serialize_structure_crate_model_lf_tag(&mut object_143, item_142)?;
object_143.finish();
}
}
array_141.finish();
}
if let Some(var_144) = &input.permissions {
let mut array_145 = object.key("Permissions").start_array();
for item_146 in var_144 {
{
array_145.value().string(item_146.as_str());
}
}
array_145.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_lf_tag(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LfTag,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_147) = &input.tag_key {
object.key("TagKey").string(var_147.as_str());
}
if let Some(var_148) = &input.tag_values {
let mut array_149 = object.key("TagValues").start_array();
for item_150 in var_148 {
{
array_149.value().string(item_150.as_str());
}
}
array_149.finish();
}
Ok(())
}