pub fn serialize_structure_crate_input_apply_archive_rule_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ApplyArchiveRuleInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_1) = &input.analyzer_arn {
object.key("analyzerArn").string(var_1);
}
if let Some(var_2) = &input.client_token {
object.key("clientToken").string(var_2);
}
if let Some(var_3) = &input.rule_name {
object.key("ruleName").string(var_3);
}
Ok(())
}
pub fn serialize_structure_crate_input_create_access_preview_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateAccessPreviewInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_4) = &input.analyzer_arn {
object.key("analyzerArn").string(var_4);
}
if let Some(var_5) = &input.client_token {
object.key("clientToken").string(var_5);
}
if let Some(var_6) = &input.configurations {
let mut object_7 = object.key("configurations").start_object();
for (key_8, value_9) in var_6 {
{
let mut object_10 = object_7.key(key_8).start_object();
crate::json_ser::serialize_union_crate_model_configuration(
&mut object_10,
value_9,
)?;
object_10.finish();
}
}
object_7.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_analyzer_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateAnalyzerInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_11) = &input.analyzer_name {
object.key("analyzerName").string(var_11);
}
if let Some(var_12) = &input.archive_rules {
let mut array_13 = object.key("archiveRules").start_array();
for item_14 in var_12 {
{
let mut object_15 = array_13.value().start_object();
crate::json_ser::serialize_structure_crate_model_inline_archive_rule(
&mut object_15,
item_14,
)?;
object_15.finish();
}
}
array_13.finish();
}
if let Some(var_16) = &input.client_token {
object.key("clientToken").string(var_16);
}
if let Some(var_17) = &input.tags {
let mut object_18 = object.key("tags").start_object();
for (key_19, value_20) in var_17 {
{
object_18.key(key_19).string(value_20);
}
}
object_18.finish();
}
if let Some(var_21) = &input.r#type {
object.key("type").string(var_21.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_archive_rule_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateArchiveRuleInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_22) = &input.client_token {
object.key("clientToken").string(var_22);
}
if let Some(var_23) = &input.filter {
let mut object_24 = object.key("filter").start_object();
for (key_25, value_26) in var_23 {
{
let mut object_27 = object_24.key(key_25).start_object();
crate::json_ser::serialize_structure_crate_model_criterion(
&mut object_27,
value_26,
)?;
object_27.finish();
}
}
object_24.finish();
}
if let Some(var_28) = &input.rule_name {
object.key("ruleName").string(var_28);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_access_preview_findings_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListAccessPreviewFindingsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_29) = &input.analyzer_arn {
object.key("analyzerArn").string(var_29);
}
if let Some(var_30) = &input.filter {
let mut object_31 = object.key("filter").start_object();
for (key_32, value_33) in var_30 {
{
let mut object_34 = object_31.key(key_32).start_object();
crate::json_ser::serialize_structure_crate_model_criterion(
&mut object_34,
value_33,
)?;
object_34.finish();
}
}
object_31.finish();
}
if let Some(var_35) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_35).into()),
);
}
if let Some(var_36) = &input.next_token {
object.key("nextToken").string(var_36);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_analyzed_resources_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListAnalyzedResourcesInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_37) = &input.analyzer_arn {
object.key("analyzerArn").string(var_37);
}
if let Some(var_38) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_38).into()),
);
}
if let Some(var_39) = &input.next_token {
object.key("nextToken").string(var_39);
}
if let Some(var_40) = &input.resource_type {
object.key("resourceType").string(var_40.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_findings_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListFindingsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_41) = &input.analyzer_arn {
object.key("analyzerArn").string(var_41);
}
if let Some(var_42) = &input.filter {
let mut object_43 = object.key("filter").start_object();
for (key_44, value_45) in var_42 {
{
let mut object_46 = object_43.key(key_44).start_object();
crate::json_ser::serialize_structure_crate_model_criterion(
&mut object_46,
value_45,
)?;
object_46.finish();
}
}
object_43.finish();
}
if let Some(var_47) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_47).into()),
);
}
if let Some(var_48) = &input.next_token {
object.key("nextToken").string(var_48);
}
if let Some(var_49) = &input.sort {
let mut object_50 = object.key("sort").start_object();
crate::json_ser::serialize_structure_crate_model_sort_criteria(&mut object_50, var_49)?;
object_50.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_start_policy_generation_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartPolicyGenerationInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_51) = &input.client_token {
object.key("clientToken").string(var_51);
}
if let Some(var_52) = &input.cloud_trail_details {
let mut object_53 = object.key("cloudTrailDetails").start_object();
crate::json_ser::serialize_structure_crate_model_cloud_trail_details(
&mut object_53,
var_52,
)?;
object_53.finish();
}
if let Some(var_54) = &input.policy_generation_details {
let mut object_55 = object.key("policyGenerationDetails").start_object();
crate::json_ser::serialize_structure_crate_model_policy_generation_details(
&mut object_55,
var_54,
)?;
object_55.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_start_resource_scan_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartResourceScanInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_56) = &input.analyzer_arn {
object.key("analyzerArn").string(var_56);
}
if let Some(var_57) = &input.resource_arn {
object.key("resourceArn").string(var_57);
}
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::SerializationError> {
if let Some(var_58) = &input.tags {
let mut object_59 = object.key("tags").start_object();
for (key_60, value_61) in var_58 {
{
object_59.key(key_60).string(value_61);
}
}
object_59.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_archive_rule_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateArchiveRuleInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_62) = &input.client_token {
object.key("clientToken").string(var_62);
}
if let Some(var_63) = &input.filter {
let mut object_64 = object.key("filter").start_object();
for (key_65, value_66) in var_63 {
{
let mut object_67 = object_64.key(key_65).start_object();
crate::json_ser::serialize_structure_crate_model_criterion(
&mut object_67,
value_66,
)?;
object_67.finish();
}
}
object_64.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_findings_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateFindingsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_68) = &input.analyzer_arn {
object.key("analyzerArn").string(var_68);
}
if let Some(var_69) = &input.client_token {
object.key("clientToken").string(var_69);
}
if let Some(var_70) = &input.ids {
let mut array_71 = object.key("ids").start_array();
for item_72 in var_70 {
{
array_71.value().string(item_72);
}
}
array_71.finish();
}
if let Some(var_73) = &input.resource_arn {
object.key("resourceArn").string(var_73);
}
if let Some(var_74) = &input.status {
object.key("status").string(var_74.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_validate_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ValidatePolicyInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_75) = &input.locale {
object.key("locale").string(var_75.as_str());
}
if let Some(var_76) = &input.policy_document {
object.key("policyDocument").string(var_76);
}
if let Some(var_77) = &input.policy_type {
object.key("policyType").string(var_77.as_str());
}
if let Some(var_78) = &input.validate_policy_resource_type {
object
.key("validatePolicyResourceType")
.string(var_78.as_str());
}
Ok(())
}
pub fn serialize_union_crate_model_configuration(
object_10: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Configuration,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
match input {
crate::model::Configuration::IamRole(inner) => {
let mut object_79 = object_10.key("iamRole").start_object();
crate::json_ser::serialize_structure_crate_model_iam_role_configuration(
&mut object_79,
inner,
)?;
object_79.finish();
}
crate::model::Configuration::KmsKey(inner) => {
let mut object_80 = object_10.key("kmsKey").start_object();
crate::json_ser::serialize_structure_crate_model_kms_key_configuration(
&mut object_80,
inner,
)?;
object_80.finish();
}
crate::model::Configuration::SecretsManagerSecret(inner) => {
let mut object_81 = object_10.key("secretsManagerSecret").start_object();
crate::json_ser::serialize_structure_crate_model_secrets_manager_secret_configuration(
&mut object_81,
inner,
)?;
object_81.finish();
}
crate::model::Configuration::S3Bucket(inner) => {
let mut object_82 = object_10.key("s3Bucket").start_object();
crate::json_ser::serialize_structure_crate_model_s3_bucket_configuration(
&mut object_82,
inner,
)?;
object_82.finish();
}
crate::model::Configuration::SqsQueue(inner) => {
let mut object_83 = object_10.key("sqsQueue").start_object();
crate::json_ser::serialize_structure_crate_model_sqs_queue_configuration(
&mut object_83,
inner,
)?;
object_83.finish();
}
crate::model::Configuration::Unknown => {
return Err(
aws_smithy_http::operation::SerializationError::unknown_variant("Configuration"),
)
}
}
Ok(())
}
pub fn serialize_structure_crate_model_inline_archive_rule(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::InlineArchiveRule,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_84) = &input.rule_name {
object.key("ruleName").string(var_84);
}
if let Some(var_85) = &input.filter {
let mut object_86 = object.key("filter").start_object();
for (key_87, value_88) in var_85 {
{
let mut object_89 = object_86.key(key_87).start_object();
crate::json_ser::serialize_structure_crate_model_criterion(
&mut object_89,
value_88,
)?;
object_89.finish();
}
}
object_86.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_criterion(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Criterion,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_90) = &input.eq {
let mut array_91 = object.key("eq").start_array();
for item_92 in var_90 {
{
array_91.value().string(item_92);
}
}
array_91.finish();
}
if let Some(var_93) = &input.neq {
let mut array_94 = object.key("neq").start_array();
for item_95 in var_93 {
{
array_94.value().string(item_95);
}
}
array_94.finish();
}
if let Some(var_96) = &input.contains {
let mut array_97 = object.key("contains").start_array();
for item_98 in var_96 {
{
array_97.value().string(item_98);
}
}
array_97.finish();
}
if let Some(var_99) = &input.exists {
object.key("exists").boolean(*var_99);
}
Ok(())
}
pub fn serialize_structure_crate_model_sort_criteria(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SortCriteria,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_100) = &input.attribute_name {
object.key("attributeName").string(var_100);
}
if let Some(var_101) = &input.order_by {
object.key("orderBy").string(var_101.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_cloud_trail_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CloudTrailDetails,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_102) = &input.trails {
let mut array_103 = object.key("trails").start_array();
for item_104 in var_102 {
{
let mut object_105 = array_103.value().start_object();
crate::json_ser::serialize_structure_crate_model_trail(&mut object_105, item_104)?;
object_105.finish();
}
}
array_103.finish();
}
if let Some(var_106) = &input.access_role {
object.key("accessRole").string(var_106);
}
if let Some(var_107) = &input.start_time {
object
.key("startTime")
.date_time(var_107, aws_smithy_types::date_time::Format::DateTime)?;
}
if let Some(var_108) = &input.end_time {
object
.key("endTime")
.date_time(var_108, aws_smithy_types::date_time::Format::DateTime)?;
}
Ok(())
}
pub fn serialize_structure_crate_model_policy_generation_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PolicyGenerationDetails,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_109) = &input.principal_arn {
object.key("principalArn").string(var_109);
}
Ok(())
}
pub fn serialize_structure_crate_model_iam_role_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::IamRoleConfiguration,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_110) = &input.trust_policy {
object.key("trustPolicy").string(var_110);
}
Ok(())
}
pub fn serialize_structure_crate_model_kms_key_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::KmsKeyConfiguration,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_111) = &input.key_policies {
let mut object_112 = object.key("keyPolicies").start_object();
for (key_113, value_114) in var_111 {
{
object_112.key(key_113).string(value_114);
}
}
object_112.finish();
}
if let Some(var_115) = &input.grants {
let mut array_116 = object.key("grants").start_array();
for item_117 in var_115 {
{
let mut object_118 = array_116.value().start_object();
crate::json_ser::serialize_structure_crate_model_kms_grant_configuration(
&mut object_118,
item_117,
)?;
object_118.finish();
}
}
array_116.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_secrets_manager_secret_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SecretsManagerSecretConfiguration,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_119) = &input.kms_key_id {
object.key("kmsKeyId").string(var_119);
}
if let Some(var_120) = &input.secret_policy {
object.key("secretPolicy").string(var_120);
}
Ok(())
}
pub fn serialize_structure_crate_model_s3_bucket_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::S3BucketConfiguration,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_121) = &input.bucket_policy {
object.key("bucketPolicy").string(var_121);
}
if let Some(var_122) = &input.bucket_acl_grants {
let mut array_123 = object.key("bucketAclGrants").start_array();
for item_124 in var_122 {
{
let mut object_125 = array_123.value().start_object();
crate::json_ser::serialize_structure_crate_model_s3_bucket_acl_grant_configuration(
&mut object_125,
item_124,
)?;
object_125.finish();
}
}
array_123.finish();
}
if let Some(var_126) = &input.bucket_public_access_block {
let mut object_127 = object.key("bucketPublicAccessBlock").start_object();
crate::json_ser::serialize_structure_crate_model_s3_public_access_block_configuration(
&mut object_127,
var_126,
)?;
object_127.finish();
}
if let Some(var_128) = &input.access_points {
let mut object_129 = object.key("accessPoints").start_object();
for (key_130, value_131) in var_128 {
{
let mut object_132 = object_129.key(key_130).start_object();
crate::json_ser::serialize_structure_crate_model_s3_access_point_configuration(
&mut object_132,
value_131,
)?;
object_132.finish();
}
}
object_129.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_sqs_queue_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SqsQueueConfiguration,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_133) = &input.queue_policy {
object.key("queuePolicy").string(var_133);
}
Ok(())
}
pub fn serialize_structure_crate_model_trail(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Trail,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_134) = &input.cloud_trail_arn {
object.key("cloudTrailArn").string(var_134);
}
if let Some(var_135) = &input.regions {
let mut array_136 = object.key("regions").start_array();
for item_137 in var_135 {
{
array_136.value().string(item_137);
}
}
array_136.finish();
}
if let Some(var_138) = &input.all_regions {
object.key("allRegions").boolean(*var_138);
}
Ok(())
}
pub fn serialize_structure_crate_model_kms_grant_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::KmsGrantConfiguration,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_139) = &input.operations {
let mut array_140 = object.key("operations").start_array();
for item_141 in var_139 {
{
array_140.value().string(item_141.as_str());
}
}
array_140.finish();
}
if let Some(var_142) = &input.grantee_principal {
object.key("granteePrincipal").string(var_142);
}
if let Some(var_143) = &input.retiring_principal {
object.key("retiringPrincipal").string(var_143);
}
if let Some(var_144) = &input.constraints {
let mut object_145 = object.key("constraints").start_object();
crate::json_ser::serialize_structure_crate_model_kms_grant_constraints(
&mut object_145,
var_144,
)?;
object_145.finish();
}
if let Some(var_146) = &input.issuing_account {
object.key("issuingAccount").string(var_146);
}
Ok(())
}
pub fn serialize_structure_crate_model_s3_bucket_acl_grant_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::S3BucketAclGrantConfiguration,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_147) = &input.permission {
object.key("permission").string(var_147.as_str());
}
if let Some(var_148) = &input.grantee {
let mut object_149 = object.key("grantee").start_object();
crate::json_ser::serialize_union_crate_model_acl_grantee(&mut object_149, var_148)?;
object_149.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_s3_public_access_block_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::S3PublicAccessBlockConfiguration,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_150) = &input.ignore_public_acls {
object.key("ignorePublicAcls").boolean(*var_150);
}
if let Some(var_151) = &input.restrict_public_buckets {
object.key("restrictPublicBuckets").boolean(*var_151);
}
Ok(())
}
pub fn serialize_structure_crate_model_s3_access_point_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::S3AccessPointConfiguration,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_152) = &input.access_point_policy {
object.key("accessPointPolicy").string(var_152);
}
if let Some(var_153) = &input.public_access_block {
let mut object_154 = object.key("publicAccessBlock").start_object();
crate::json_ser::serialize_structure_crate_model_s3_public_access_block_configuration(
&mut object_154,
var_153,
)?;
object_154.finish();
}
if let Some(var_155) = &input.network_origin {
let mut object_156 = object.key("networkOrigin").start_object();
crate::json_ser::serialize_union_crate_model_network_origin_configuration(
&mut object_156,
var_155,
)?;
object_156.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_kms_grant_constraints(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::KmsGrantConstraints,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_157) = &input.encryption_context_equals {
let mut object_158 = object.key("encryptionContextEquals").start_object();
for (key_159, value_160) in var_157 {
{
object_158.key(key_159).string(value_160);
}
}
object_158.finish();
}
if let Some(var_161) = &input.encryption_context_subset {
let mut object_162 = object.key("encryptionContextSubset").start_object();
for (key_163, value_164) in var_161 {
{
object_162.key(key_163).string(value_164);
}
}
object_162.finish();
}
Ok(())
}
pub fn serialize_union_crate_model_acl_grantee(
object_149: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AclGrantee,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
match input {
crate::model::AclGrantee::Id(inner) => {
object_149.key("id").string(inner);
}
crate::model::AclGrantee::Uri(inner) => {
object_149.key("uri").string(inner);
}
crate::model::AclGrantee::Unknown => {
return Err(
aws_smithy_http::operation::SerializationError::unknown_variant("AclGrantee"),
)
}
}
Ok(())
}
pub fn serialize_union_crate_model_network_origin_configuration(
object_156: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::NetworkOriginConfiguration,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
match input {
crate::model::NetworkOriginConfiguration::VpcConfiguration(inner) => {
let mut object_165 = object_156.key("vpcConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_vpc_configuration(
&mut object_165,
inner,
)?;
object_165.finish();
}
crate::model::NetworkOriginConfiguration::InternetConfiguration(inner) => {
let mut object_166 = object_156.key("internetConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_internet_configuration(
&mut object_166,
inner,
)?;
object_166.finish();
}
crate::model::NetworkOriginConfiguration::Unknown => {
return Err(
aws_smithy_http::operation::SerializationError::unknown_variant(
"NetworkOriginConfiguration",
),
)
}
}
Ok(())
}
pub fn serialize_structure_crate_model_vpc_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::VpcConfiguration,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_167) = &input.vpc_id {
object.key("vpcId").string(var_167);
}
Ok(())
}
pub fn serialize_structure_crate_model_internet_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::InternetConfiguration,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
let (_, _) = (object, input);
Ok(())
}