pub fn serialize_structure_crate_input_batch_associate_scram_secret_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchAssociateScramSecretInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.secret_arn_list {
let mut array_2 = object.key("secretArnList").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_batch_disassociate_scram_secret_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchDisassociateScramSecretInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_4) = &input.secret_arn_list {
let mut array_5 = object.key("secretArnList").start_array();
for item_6 in var_4 {
{
array_5.value().string(item_6.as_str());
}
}
array_5.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_cluster_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateClusterInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_7) = &input.broker_node_group_info {
#[allow(unused_mut)]
let mut object_8 = object.key("brokerNodeGroupInfo").start_object();
crate::json_ser::serialize_structure_crate_model_broker_node_group_info(
&mut object_8,
var_7,
)?;
object_8.finish();
}
if let Some(var_9) = &input.client_authentication {
#[allow(unused_mut)]
let mut object_10 = object.key("clientAuthentication").start_object();
crate::json_ser::serialize_structure_crate_model_client_authentication(
&mut object_10,
var_9,
)?;
object_10.finish();
}
if let Some(var_11) = &input.cluster_name {
object.key("clusterName").string(var_11.as_str());
}
if let Some(var_12) = &input.configuration_info {
#[allow(unused_mut)]
let mut object_13 = object.key("configurationInfo").start_object();
crate::json_ser::serialize_structure_crate_model_configuration_info(
&mut object_13,
var_12,
)?;
object_13.finish();
}
if let Some(var_14) = &input.encryption_info {
#[allow(unused_mut)]
let mut object_15 = object.key("encryptionInfo").start_object();
crate::json_ser::serialize_structure_crate_model_encryption_info(&mut object_15, var_14)?;
object_15.finish();
}
if let Some(var_16) = &input.enhanced_monitoring {
object.key("enhancedMonitoring").string(var_16.as_str());
}
if let Some(var_17) = &input.kafka_version {
object.key("kafkaVersion").string(var_17.as_str());
}
if let Some(var_18) = &input.logging_info {
#[allow(unused_mut)]
let mut object_19 = object.key("loggingInfo").start_object();
crate::json_ser::serialize_structure_crate_model_logging_info(&mut object_19, var_18)?;
object_19.finish();
}
{
object.key("numberOfBrokerNodes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.number_of_broker_nodes).into()),
);
}
if let Some(var_20) = &input.open_monitoring {
#[allow(unused_mut)]
let mut object_21 = object.key("openMonitoring").start_object();
crate::json_ser::serialize_structure_crate_model_open_monitoring_info(
&mut object_21,
var_20,
)?;
object_21.finish();
}
if let Some(var_22) = &input.storage_mode {
object.key("storageMode").string(var_22.as_str());
}
if let Some(var_23) = &input.tags {
#[allow(unused_mut)]
let mut object_24 = object.key("tags").start_object();
for (key_25, value_26) in var_23 {
{
object_24.key(key_25.as_str()).string(value_26.as_str());
}
}
object_24.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_cluster_v2_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateClusterV2Input,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_27) = &input.cluster_name {
object.key("clusterName").string(var_27.as_str());
}
if let Some(var_28) = &input.provisioned {
#[allow(unused_mut)]
let mut object_29 = object.key("provisioned").start_object();
crate::json_ser::serialize_structure_crate_model_provisioned_request(
&mut object_29,
var_28,
)?;
object_29.finish();
}
if let Some(var_30) = &input.serverless {
#[allow(unused_mut)]
let mut object_31 = object.key("serverless").start_object();
crate::json_ser::serialize_structure_crate_model_serverless_request(
&mut object_31,
var_30,
)?;
object_31.finish();
}
if let Some(var_32) = &input.tags {
#[allow(unused_mut)]
let mut object_33 = object.key("tags").start_object();
for (key_34, value_35) in var_32 {
{
object_33.key(key_34.as_str()).string(value_35.as_str());
}
}
object_33.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_36) = &input.description {
object.key("description").string(var_36.as_str());
}
if let Some(var_37) = &input.kafka_versions {
let mut array_38 = object.key("kafkaVersions").start_array();
for item_39 in var_37 {
{
array_38.value().string(item_39.as_str());
}
}
array_38.finish();
}
if let Some(var_40) = &input.name {
object.key("name").string(var_40.as_str());
}
if let Some(var_41) = &input.server_properties {
object
.key("serverProperties")
.string_unchecked(&aws_smithy_types::base64::encode(var_41));
}
Ok(())
}
pub fn serialize_structure_crate_input_reboot_broker_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RebootBrokerInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_42) = &input.broker_ids {
let mut array_43 = object.key("brokerIds").start_array();
for item_44 in var_42 {
{
array_43.value().string(item_44.as_str());
}
}
array_43.finish();
}
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_45) = &input.tags {
#[allow(unused_mut)]
let mut object_46 = object.key("tags").start_object();
for (key_47, value_48) in var_45 {
{
object_46.key(key_47.as_str()).string(value_48.as_str());
}
}
object_46.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_broker_count_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateBrokerCountInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_49) = &input.current_version {
object.key("currentVersion").string(var_49.as_str());
}
{
object.key("targetNumberOfBrokerNodes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.target_number_of_broker_nodes).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_update_broker_storage_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateBrokerStorageInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_50) = &input.current_version {
object.key("currentVersion").string(var_50.as_str());
}
if let Some(var_51) = &input.target_broker_ebs_volume_info {
let mut array_52 = object.key("targetBrokerEBSVolumeInfo").start_array();
for item_53 in var_51 {
{
#[allow(unused_mut)]
let mut object_54 = array_52.value().start_object();
crate::json_ser::serialize_structure_crate_model_broker_ebs_volume_info(
&mut object_54,
item_53,
)?;
object_54.finish();
}
}
array_52.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_broker_type_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateBrokerTypeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_55) = &input.current_version {
object.key("currentVersion").string(var_55.as_str());
}
if let Some(var_56) = &input.target_instance_type {
object.key("targetInstanceType").string(var_56.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_cluster_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateClusterConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_57) = &input.configuration_info {
#[allow(unused_mut)]
let mut object_58 = object.key("configurationInfo").start_object();
crate::json_ser::serialize_structure_crate_model_configuration_info(
&mut object_58,
var_57,
)?;
object_58.finish();
}
if let Some(var_59) = &input.current_version {
object.key("currentVersion").string(var_59.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_cluster_kafka_version_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateClusterKafkaVersionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_60) = &input.configuration_info {
#[allow(unused_mut)]
let mut object_61 = object.key("configurationInfo").start_object();
crate::json_ser::serialize_structure_crate_model_configuration_info(
&mut object_61,
var_60,
)?;
object_61.finish();
}
if let Some(var_62) = &input.current_version {
object.key("currentVersion").string(var_62.as_str());
}
if let Some(var_63) = &input.target_kafka_version {
object.key("targetKafkaVersion").string(var_63.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_64) = &input.description {
object.key("description").string(var_64.as_str());
}
if let Some(var_65) = &input.server_properties {
object
.key("serverProperties")
.string_unchecked(&aws_smithy_types::base64::encode(var_65));
}
Ok(())
}
pub fn serialize_structure_crate_input_update_connectivity_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateConnectivityInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_66) = &input.connectivity_info {
#[allow(unused_mut)]
let mut object_67 = object.key("connectivityInfo").start_object();
crate::json_ser::serialize_structure_crate_model_connectivity_info(&mut object_67, var_66)?;
object_67.finish();
}
if let Some(var_68) = &input.current_version {
object.key("currentVersion").string(var_68.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_monitoring_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateMonitoringInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_69) = &input.current_version {
object.key("currentVersion").string(var_69.as_str());
}
if let Some(var_70) = &input.enhanced_monitoring {
object.key("enhancedMonitoring").string(var_70.as_str());
}
if let Some(var_71) = &input.logging_info {
#[allow(unused_mut)]
let mut object_72 = object.key("loggingInfo").start_object();
crate::json_ser::serialize_structure_crate_model_logging_info(&mut object_72, var_71)?;
object_72.finish();
}
if let Some(var_73) = &input.open_monitoring {
#[allow(unused_mut)]
let mut object_74 = object.key("openMonitoring").start_object();
crate::json_ser::serialize_structure_crate_model_open_monitoring_info(
&mut object_74,
var_73,
)?;
object_74.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_security_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateSecurityInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_75) = &input.client_authentication {
#[allow(unused_mut)]
let mut object_76 = object.key("clientAuthentication").start_object();
crate::json_ser::serialize_structure_crate_model_client_authentication(
&mut object_76,
var_75,
)?;
object_76.finish();
}
if let Some(var_77) = &input.current_version {
object.key("currentVersion").string(var_77.as_str());
}
if let Some(var_78) = &input.encryption_info {
#[allow(unused_mut)]
let mut object_79 = object.key("encryptionInfo").start_object();
crate::json_ser::serialize_structure_crate_model_encryption_info(&mut object_79, var_78)?;
object_79.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_storage_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateStorageInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_80) = &input.current_version {
object.key("currentVersion").string(var_80.as_str());
}
if let Some(var_81) = &input.provisioned_throughput {
#[allow(unused_mut)]
let mut object_82 = object.key("provisionedThroughput").start_object();
crate::json_ser::serialize_structure_crate_model_provisioned_throughput(
&mut object_82,
var_81,
)?;
object_82.finish();
}
if let Some(var_83) = &input.storage_mode {
object.key("storageMode").string(var_83.as_str());
}
if input.volume_size_gb != 0 {
object.key("volumeSizeGB").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.volume_size_gb).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_broker_node_group_info(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BrokerNodeGroupInfo,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_84) = &input.broker_az_distribution {
object.key("brokerAZDistribution").string(var_84.as_str());
}
if let Some(var_85) = &input.client_subnets {
let mut array_86 = object.key("clientSubnets").start_array();
for item_87 in var_85 {
{
array_86.value().string(item_87.as_str());
}
}
array_86.finish();
}
if let Some(var_88) = &input.instance_type {
object.key("instanceType").string(var_88.as_str());
}
if let Some(var_89) = &input.security_groups {
let mut array_90 = object.key("securityGroups").start_array();
for item_91 in var_89 {
{
array_90.value().string(item_91.as_str());
}
}
array_90.finish();
}
if let Some(var_92) = &input.storage_info {
#[allow(unused_mut)]
let mut object_93 = object.key("storageInfo").start_object();
crate::json_ser::serialize_structure_crate_model_storage_info(&mut object_93, var_92)?;
object_93.finish();
}
if let Some(var_94) = &input.connectivity_info {
#[allow(unused_mut)]
let mut object_95 = object.key("connectivityInfo").start_object();
crate::json_ser::serialize_structure_crate_model_connectivity_info(&mut object_95, var_94)?;
object_95.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_client_authentication(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ClientAuthentication,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_96) = &input.sasl {
#[allow(unused_mut)]
let mut object_97 = object.key("sasl").start_object();
crate::json_ser::serialize_structure_crate_model_sasl(&mut object_97, var_96)?;
object_97.finish();
}
if let Some(var_98) = &input.tls {
#[allow(unused_mut)]
let mut object_99 = object.key("tls").start_object();
crate::json_ser::serialize_structure_crate_model_tls(&mut object_99, var_98)?;
object_99.finish();
}
if let Some(var_100) = &input.unauthenticated {
#[allow(unused_mut)]
let mut object_101 = object.key("unauthenticated").start_object();
crate::json_ser::serialize_structure_crate_model_unauthenticated(&mut object_101, var_100)?;
object_101.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_configuration_info(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ConfigurationInfo,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_102) = &input.arn {
object.key("arn").string(var_102.as_str());
}
{
object.key("revision").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.revision).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_encryption_info(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EncryptionInfo,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_103) = &input.encryption_at_rest {
#[allow(unused_mut)]
let mut object_104 = object.key("encryptionAtRest").start_object();
crate::json_ser::serialize_structure_crate_model_encryption_at_rest(
&mut object_104,
var_103,
)?;
object_104.finish();
}
if let Some(var_105) = &input.encryption_in_transit {
#[allow(unused_mut)]
let mut object_106 = object.key("encryptionInTransit").start_object();
crate::json_ser::serialize_structure_crate_model_encryption_in_transit(
&mut object_106,
var_105,
)?;
object_106.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_logging_info(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LoggingInfo,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_107) = &input.broker_logs {
#[allow(unused_mut)]
let mut object_108 = object.key("brokerLogs").start_object();
crate::json_ser::serialize_structure_crate_model_broker_logs(&mut object_108, var_107)?;
object_108.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_open_monitoring_info(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OpenMonitoringInfo,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_109) = &input.prometheus {
#[allow(unused_mut)]
let mut object_110 = object.key("prometheus").start_object();
crate::json_ser::serialize_structure_crate_model_prometheus_info(&mut object_110, var_109)?;
object_110.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_provisioned_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ProvisionedRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_111) = &input.broker_node_group_info {
#[allow(unused_mut)]
let mut object_112 = object.key("brokerNodeGroupInfo").start_object();
crate::json_ser::serialize_structure_crate_model_broker_node_group_info(
&mut object_112,
var_111,
)?;
object_112.finish();
}
if let Some(var_113) = &input.client_authentication {
#[allow(unused_mut)]
let mut object_114 = object.key("clientAuthentication").start_object();
crate::json_ser::serialize_structure_crate_model_client_authentication(
&mut object_114,
var_113,
)?;
object_114.finish();
}
if let Some(var_115) = &input.configuration_info {
#[allow(unused_mut)]
let mut object_116 = object.key("configurationInfo").start_object();
crate::json_ser::serialize_structure_crate_model_configuration_info(
&mut object_116,
var_115,
)?;
object_116.finish();
}
if let Some(var_117) = &input.encryption_info {
#[allow(unused_mut)]
let mut object_118 = object.key("encryptionInfo").start_object();
crate::json_ser::serialize_structure_crate_model_encryption_info(&mut object_118, var_117)?;
object_118.finish();
}
if let Some(var_119) = &input.enhanced_monitoring {
object.key("enhancedMonitoring").string(var_119.as_str());
}
if let Some(var_120) = &input.open_monitoring {
#[allow(unused_mut)]
let mut object_121 = object.key("openMonitoring").start_object();
crate::json_ser::serialize_structure_crate_model_open_monitoring_info(
&mut object_121,
var_120,
)?;
object_121.finish();
}
if let Some(var_122) = &input.kafka_version {
object.key("kafkaVersion").string(var_122.as_str());
}
if let Some(var_123) = &input.logging_info {
#[allow(unused_mut)]
let mut object_124 = object.key("loggingInfo").start_object();
crate::json_ser::serialize_structure_crate_model_logging_info(&mut object_124, var_123)?;
object_124.finish();
}
{
object.key("numberOfBrokerNodes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.number_of_broker_nodes).into()),
);
}
if let Some(var_125) = &input.storage_mode {
object.key("storageMode").string(var_125.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_serverless_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ServerlessRequest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_126) = &input.vpc_configs {
let mut array_127 = object.key("vpcConfigs").start_array();
for item_128 in var_126 {
{
#[allow(unused_mut)]
let mut object_129 = array_127.value().start_object();
crate::json_ser::serialize_structure_crate_model_vpc_config(
&mut object_129,
item_128,
)?;
object_129.finish();
}
}
array_127.finish();
}
if let Some(var_130) = &input.client_authentication {
#[allow(unused_mut)]
let mut object_131 = object.key("clientAuthentication").start_object();
crate::json_ser::serialize_structure_crate_model_serverless_client_authentication(
&mut object_131,
var_130,
)?;
object_131.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_broker_ebs_volume_info(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BrokerEbsVolumeInfo,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_132) = &input.kafka_broker_node_id {
object.key("kafkaBrokerNodeId").string(var_132.as_str());
}
if let Some(var_133) = &input.provisioned_throughput {
#[allow(unused_mut)]
let mut object_134 = object.key("provisionedThroughput").start_object();
crate::json_ser::serialize_structure_crate_model_provisioned_throughput(
&mut object_134,
var_133,
)?;
object_134.finish();
}
if input.volume_size_gb != 0 {
object.key("volumeSizeGB").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.volume_size_gb).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_connectivity_info(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ConnectivityInfo,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_135) = &input.public_access {
#[allow(unused_mut)]
let mut object_136 = object.key("publicAccess").start_object();
crate::json_ser::serialize_structure_crate_model_public_access(&mut object_136, var_135)?;
object_136.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_provisioned_throughput(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ProvisionedThroughput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.enabled {
object.key("enabled").boolean(input.enabled);
}
if input.volume_throughput != 0 {
object.key("volumeThroughput").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.volume_throughput).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_storage_info(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StorageInfo,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_137) = &input.ebs_storage_info {
#[allow(unused_mut)]
let mut object_138 = object.key("ebsStorageInfo").start_object();
crate::json_ser::serialize_structure_crate_model_ebs_storage_info(
&mut object_138,
var_137,
)?;
object_138.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_sasl(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Sasl,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_139) = &input.scram {
#[allow(unused_mut)]
let mut object_140 = object.key("scram").start_object();
crate::json_ser::serialize_structure_crate_model_scram(&mut object_140, var_139)?;
object_140.finish();
}
if let Some(var_141) = &input.iam {
#[allow(unused_mut)]
let mut object_142 = object.key("iam").start_object();
crate::json_ser::serialize_structure_crate_model_iam(&mut object_142, var_141)?;
object_142.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_tls(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Tls,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_143) = &input.certificate_authority_arn_list {
let mut array_144 = object.key("certificateAuthorityArnList").start_array();
for item_145 in var_143 {
{
array_144.value().string(item_145.as_str());
}
}
array_144.finish();
}
if input.enabled {
object.key("enabled").boolean(input.enabled);
}
Ok(())
}
pub fn serialize_structure_crate_model_unauthenticated(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Unauthenticated,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.enabled {
object.key("enabled").boolean(input.enabled);
}
Ok(())
}
pub fn serialize_structure_crate_model_encryption_at_rest(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EncryptionAtRest,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_146) = &input.data_volume_kms_key_id {
object.key("dataVolumeKMSKeyId").string(var_146.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_encryption_in_transit(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EncryptionInTransit,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_147) = &input.client_broker {
object.key("clientBroker").string(var_147.as_str());
}
if input.in_cluster {
object.key("inCluster").boolean(input.in_cluster);
}
Ok(())
}
pub fn serialize_structure_crate_model_broker_logs(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::BrokerLogs,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_148) = &input.cloud_watch_logs {
#[allow(unused_mut)]
let mut object_149 = object.key("cloudWatchLogs").start_object();
crate::json_ser::serialize_structure_crate_model_cloud_watch_logs(
&mut object_149,
var_148,
)?;
object_149.finish();
}
if let Some(var_150) = &input.firehose {
#[allow(unused_mut)]
let mut object_151 = object.key("firehose").start_object();
crate::json_ser::serialize_structure_crate_model_firehose(&mut object_151, var_150)?;
object_151.finish();
}
if let Some(var_152) = &input.s3 {
#[allow(unused_mut)]
let mut object_153 = object.key("s3").start_object();
crate::json_ser::serialize_structure_crate_model_s3(&mut object_153, var_152)?;
object_153.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_prometheus_info(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PrometheusInfo,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_154) = &input.jmx_exporter {
#[allow(unused_mut)]
let mut object_155 = object.key("jmxExporter").start_object();
crate::json_ser::serialize_structure_crate_model_jmx_exporter_info(
&mut object_155,
var_154,
)?;
object_155.finish();
}
if let Some(var_156) = &input.node_exporter {
#[allow(unused_mut)]
let mut object_157 = object.key("nodeExporter").start_object();
crate::json_ser::serialize_structure_crate_model_node_exporter_info(
&mut object_157,
var_156,
)?;
object_157.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_vpc_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::VpcConfig,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_158) = &input.subnet_ids {
let mut array_159 = object.key("subnetIds").start_array();
for item_160 in var_158 {
{
array_159.value().string(item_160.as_str());
}
}
array_159.finish();
}
if let Some(var_161) = &input.security_group_ids {
let mut array_162 = object.key("securityGroupIds").start_array();
for item_163 in var_161 {
{
array_162.value().string(item_163.as_str());
}
}
array_162.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_serverless_client_authentication(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ServerlessClientAuthentication,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_164) = &input.sasl {
#[allow(unused_mut)]
let mut object_165 = object.key("sasl").start_object();
crate::json_ser::serialize_structure_crate_model_serverless_sasl(&mut object_165, var_164)?;
object_165.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_public_access(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PublicAccess,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_166) = &input.r#type {
object.key("type").string(var_166.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_ebs_storage_info(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EbsStorageInfo,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_167) = &input.provisioned_throughput {
#[allow(unused_mut)]
let mut object_168 = object.key("provisionedThroughput").start_object();
crate::json_ser::serialize_structure_crate_model_provisioned_throughput(
&mut object_168,
var_167,
)?;
object_168.finish();
}
if input.volume_size != 0 {
object.key("volumeSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.volume_size).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_scram(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Scram,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.enabled {
object.key("enabled").boolean(input.enabled);
}
Ok(())
}
pub fn serialize_structure_crate_model_iam(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Iam,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if input.enabled {
object.key("enabled").boolean(input.enabled);
}
Ok(())
}
pub fn serialize_structure_crate_model_cloud_watch_logs(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CloudWatchLogs,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
{
object.key("enabled").boolean(input.enabled);
}
if let Some(var_169) = &input.log_group {
object.key("logGroup").string(var_169.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_firehose(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Firehose,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_170) = &input.delivery_stream {
object.key("deliveryStream").string(var_170.as_str());
}
{
object.key("enabled").boolean(input.enabled);
}
Ok(())
}
pub fn serialize_structure_crate_model_s3(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::S3,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_171) = &input.bucket {
object.key("bucket").string(var_171.as_str());
}
{
object.key("enabled").boolean(input.enabled);
}
if let Some(var_172) = &input.prefix {
object.key("prefix").string(var_172.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_jmx_exporter_info(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::JmxExporterInfo,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
{
object
.key("enabledInBroker")
.boolean(input.enabled_in_broker);
}
Ok(())
}
pub fn serialize_structure_crate_model_node_exporter_info(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::NodeExporterInfo,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
{
object
.key("enabledInBroker")
.boolean(input.enabled_in_broker);
}
Ok(())
}
pub fn serialize_structure_crate_model_serverless_sasl(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ServerlessSasl,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_173) = &input.iam {
#[allow(unused_mut)]
let mut object_174 = object.key("iam").start_object();
crate::json_ser::serialize_structure_crate_model_iam(&mut object_174, var_173)?;
object_174.finish();
}
Ok(())
}