pub fn serialize_structure_crate_input_add_tags_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AddTagsInput,
) -> 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.tag_list {
let mut array_3 = object.key("TagList").start_array();
for item_4 in var_2 {
{
#[allow(unused_mut)]
let mut object_5 = array_3.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_5, item_4)?;
object_5.finish();
}
}
array_3.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_authorize_vpc_endpoint_access_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AuthorizeVpcEndpointAccessInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_6) = &input.account {
object.key("Account").string(var_6.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_cancel_service_software_update_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CancelServiceSoftwareUpdateInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_7) = &input.domain_name {
object.key("DomainName").string(var_7.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_domain_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateDomainInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_8) = &input.access_policies {
object.key("AccessPolicies").string(var_8.as_str());
}
if let Some(var_9) = &input.advanced_options {
#[allow(unused_mut)]
let mut object_10 = object.key("AdvancedOptions").start_object();
for (key_11, value_12) in var_9 {
{
object_10.key(key_11.as_str()).string(value_12.as_str());
}
}
object_10.finish();
}
if let Some(var_13) = &input.advanced_security_options {
#[allow(unused_mut)]
let mut object_14 = object.key("AdvancedSecurityOptions").start_object();
crate::json_ser::serialize_structure_crate_model_advanced_security_options_input(
&mut object_14,
var_13,
)?;
object_14.finish();
}
if let Some(var_15) = &input.auto_tune_options {
#[allow(unused_mut)]
let mut object_16 = object.key("AutoTuneOptions").start_object();
crate::json_ser::serialize_structure_crate_model_auto_tune_options_input(
&mut object_16,
var_15,
)?;
object_16.finish();
}
if let Some(var_17) = &input.cluster_config {
#[allow(unused_mut)]
let mut object_18 = object.key("ClusterConfig").start_object();
crate::json_ser::serialize_structure_crate_model_cluster_config(&mut object_18, var_17)?;
object_18.finish();
}
if let Some(var_19) = &input.cognito_options {
#[allow(unused_mut)]
let mut object_20 = object.key("CognitoOptions").start_object();
crate::json_ser::serialize_structure_crate_model_cognito_options(&mut object_20, var_19)?;
object_20.finish();
}
if let Some(var_21) = &input.domain_endpoint_options {
#[allow(unused_mut)]
let mut object_22 = object.key("DomainEndpointOptions").start_object();
crate::json_ser::serialize_structure_crate_model_domain_endpoint_options(
&mut object_22,
var_21,
)?;
object_22.finish();
}
if let Some(var_23) = &input.domain_name {
object.key("DomainName").string(var_23.as_str());
}
if let Some(var_24) = &input.ebs_options {
#[allow(unused_mut)]
let mut object_25 = object.key("EBSOptions").start_object();
crate::json_ser::serialize_structure_crate_model_ebs_options(&mut object_25, var_24)?;
object_25.finish();
}
if let Some(var_26) = &input.encryption_at_rest_options {
#[allow(unused_mut)]
let mut object_27 = object.key("EncryptionAtRestOptions").start_object();
crate::json_ser::serialize_structure_crate_model_encryption_at_rest_options(
&mut object_27,
var_26,
)?;
object_27.finish();
}
if let Some(var_28) = &input.engine_version {
object.key("EngineVersion").string(var_28.as_str());
}
if let Some(var_29) = &input.log_publishing_options {
#[allow(unused_mut)]
let mut object_30 = object.key("LogPublishingOptions").start_object();
for (key_31, value_32) in var_29 {
{
#[allow(unused_mut)]
let mut object_33 = object_30.key(key_31.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_log_publishing_option(
&mut object_33,
value_32,
)?;
object_33.finish();
}
}
object_30.finish();
}
if let Some(var_34) = &input.node_to_node_encryption_options {
#[allow(unused_mut)]
let mut object_35 = object.key("NodeToNodeEncryptionOptions").start_object();
crate::json_ser::serialize_structure_crate_model_node_to_node_encryption_options(
&mut object_35,
var_34,
)?;
object_35.finish();
}
if let Some(var_36) = &input.snapshot_options {
#[allow(unused_mut)]
let mut object_37 = object.key("SnapshotOptions").start_object();
crate::json_ser::serialize_structure_crate_model_snapshot_options(&mut object_37, var_36)?;
object_37.finish();
}
if let Some(var_38) = &input.tag_list {
let mut array_39 = object.key("TagList").start_array();
for item_40 in var_38 {
{
#[allow(unused_mut)]
let mut object_41 = array_39.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_41, item_40)?;
object_41.finish();
}
}
array_39.finish();
}
if let Some(var_42) = &input.vpc_options {
#[allow(unused_mut)]
let mut object_43 = object.key("VPCOptions").start_object();
crate::json_ser::serialize_structure_crate_model_vpc_options(&mut object_43, var_42)?;
object_43.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_outbound_connection_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateOutboundConnectionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_44) = &input.connection_alias {
object.key("ConnectionAlias").string(var_44.as_str());
}
if let Some(var_45) = &input.local_domain_info {
#[allow(unused_mut)]
let mut object_46 = object.key("LocalDomainInfo").start_object();
crate::json_ser::serialize_structure_crate_model_domain_information_container(
&mut object_46,
var_45,
)?;
object_46.finish();
}
if let Some(var_47) = &input.remote_domain_info {
#[allow(unused_mut)]
let mut object_48 = object.key("RemoteDomainInfo").start_object();
crate::json_ser::serialize_structure_crate_model_domain_information_container(
&mut object_48,
var_47,
)?;
object_48.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_package_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreatePackageInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_49) = &input.package_description {
object.key("PackageDescription").string(var_49.as_str());
}
if let Some(var_50) = &input.package_name {
object.key("PackageName").string(var_50.as_str());
}
if let Some(var_51) = &input.package_source {
#[allow(unused_mut)]
let mut object_52 = object.key("PackageSource").start_object();
crate::json_ser::serialize_structure_crate_model_package_source(&mut object_52, var_51)?;
object_52.finish();
}
if let Some(var_53) = &input.package_type {
object.key("PackageType").string(var_53.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_vpc_endpoint_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateVpcEndpointInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_54) = &input.client_token {
object.key("ClientToken").string(var_54.as_str());
}
if let Some(var_55) = &input.domain_arn {
object.key("DomainArn").string(var_55.as_str());
}
if let Some(var_56) = &input.vpc_options {
#[allow(unused_mut)]
let mut object_57 = object.key("VpcOptions").start_object();
crate::json_ser::serialize_structure_crate_model_vpc_options(&mut object_57, var_56)?;
object_57.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_domain_auto_tunes_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeDomainAutoTunesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.max_results != 0 {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max_results).into()),
);
}
if let Some(var_58) = &input.next_token {
object.key("NextToken").string(var_58.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_domains_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeDomainsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_59) = &input.domain_names {
let mut array_60 = object.key("DomainNames").start_array();
for item_61 in var_59 {
{
array_60.value().string(item_61.as_str());
}
}
array_60.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_inbound_connections_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeInboundConnectionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_62) = &input.filters {
let mut array_63 = object.key("Filters").start_array();
for item_64 in var_62 {
{
#[allow(unused_mut)]
let mut object_65 = array_63.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_65, item_64)?;
object_65.finish();
}
}
array_63.finish();
}
if input.max_results != 0 {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max_results).into()),
);
}
if let Some(var_66) = &input.next_token {
object.key("NextToken").string(var_66.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_outbound_connections_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeOutboundConnectionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_67) = &input.filters {
let mut array_68 = object.key("Filters").start_array();
for item_69 in var_67 {
{
#[allow(unused_mut)]
let mut object_70 = array_68.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_70, item_69)?;
object_70.finish();
}
}
array_68.finish();
}
if input.max_results != 0 {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max_results).into()),
);
}
if let Some(var_71) = &input.next_token {
object.key("NextToken").string(var_71.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_packages_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribePackagesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_72) = &input.filters {
let mut array_73 = object.key("Filters").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_describe_packages_filter(
&mut object_75,
item_74,
)?;
object_75.finish();
}
}
array_73.finish();
}
if input.max_results != 0 {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.max_results).into()),
);
}
if let Some(var_76) = &input.next_token {
object.key("NextToken").string(var_76.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_vpc_endpoints_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeVpcEndpointsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_77) = &input.vpc_endpoint_ids {
let mut array_78 = object.key("VpcEndpointIds").start_array();
for item_79 in var_77 {
{
array_78.value().string(item_79.as_str());
}
}
array_78.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_purchase_reserved_instance_offering_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PurchaseReservedInstanceOfferingInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.instance_count != 0 {
object.key("InstanceCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.instance_count).into()),
);
}
if let Some(var_80) = &input.reservation_name {
object.key("ReservationName").string(var_80.as_str());
}
if let Some(var_81) = &input.reserved_instance_offering_id {
object
.key("ReservedInstanceOfferingId")
.string(var_81.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_remove_tags_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RemoveTagsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_82) = &input.arn {
object.key("ARN").string(var_82.as_str());
}
if let Some(var_83) = &input.tag_keys {
let mut array_84 = object.key("TagKeys").start_array();
for item_85 in var_83 {
{
array_84.value().string(item_85.as_str());
}
}
array_84.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_revoke_vpc_endpoint_access_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RevokeVpcEndpointAccessInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_86) = &input.account {
object.key("Account").string(var_86.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_start_service_software_update_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartServiceSoftwareUpdateInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_87) = &input.domain_name {
object.key("DomainName").string(var_87.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_domain_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateDomainConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_88) = &input.access_policies {
object.key("AccessPolicies").string(var_88.as_str());
}
if let Some(var_89) = &input.advanced_options {
#[allow(unused_mut)]
let mut object_90 = object.key("AdvancedOptions").start_object();
for (key_91, value_92) in var_89 {
{
object_90.key(key_91.as_str()).string(value_92.as_str());
}
}
object_90.finish();
}
if let Some(var_93) = &input.advanced_security_options {
#[allow(unused_mut)]
let mut object_94 = object.key("AdvancedSecurityOptions").start_object();
crate::json_ser::serialize_structure_crate_model_advanced_security_options_input(
&mut object_94,
var_93,
)?;
object_94.finish();
}
if let Some(var_95) = &input.auto_tune_options {
#[allow(unused_mut)]
let mut object_96 = object.key("AutoTuneOptions").start_object();
crate::json_ser::serialize_structure_crate_model_auto_tune_options(&mut object_96, var_95)?;
object_96.finish();
}
if let Some(var_97) = &input.cluster_config {
#[allow(unused_mut)]
let mut object_98 = object.key("ClusterConfig").start_object();
crate::json_ser::serialize_structure_crate_model_cluster_config(&mut object_98, var_97)?;
object_98.finish();
}
if let Some(var_99) = &input.cognito_options {
#[allow(unused_mut)]
let mut object_100 = object.key("CognitoOptions").start_object();
crate::json_ser::serialize_structure_crate_model_cognito_options(&mut object_100, var_99)?;
object_100.finish();
}
if let Some(var_101) = &input.domain_endpoint_options {
#[allow(unused_mut)]
let mut object_102 = object.key("DomainEndpointOptions").start_object();
crate::json_ser::serialize_structure_crate_model_domain_endpoint_options(
&mut object_102,
var_101,
)?;
object_102.finish();
}
if let Some(var_103) = &input.dry_run {
object.key("DryRun").boolean(*var_103);
}
if let Some(var_104) = &input.dry_run_mode {
object.key("DryRunMode").string(var_104.as_str());
}
if let Some(var_105) = &input.ebs_options {
#[allow(unused_mut)]
let mut object_106 = object.key("EBSOptions").start_object();
crate::json_ser::serialize_structure_crate_model_ebs_options(&mut object_106, var_105)?;
object_106.finish();
}
if let Some(var_107) = &input.encryption_at_rest_options {
#[allow(unused_mut)]
let mut object_108 = object.key("EncryptionAtRestOptions").start_object();
crate::json_ser::serialize_structure_crate_model_encryption_at_rest_options(
&mut object_108,
var_107,
)?;
object_108.finish();
}
if let Some(var_109) = &input.log_publishing_options {
#[allow(unused_mut)]
let mut object_110 = object.key("LogPublishingOptions").start_object();
for (key_111, value_112) in var_109 {
{
#[allow(unused_mut)]
let mut object_113 = object_110.key(key_111.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_log_publishing_option(
&mut object_113,
value_112,
)?;
object_113.finish();
}
}
object_110.finish();
}
if let Some(var_114) = &input.node_to_node_encryption_options {
#[allow(unused_mut)]
let mut object_115 = object.key("NodeToNodeEncryptionOptions").start_object();
crate::json_ser::serialize_structure_crate_model_node_to_node_encryption_options(
&mut object_115,
var_114,
)?;
object_115.finish();
}
if let Some(var_116) = &input.snapshot_options {
#[allow(unused_mut)]
let mut object_117 = object.key("SnapshotOptions").start_object();
crate::json_ser::serialize_structure_crate_model_snapshot_options(
&mut object_117,
var_116,
)?;
object_117.finish();
}
if let Some(var_118) = &input.vpc_options {
#[allow(unused_mut)]
let mut object_119 = object.key("VPCOptions").start_object();
crate::json_ser::serialize_structure_crate_model_vpc_options(&mut object_119, var_118)?;
object_119.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_package_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdatePackageInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_120) = &input.commit_message {
object.key("CommitMessage").string(var_120.as_str());
}
if let Some(var_121) = &input.package_description {
object.key("PackageDescription").string(var_121.as_str());
}
if let Some(var_122) = &input.package_id {
object.key("PackageID").string(var_122.as_str());
}
if let Some(var_123) = &input.package_source {
#[allow(unused_mut)]
let mut object_124 = object.key("PackageSource").start_object();
crate::json_ser::serialize_structure_crate_model_package_source(&mut object_124, var_123)?;
object_124.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_vpc_endpoint_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateVpcEndpointInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_125) = &input.vpc_endpoint_id {
object.key("VpcEndpointId").string(var_125.as_str());
}
if let Some(var_126) = &input.vpc_options {
#[allow(unused_mut)]
let mut object_127 = object.key("VpcOptions").start_object();
crate::json_ser::serialize_structure_crate_model_vpc_options(&mut object_127, var_126)?;
object_127.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_upgrade_domain_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpgradeDomainInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_128) = &input.advanced_options {
#[allow(unused_mut)]
let mut object_129 = object.key("AdvancedOptions").start_object();
for (key_130, value_131) in var_128 {
{
object_129.key(key_130.as_str()).string(value_131.as_str());
}
}
object_129.finish();
}
if let Some(var_132) = &input.domain_name {
object.key("DomainName").string(var_132.as_str());
}
if let Some(var_133) = &input.perform_check_only {
object.key("PerformCheckOnly").boolean(*var_133);
}
if let Some(var_134) = &input.target_version {
object.key("TargetVersion").string(var_134.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_tag(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Tag,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_135) = &input.key {
object.key("Key").string(var_135.as_str());
}
if let Some(var_136) = &input.value {
object.key("Value").string(var_136.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_advanced_security_options_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AdvancedSecurityOptionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_137) = &input.enabled {
object.key("Enabled").boolean(*var_137);
}
if let Some(var_138) = &input.internal_user_database_enabled {
object.key("InternalUserDatabaseEnabled").boolean(*var_138);
}
if let Some(var_139) = &input.master_user_options {
#[allow(unused_mut)]
let mut object_140 = object.key("MasterUserOptions").start_object();
crate::json_ser::serialize_structure_crate_model_master_user_options(
&mut object_140,
var_139,
)?;
object_140.finish();
}
if let Some(var_141) = &input.saml_options {
#[allow(unused_mut)]
let mut object_142 = object.key("SAMLOptions").start_object();
crate::json_ser::serialize_structure_crate_model_saml_options_input(
&mut object_142,
var_141,
)?;
object_142.finish();
}
if let Some(var_143) = &input.anonymous_auth_enabled {
object.key("AnonymousAuthEnabled").boolean(*var_143);
}
Ok(())
}
pub fn serialize_structure_crate_model_auto_tune_options_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AutoTuneOptionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_144) = &input.desired_state {
object.key("DesiredState").string(var_144.as_str());
}
if let Some(var_145) = &input.maintenance_schedules {
let mut array_146 = object.key("MaintenanceSchedules").start_array();
for item_147 in var_145 {
{
#[allow(unused_mut)]
let mut object_148 = array_146.value().start_object();
crate::json_ser::serialize_structure_crate_model_auto_tune_maintenance_schedule(
&mut object_148,
item_147,
)?;
object_148.finish();
}
}
array_146.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_cluster_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ClusterConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_149) = &input.instance_type {
object.key("InstanceType").string(var_149.as_str());
}
if let Some(var_150) = &input.instance_count {
object.key("InstanceCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_150).into()),
);
}
if let Some(var_151) = &input.dedicated_master_enabled {
object.key("DedicatedMasterEnabled").boolean(*var_151);
}
if let Some(var_152) = &input.zone_awareness_enabled {
object.key("ZoneAwarenessEnabled").boolean(*var_152);
}
if let Some(var_153) = &input.zone_awareness_config {
#[allow(unused_mut)]
let mut object_154 = object.key("ZoneAwarenessConfig").start_object();
crate::json_ser::serialize_structure_crate_model_zone_awareness_config(
&mut object_154,
var_153,
)?;
object_154.finish();
}
if let Some(var_155) = &input.dedicated_master_type {
object.key("DedicatedMasterType").string(var_155.as_str());
}
if let Some(var_156) = &input.dedicated_master_count {
object.key("DedicatedMasterCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_156).into()),
);
}
if let Some(var_157) = &input.warm_enabled {
object.key("WarmEnabled").boolean(*var_157);
}
if let Some(var_158) = &input.warm_type {
object.key("WarmType").string(var_158.as_str());
}
if let Some(var_159) = &input.warm_count {
object.key("WarmCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_159).into()),
);
}
if let Some(var_160) = &input.cold_storage_options {
#[allow(unused_mut)]
let mut object_161 = object.key("ColdStorageOptions").start_object();
crate::json_ser::serialize_structure_crate_model_cold_storage_options(
&mut object_161,
var_160,
)?;
object_161.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_cognito_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CognitoOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_162) = &input.enabled {
object.key("Enabled").boolean(*var_162);
}
if let Some(var_163) = &input.user_pool_id {
object.key("UserPoolId").string(var_163.as_str());
}
if let Some(var_164) = &input.identity_pool_id {
object.key("IdentityPoolId").string(var_164.as_str());
}
if let Some(var_165) = &input.role_arn {
object.key("RoleArn").string(var_165.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_domain_endpoint_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DomainEndpointOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_166) = &input.enforce_https {
object.key("EnforceHTTPS").boolean(*var_166);
}
if let Some(var_167) = &input.tls_security_policy {
object.key("TLSSecurityPolicy").string(var_167.as_str());
}
if let Some(var_168) = &input.custom_endpoint_enabled {
object.key("CustomEndpointEnabled").boolean(*var_168);
}
if let Some(var_169) = &input.custom_endpoint {
object.key("CustomEndpoint").string(var_169.as_str());
}
if let Some(var_170) = &input.custom_endpoint_certificate_arn {
object
.key("CustomEndpointCertificateArn")
.string(var_170.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_ebs_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EbsOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_171) = &input.ebs_enabled {
object.key("EBSEnabled").boolean(*var_171);
}
if let Some(var_172) = &input.volume_type {
object.key("VolumeType").string(var_172.as_str());
}
if let Some(var_173) = &input.volume_size {
object.key("VolumeSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_173).into()),
);
}
if let Some(var_174) = &input.iops {
object.key("Iops").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_174).into()),
);
}
if let Some(var_175) = &input.throughput {
object.key("Throughput").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_175).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_encryption_at_rest_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EncryptionAtRestOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_176) = &input.enabled {
object.key("Enabled").boolean(*var_176);
}
if let Some(var_177) = &input.kms_key_id {
object.key("KmsKeyId").string(var_177.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_log_publishing_option(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LogPublishingOption,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_178) = &input.cloud_watch_logs_log_group_arn {
object
.key("CloudWatchLogsLogGroupArn")
.string(var_178.as_str());
}
if let Some(var_179) = &input.enabled {
object.key("Enabled").boolean(*var_179);
}
Ok(())
}
pub fn serialize_structure_crate_model_node_to_node_encryption_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::NodeToNodeEncryptionOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_180) = &input.enabled {
object.key("Enabled").boolean(*var_180);
}
Ok(())
}
pub fn serialize_structure_crate_model_snapshot_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SnapshotOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_181) = &input.automated_snapshot_start_hour {
object.key("AutomatedSnapshotStartHour").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_181).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_vpc_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::VpcOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_182) = &input.subnet_ids {
let mut array_183 = object.key("SubnetIds").start_array();
for item_184 in var_182 {
{
array_183.value().string(item_184.as_str());
}
}
array_183.finish();
}
if let Some(var_185) = &input.security_group_ids {
let mut array_186 = object.key("SecurityGroupIds").start_array();
for item_187 in var_185 {
{
array_186.value().string(item_187.as_str());
}
}
array_186.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_domain_information_container(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DomainInformationContainer,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_188) = &input.aws_domain_information {
#[allow(unused_mut)]
let mut object_189 = object.key("AWSDomainInformation").start_object();
crate::json_ser::serialize_structure_crate_model_aws_domain_information(
&mut object_189,
var_188,
)?;
object_189.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_package_source(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PackageSource,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_190) = &input.s3_bucket_name {
object.key("S3BucketName").string(var_190.as_str());
}
if let Some(var_191) = &input.s3_key {
object.key("S3Key").string(var_191.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Filter,
) -> 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.values {
let mut array_194 = object.key("Values").start_array();
for item_195 in var_193 {
{
array_194.value().string(item_195.as_str());
}
}
array_194.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_describe_packages_filter(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DescribePackagesFilter,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_196) = &input.name {
object.key("Name").string(var_196.as_str());
}
if let Some(var_197) = &input.value {
let mut array_198 = object.key("Value").start_array();
for item_199 in var_197 {
{
array_198.value().string(item_199.as_str());
}
}
array_198.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_auto_tune_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AutoTuneOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_200) = &input.desired_state {
object.key("DesiredState").string(var_200.as_str());
}
if let Some(var_201) = &input.rollback_on_disable {
object.key("RollbackOnDisable").string(var_201.as_str());
}
if let Some(var_202) = &input.maintenance_schedules {
let mut array_203 = object.key("MaintenanceSchedules").start_array();
for item_204 in var_202 {
{
#[allow(unused_mut)]
let mut object_205 = array_203.value().start_object();
crate::json_ser::serialize_structure_crate_model_auto_tune_maintenance_schedule(
&mut object_205,
item_204,
)?;
object_205.finish();
}
}
array_203.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_master_user_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::MasterUserOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_206) = &input.master_user_arn {
object.key("MasterUserARN").string(var_206.as_str());
}
if let Some(var_207) = &input.master_user_name {
object.key("MasterUserName").string(var_207.as_str());
}
if let Some(var_208) = &input.master_user_password {
object.key("MasterUserPassword").string(var_208.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_saml_options_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SamlOptionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_209) = &input.enabled {
object.key("Enabled").boolean(*var_209);
}
if let Some(var_210) = &input.idp {
#[allow(unused_mut)]
let mut object_211 = object.key("Idp").start_object();
crate::json_ser::serialize_structure_crate_model_saml_idp(&mut object_211, var_210)?;
object_211.finish();
}
if let Some(var_212) = &input.master_user_name {
object.key("MasterUserName").string(var_212.as_str());
}
if let Some(var_213) = &input.master_backend_role {
object.key("MasterBackendRole").string(var_213.as_str());
}
if let Some(var_214) = &input.subject_key {
object.key("SubjectKey").string(var_214.as_str());
}
if let Some(var_215) = &input.roles_key {
object.key("RolesKey").string(var_215.as_str());
}
if let Some(var_216) = &input.session_timeout_minutes {
object.key("SessionTimeoutMinutes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_216).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_auto_tune_maintenance_schedule(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AutoTuneMaintenanceSchedule,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_217) = &input.start_at {
object
.key("StartAt")
.date_time(var_217, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_218) = &input.duration {
#[allow(unused_mut)]
let mut object_219 = object.key("Duration").start_object();
crate::json_ser::serialize_structure_crate_model_duration(&mut object_219, var_218)?;
object_219.finish();
}
if let Some(var_220) = &input.cron_expression_for_recurrence {
object
.key("CronExpressionForRecurrence")
.string(var_220.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_zone_awareness_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ZoneAwarenessConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_221) = &input.availability_zone_count {
object.key("AvailabilityZoneCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_221).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_cold_storage_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ColdStorageOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_222) = &input.enabled {
object.key("Enabled").boolean(*var_222);
}
Ok(())
}
pub fn serialize_structure_crate_model_aws_domain_information(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AwsDomainInformation,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_223) = &input.owner_id {
object.key("OwnerId").string(var_223.as_str());
}
if let Some(var_224) = &input.domain_name {
object.key("DomainName").string(var_224.as_str());
}
if let Some(var_225) = &input.region {
object.key("Region").string(var_225.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_saml_idp(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SamlIdp,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_226) = &input.metadata_content {
object.key("MetadataContent").string(var_226.as_str());
}
if let Some(var_227) = &input.entity_id {
object.key("EntityId").string(var_227.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_duration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Duration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.value != 0 {
object.key("Value").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.value).into()),
);
}
if let Some(var_228) = &input.unit {
object.key("Unit").string(var_228.as_str());
}
Ok(())
}