pub fn serialize_structure_crate_input_cancel_rotate_secret_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CancelRotateSecretInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.secret_id {
object.key("SecretId").string(var_1.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_secret_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateSecretInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2) = &input.name {
object.key("Name").string(var_2.as_str());
}
if let Some(var_3) = &input.client_request_token {
object.key("ClientRequestToken").string(var_3.as_str());
}
if let Some(var_4) = &input.description {
object.key("Description").string(var_4.as_str());
}
if let Some(var_5) = &input.kms_key_id {
object.key("KmsKeyId").string(var_5.as_str());
}
if let Some(var_6) = &input.secret_binary {
object
.key("SecretBinary")
.string_unchecked(&aws_smithy_types::base64::encode(var_6));
}
if let Some(var_7) = &input.secret_string {
object.key("SecretString").string(var_7.as_str());
}
if let Some(var_8) = &input.tags {
let mut array_9 = object.key("Tags").start_array();
for item_10 in var_8 {
{
#[allow(unused_mut)]
let mut object_11 = array_9.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_11, item_10)?;
object_11.finish();
}
}
array_9.finish();
}
if let Some(var_12) = &input.add_replica_regions {
let mut array_13 = object.key("AddReplicaRegions").start_array();
for item_14 in var_12 {
{
#[allow(unused_mut)]
let mut object_15 = array_13.value().start_object();
crate::json_ser::serialize_structure_crate_model_replica_region_type(
&mut object_15,
item_14,
)?;
object_15.finish();
}
}
array_13.finish();
}
if input.force_overwrite_replica_secret {
object
.key("ForceOverwriteReplicaSecret")
.boolean(input.force_overwrite_replica_secret);
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_resource_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteResourcePolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_16) = &input.secret_id {
object.key("SecretId").string(var_16.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_secret_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteSecretInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_17) = &input.secret_id {
object.key("SecretId").string(var_17.as_str());
}
if let Some(var_18) = &input.recovery_window_in_days {
object.key("RecoveryWindowInDays").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_18).into()),
);
}
if let Some(var_19) = &input.force_delete_without_recovery {
object.key("ForceDeleteWithoutRecovery").boolean(*var_19);
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_secret_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeSecretInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_20) = &input.secret_id {
object.key("SecretId").string(var_20.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_random_password_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetRandomPasswordInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_21) = &input.password_length {
object.key("PasswordLength").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_21).into()),
);
}
if let Some(var_22) = &input.exclude_characters {
object.key("ExcludeCharacters").string(var_22.as_str());
}
if let Some(var_23) = &input.exclude_numbers {
object.key("ExcludeNumbers").boolean(*var_23);
}
if let Some(var_24) = &input.exclude_punctuation {
object.key("ExcludePunctuation").boolean(*var_24);
}
if let Some(var_25) = &input.exclude_uppercase {
object.key("ExcludeUppercase").boolean(*var_25);
}
if let Some(var_26) = &input.exclude_lowercase {
object.key("ExcludeLowercase").boolean(*var_26);
}
if let Some(var_27) = &input.include_space {
object.key("IncludeSpace").boolean(*var_27);
}
if let Some(var_28) = &input.require_each_included_type {
object.key("RequireEachIncludedType").boolean(*var_28);
}
Ok(())
}
pub fn serialize_structure_crate_input_get_resource_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetResourcePolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_29) = &input.secret_id {
object.key("SecretId").string(var_29.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_secret_value_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetSecretValueInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_30) = &input.secret_id {
object.key("SecretId").string(var_30.as_str());
}
if let Some(var_31) = &input.version_id {
object.key("VersionId").string(var_31.as_str());
}
if let Some(var_32) = &input.version_stage {
object.key("VersionStage").string(var_32.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_secrets_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListSecretsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_33) = &input.include_planned_deletion {
object.key("IncludePlannedDeletion").boolean(*var_33);
}
if let Some(var_34) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_34).into()),
);
}
if let Some(var_35) = &input.next_token {
object.key("NextToken").string(var_35.as_str());
}
if let Some(var_36) = &input.filters {
let mut array_37 = object.key("Filters").start_array();
for item_38 in var_36 {
{
#[allow(unused_mut)]
let mut object_39 = array_37.value().start_object();
crate::json_ser::serialize_structure_crate_model_filter(&mut object_39, item_38)?;
object_39.finish();
}
}
array_37.finish();
}
if let Some(var_40) = &input.sort_order {
object.key("SortOrder").string(var_40.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_secret_version_ids_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListSecretVersionIdsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_41) = &input.secret_id {
object.key("SecretId").string(var_41.as_str());
}
if let Some(var_42) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_42).into()),
);
}
if let Some(var_43) = &input.next_token {
object.key("NextToken").string(var_43.as_str());
}
if let Some(var_44) = &input.include_deprecated {
object.key("IncludeDeprecated").boolean(*var_44);
}
Ok(())
}
pub fn serialize_structure_crate_input_put_resource_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutResourcePolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_45) = &input.secret_id {
object.key("SecretId").string(var_45.as_str());
}
if let Some(var_46) = &input.resource_policy {
object.key("ResourcePolicy").string(var_46.as_str());
}
if let Some(var_47) = &input.block_public_policy {
object.key("BlockPublicPolicy").boolean(*var_47);
}
Ok(())
}
pub fn serialize_structure_crate_input_put_secret_value_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutSecretValueInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_48) = &input.secret_id {
object.key("SecretId").string(var_48.as_str());
}
if let Some(var_49) = &input.client_request_token {
object.key("ClientRequestToken").string(var_49.as_str());
}
if let Some(var_50) = &input.secret_binary {
object
.key("SecretBinary")
.string_unchecked(&aws_smithy_types::base64::encode(var_50));
}
if let Some(var_51) = &input.secret_string {
object.key("SecretString").string(var_51.as_str());
}
if let Some(var_52) = &input.version_stages {
let mut array_53 = object.key("VersionStages").start_array();
for item_54 in var_52 {
{
array_53.value().string(item_54.as_str());
}
}
array_53.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_remove_regions_from_replication_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RemoveRegionsFromReplicationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_55) = &input.secret_id {
object.key("SecretId").string(var_55.as_str());
}
if let Some(var_56) = &input.remove_replica_regions {
let mut array_57 = object.key("RemoveReplicaRegions").start_array();
for item_58 in var_56 {
{
array_57.value().string(item_58.as_str());
}
}
array_57.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_replicate_secret_to_regions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ReplicateSecretToRegionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_59) = &input.secret_id {
object.key("SecretId").string(var_59.as_str());
}
if let Some(var_60) = &input.add_replica_regions {
let mut array_61 = object.key("AddReplicaRegions").start_array();
for item_62 in var_60 {
{
#[allow(unused_mut)]
let mut object_63 = array_61.value().start_object();
crate::json_ser::serialize_structure_crate_model_replica_region_type(
&mut object_63,
item_62,
)?;
object_63.finish();
}
}
array_61.finish();
}
if input.force_overwrite_replica_secret {
object
.key("ForceOverwriteReplicaSecret")
.boolean(input.force_overwrite_replica_secret);
}
Ok(())
}
pub fn serialize_structure_crate_input_restore_secret_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RestoreSecretInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_64) = &input.secret_id {
object.key("SecretId").string(var_64.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_rotate_secret_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RotateSecretInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_65) = &input.secret_id {
object.key("SecretId").string(var_65.as_str());
}
if let Some(var_66) = &input.client_request_token {
object.key("ClientRequestToken").string(var_66.as_str());
}
if let Some(var_67) = &input.rotation_lambda_arn {
object.key("RotationLambdaARN").string(var_67.as_str());
}
if let Some(var_68) = &input.rotation_rules {
#[allow(unused_mut)]
let mut object_69 = object.key("RotationRules").start_object();
crate::json_ser::serialize_structure_crate_model_rotation_rules_type(
&mut object_69,
var_68,
)?;
object_69.finish();
}
if let Some(var_70) = &input.rotate_immediately {
object.key("RotateImmediately").boolean(*var_70);
}
Ok(())
}
pub fn serialize_structure_crate_input_stop_replication_to_replica_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StopReplicationToReplicaInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_71) = &input.secret_id {
object.key("SecretId").string(var_71.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_72) = &input.secret_id {
object.key("SecretId").string(var_72.as_str());
}
if let Some(var_73) = &input.tags {
let mut array_74 = object.key("Tags").start_array();
for item_75 in var_73 {
{
#[allow(unused_mut)]
let mut object_76 = array_74.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_76, item_75)?;
object_76.finish();
}
}
array_74.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_untag_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UntagResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_77) = &input.secret_id {
object.key("SecretId").string(var_77.as_str());
}
if let Some(var_78) = &input.tag_keys {
let mut array_79 = object.key("TagKeys").start_array();
for item_80 in var_78 {
{
array_79.value().string(item_80.as_str());
}
}
array_79.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_secret_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateSecretInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_81) = &input.secret_id {
object.key("SecretId").string(var_81.as_str());
}
if let Some(var_82) = &input.client_request_token {
object.key("ClientRequestToken").string(var_82.as_str());
}
if let Some(var_83) = &input.description {
object.key("Description").string(var_83.as_str());
}
if let Some(var_84) = &input.kms_key_id {
object.key("KmsKeyId").string(var_84.as_str());
}
if let Some(var_85) = &input.secret_binary {
object
.key("SecretBinary")
.string_unchecked(&aws_smithy_types::base64::encode(var_85));
}
if let Some(var_86) = &input.secret_string {
object.key("SecretString").string(var_86.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_secret_version_stage_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateSecretVersionStageInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_87) = &input.secret_id {
object.key("SecretId").string(var_87.as_str());
}
if let Some(var_88) = &input.version_stage {
object.key("VersionStage").string(var_88.as_str());
}
if let Some(var_89) = &input.remove_from_version_id {
object.key("RemoveFromVersionId").string(var_89.as_str());
}
if let Some(var_90) = &input.move_to_version_id {
object.key("MoveToVersionId").string(var_90.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_validate_resource_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ValidateResourcePolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_91) = &input.secret_id {
object.key("SecretId").string(var_91.as_str());
}
if let Some(var_92) = &input.resource_policy {
object.key("ResourcePolicy").string(var_92.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_93) = &input.key {
object.key("Key").string(var_93.as_str());
}
if let Some(var_94) = &input.value {
object.key("Value").string(var_94.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_replica_region_type(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ReplicaRegionType,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_95) = &input.region {
object.key("Region").string(var_95.as_str());
}
if let Some(var_96) = &input.kms_key_id {
object.key("KmsKeyId").string(var_96.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_97) = &input.key {
object.key("Key").string(var_97.as_str());
}
if let Some(var_98) = &input.values {
let mut array_99 = object.key("Values").start_array();
for item_100 in var_98 {
{
array_99.value().string(item_100.as_str());
}
}
array_99.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_rotation_rules_type(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RotationRulesType,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_101) = &input.automatically_after_days {
object.key("AutomaticallyAfterDays").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_101).into()),
);
}
if let Some(var_102) = &input.duration {
object.key("Duration").string(var_102.as_str());
}
if let Some(var_103) = &input.schedule_expression {
object.key("ScheduleExpression").string(var_103.as_str());
}
Ok(())
}