pub fn serialize_structure_crate_input_cancel_key_deletion_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CancelKeyDeletionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.key_id {
object.key("KeyId").string(var_1.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_connect_custom_key_store_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ConnectCustomKeyStoreInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2) = &input.custom_key_store_id {
object.key("CustomKeyStoreId").string(var_2.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_alias_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateAliasInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3) = &input.alias_name {
object.key("AliasName").string(var_3.as_str());
}
if let Some(var_4) = &input.target_key_id {
object.key("TargetKeyId").string(var_4.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_custom_key_store_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateCustomKeyStoreInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_5) = &input.custom_key_store_name {
object.key("CustomKeyStoreName").string(var_5.as_str());
}
if let Some(var_6) = &input.cloud_hsm_cluster_id {
object.key("CloudHsmClusterId").string(var_6.as_str());
}
if let Some(var_7) = &input.trust_anchor_certificate {
object.key("TrustAnchorCertificate").string(var_7.as_str());
}
if let Some(var_8) = &input.key_store_password {
object.key("KeyStorePassword").string(var_8.as_str());
}
if let Some(var_9) = &input.custom_key_store_type {
object.key("CustomKeyStoreType").string(var_9.as_str());
}
if let Some(var_10) = &input.xks_proxy_uri_endpoint {
object.key("XksProxyUriEndpoint").string(var_10.as_str());
}
if let Some(var_11) = &input.xks_proxy_uri_path {
object.key("XksProxyUriPath").string(var_11.as_str());
}
if let Some(var_12) = &input.xks_proxy_vpc_endpoint_service_name {
object
.key("XksProxyVpcEndpointServiceName")
.string(var_12.as_str());
}
if let Some(var_13) = &input.xks_proxy_authentication_credential {
#[allow(unused_mut)]
let mut object_14 = object
.key("XksProxyAuthenticationCredential")
.start_object();
crate::json_ser::serialize_structure_crate_model_xks_proxy_authentication_credential_type(
&mut object_14,
var_13,
)?;
object_14.finish();
}
if let Some(var_15) = &input.xks_proxy_connectivity {
object.key("XksProxyConnectivity").string(var_15.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_grant_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateGrantInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_16) = &input.key_id {
object.key("KeyId").string(var_16.as_str());
}
if let Some(var_17) = &input.grantee_principal {
object.key("GranteePrincipal").string(var_17.as_str());
}
if let Some(var_18) = &input.retiring_principal {
object.key("RetiringPrincipal").string(var_18.as_str());
}
if let Some(var_19) = &input.operations {
let mut array_20 = object.key("Operations").start_array();
for item_21 in var_19 {
{
array_20.value().string(item_21.as_str());
}
}
array_20.finish();
}
if let Some(var_22) = &input.constraints {
#[allow(unused_mut)]
let mut object_23 = object.key("Constraints").start_object();
crate::json_ser::serialize_structure_crate_model_grant_constraints(&mut object_23, var_22)?;
object_23.finish();
}
if let Some(var_24) = &input.grant_tokens {
let mut array_25 = object.key("GrantTokens").start_array();
for item_26 in var_24 {
{
array_25.value().string(item_26.as_str());
}
}
array_25.finish();
}
if let Some(var_27) = &input.name {
object.key("Name").string(var_27.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_key_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateKeyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_28) = &input.policy {
object.key("Policy").string(var_28.as_str());
}
if let Some(var_29) = &input.description {
object.key("Description").string(var_29.as_str());
}
if let Some(var_30) = &input.key_usage {
object.key("KeyUsage").string(var_30.as_str());
}
if let Some(var_31) = &input.customer_master_key_spec {
object.key("CustomerMasterKeySpec").string(var_31.as_str());
}
if let Some(var_32) = &input.key_spec {
object.key("KeySpec").string(var_32.as_str());
}
if let Some(var_33) = &input.origin {
object.key("Origin").string(var_33.as_str());
}
if let Some(var_34) = &input.custom_key_store_id {
object.key("CustomKeyStoreId").string(var_34.as_str());
}
if input.bypass_policy_lockout_safety_check {
object
.key("BypassPolicyLockoutSafetyCheck")
.boolean(input.bypass_policy_lockout_safety_check);
}
if let Some(var_35) = &input.tags {
let mut array_36 = object.key("Tags").start_array();
for item_37 in var_35 {
{
#[allow(unused_mut)]
let mut object_38 = array_36.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_38, item_37)?;
object_38.finish();
}
}
array_36.finish();
}
if let Some(var_39) = &input.multi_region {
object.key("MultiRegion").boolean(*var_39);
}
if let Some(var_40) = &input.xks_key_id {
object.key("XksKeyId").string(var_40.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_decrypt_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DecryptInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_41) = &input.ciphertext_blob {
object
.key("CiphertextBlob")
.string_unchecked(&aws_smithy_types::base64::encode(var_41));
}
if let Some(var_42) = &input.encryption_context {
#[allow(unused_mut)]
let mut object_43 = object.key("EncryptionContext").start_object();
for (key_44, value_45) in var_42 {
{
object_43.key(key_44.as_str()).string(value_45.as_str());
}
}
object_43.finish();
}
if let Some(var_46) = &input.grant_tokens {
let mut array_47 = object.key("GrantTokens").start_array();
for item_48 in var_46 {
{
array_47.value().string(item_48.as_str());
}
}
array_47.finish();
}
if let Some(var_49) = &input.key_id {
object.key("KeyId").string(var_49.as_str());
}
if let Some(var_50) = &input.encryption_algorithm {
object.key("EncryptionAlgorithm").string(var_50.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_alias_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteAliasInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_51) = &input.alias_name {
object.key("AliasName").string(var_51.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_custom_key_store_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteCustomKeyStoreInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_52) = &input.custom_key_store_id {
object.key("CustomKeyStoreId").string(var_52.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_imported_key_material_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteImportedKeyMaterialInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_53) = &input.key_id {
object.key("KeyId").string(var_53.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_custom_key_stores_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeCustomKeyStoresInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_54) = &input.custom_key_store_id {
object.key("CustomKeyStoreId").string(var_54.as_str());
}
if let Some(var_55) = &input.custom_key_store_name {
object.key("CustomKeyStoreName").string(var_55.as_str());
}
if let Some(var_56) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_56).into()),
);
}
if let Some(var_57) = &input.marker {
object.key("Marker").string(var_57.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_key_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeKeyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_58) = &input.key_id {
object.key("KeyId").string(var_58.as_str());
}
if let Some(var_59) = &input.grant_tokens {
let mut array_60 = object.key("GrantTokens").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_disable_key_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DisableKeyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_62) = &input.key_id {
object.key("KeyId").string(var_62.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_disable_key_rotation_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DisableKeyRotationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_63) = &input.key_id {
object.key("KeyId").string(var_63.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_disconnect_custom_key_store_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DisconnectCustomKeyStoreInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_64) = &input.custom_key_store_id {
object.key("CustomKeyStoreId").string(var_64.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_enable_key_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::EnableKeyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_65) = &input.key_id {
object.key("KeyId").string(var_65.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_enable_key_rotation_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::EnableKeyRotationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_66) = &input.key_id {
object.key("KeyId").string(var_66.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_encrypt_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::EncryptInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_67) = &input.key_id {
object.key("KeyId").string(var_67.as_str());
}
if let Some(var_68) = &input.plaintext {
object
.key("Plaintext")
.string_unchecked(&aws_smithy_types::base64::encode(var_68));
}
if let Some(var_69) = &input.encryption_context {
#[allow(unused_mut)]
let mut object_70 = object.key("EncryptionContext").start_object();
for (key_71, value_72) in var_69 {
{
object_70.key(key_71.as_str()).string(value_72.as_str());
}
}
object_70.finish();
}
if let Some(var_73) = &input.grant_tokens {
let mut array_74 = object.key("GrantTokens").start_array();
for item_75 in var_73 {
{
array_74.value().string(item_75.as_str());
}
}
array_74.finish();
}
if let Some(var_76) = &input.encryption_algorithm {
object.key("EncryptionAlgorithm").string(var_76.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_generate_data_key_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GenerateDataKeyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_77) = &input.key_id {
object.key("KeyId").string(var_77.as_str());
}
if let Some(var_78) = &input.encryption_context {
#[allow(unused_mut)]
let mut object_79 = object.key("EncryptionContext").start_object();
for (key_80, value_81) in var_78 {
{
object_79.key(key_80.as_str()).string(value_81.as_str());
}
}
object_79.finish();
}
if let Some(var_82) = &input.number_of_bytes {
object.key("NumberOfBytes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_82).into()),
);
}
if let Some(var_83) = &input.key_spec {
object.key("KeySpec").string(var_83.as_str());
}
if let Some(var_84) = &input.grant_tokens {
let mut array_85 = object.key("GrantTokens").start_array();
for item_86 in var_84 {
{
array_85.value().string(item_86.as_str());
}
}
array_85.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_generate_data_key_pair_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GenerateDataKeyPairInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_87) = &input.encryption_context {
#[allow(unused_mut)]
let mut object_88 = object.key("EncryptionContext").start_object();
for (key_89, value_90) in var_87 {
{
object_88.key(key_89.as_str()).string(value_90.as_str());
}
}
object_88.finish();
}
if let Some(var_91) = &input.key_id {
object.key("KeyId").string(var_91.as_str());
}
if let Some(var_92) = &input.key_pair_spec {
object.key("KeyPairSpec").string(var_92.as_str());
}
if let Some(var_93) = &input.grant_tokens {
let mut array_94 = object.key("GrantTokens").start_array();
for item_95 in var_93 {
{
array_94.value().string(item_95.as_str());
}
}
array_94.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_generate_data_key_pair_without_plaintext_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GenerateDataKeyPairWithoutPlaintextInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_96) = &input.encryption_context {
#[allow(unused_mut)]
let mut object_97 = object.key("EncryptionContext").start_object();
for (key_98, value_99) in var_96 {
{
object_97.key(key_98.as_str()).string(value_99.as_str());
}
}
object_97.finish();
}
if let Some(var_100) = &input.key_id {
object.key("KeyId").string(var_100.as_str());
}
if let Some(var_101) = &input.key_pair_spec {
object.key("KeyPairSpec").string(var_101.as_str());
}
if let Some(var_102) = &input.grant_tokens {
let mut array_103 = object.key("GrantTokens").start_array();
for item_104 in var_102 {
{
array_103.value().string(item_104.as_str());
}
}
array_103.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_generate_data_key_without_plaintext_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GenerateDataKeyWithoutPlaintextInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_105) = &input.key_id {
object.key("KeyId").string(var_105.as_str());
}
if let Some(var_106) = &input.encryption_context {
#[allow(unused_mut)]
let mut object_107 = object.key("EncryptionContext").start_object();
for (key_108, value_109) in var_106 {
{
object_107.key(key_108.as_str()).string(value_109.as_str());
}
}
object_107.finish();
}
if let Some(var_110) = &input.key_spec {
object.key("KeySpec").string(var_110.as_str());
}
if let Some(var_111) = &input.number_of_bytes {
object.key("NumberOfBytes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_111).into()),
);
}
if let Some(var_112) = &input.grant_tokens {
let mut array_113 = object.key("GrantTokens").start_array();
for item_114 in var_112 {
{
array_113.value().string(item_114.as_str());
}
}
array_113.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_generate_mac_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GenerateMacInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_115) = &input.message {
object
.key("Message")
.string_unchecked(&aws_smithy_types::base64::encode(var_115));
}
if let Some(var_116) = &input.key_id {
object.key("KeyId").string(var_116.as_str());
}
if let Some(var_117) = &input.mac_algorithm {
object.key("MacAlgorithm").string(var_117.as_str());
}
if let Some(var_118) = &input.grant_tokens {
let mut array_119 = object.key("GrantTokens").start_array();
for item_120 in var_118 {
{
array_119.value().string(item_120.as_str());
}
}
array_119.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_generate_random_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GenerateRandomInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_121) = &input.number_of_bytes {
object.key("NumberOfBytes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_121).into()),
);
}
if let Some(var_122) = &input.custom_key_store_id {
object.key("CustomKeyStoreId").string(var_122.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_key_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetKeyPolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_123) = &input.key_id {
object.key("KeyId").string(var_123.as_str());
}
if let Some(var_124) = &input.policy_name {
object.key("PolicyName").string(var_124.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_key_rotation_status_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetKeyRotationStatusInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_125) = &input.key_id {
object.key("KeyId").string(var_125.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_parameters_for_import_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetParametersForImportInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_126) = &input.key_id {
object.key("KeyId").string(var_126.as_str());
}
if let Some(var_127) = &input.wrapping_algorithm {
object.key("WrappingAlgorithm").string(var_127.as_str());
}
if let Some(var_128) = &input.wrapping_key_spec {
object.key("WrappingKeySpec").string(var_128.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_public_key_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetPublicKeyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_129) = &input.key_id {
object.key("KeyId").string(var_129.as_str());
}
if let Some(var_130) = &input.grant_tokens {
let mut array_131 = object.key("GrantTokens").start_array();
for item_132 in var_130 {
{
array_131.value().string(item_132.as_str());
}
}
array_131.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_import_key_material_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ImportKeyMaterialInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_133) = &input.key_id {
object.key("KeyId").string(var_133.as_str());
}
if let Some(var_134) = &input.import_token {
object
.key("ImportToken")
.string_unchecked(&aws_smithy_types::base64::encode(var_134));
}
if let Some(var_135) = &input.encrypted_key_material {
object
.key("EncryptedKeyMaterial")
.string_unchecked(&aws_smithy_types::base64::encode(var_135));
}
if let Some(var_136) = &input.valid_to {
object
.key("ValidTo")
.date_time(var_136, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_137) = &input.expiration_model {
object.key("ExpirationModel").string(var_137.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_aliases_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListAliasesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_138) = &input.key_id {
object.key("KeyId").string(var_138.as_str());
}
if let Some(var_139) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_139).into()),
);
}
if let Some(var_140) = &input.marker {
object.key("Marker").string(var_140.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_grants_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListGrantsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_141) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_141).into()),
);
}
if let Some(var_142) = &input.marker {
object.key("Marker").string(var_142.as_str());
}
if let Some(var_143) = &input.key_id {
object.key("KeyId").string(var_143.as_str());
}
if let Some(var_144) = &input.grant_id {
object.key("GrantId").string(var_144.as_str());
}
if let Some(var_145) = &input.grantee_principal {
object.key("GranteePrincipal").string(var_145.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_key_policies_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListKeyPoliciesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_146) = &input.key_id {
object.key("KeyId").string(var_146.as_str());
}
if let Some(var_147) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_147).into()),
);
}
if let Some(var_148) = &input.marker {
object.key("Marker").string(var_148.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_keys_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListKeysInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_149) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_149).into()),
);
}
if let Some(var_150) = &input.marker {
object.key("Marker").string(var_150.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_resource_tags_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListResourceTagsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_151) = &input.key_id {
object.key("KeyId").string(var_151.as_str());
}
if let Some(var_152) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_152).into()),
);
}
if let Some(var_153) = &input.marker {
object.key("Marker").string(var_153.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_retirable_grants_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListRetirableGrantsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_154) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_154).into()),
);
}
if let Some(var_155) = &input.marker {
object.key("Marker").string(var_155.as_str());
}
if let Some(var_156) = &input.retiring_principal {
object.key("RetiringPrincipal").string(var_156.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_put_key_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutKeyPolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_157) = &input.key_id {
object.key("KeyId").string(var_157.as_str());
}
if let Some(var_158) = &input.policy_name {
object.key("PolicyName").string(var_158.as_str());
}
if let Some(var_159) = &input.policy {
object.key("Policy").string(var_159.as_str());
}
if input.bypass_policy_lockout_safety_check {
object
.key("BypassPolicyLockoutSafetyCheck")
.boolean(input.bypass_policy_lockout_safety_check);
}
Ok(())
}
pub fn serialize_structure_crate_input_re_encrypt_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ReEncryptInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_160) = &input.ciphertext_blob {
object
.key("CiphertextBlob")
.string_unchecked(&aws_smithy_types::base64::encode(var_160));
}
if let Some(var_161) = &input.source_encryption_context {
#[allow(unused_mut)]
let mut object_162 = object.key("SourceEncryptionContext").start_object();
for (key_163, value_164) in var_161 {
{
object_162.key(key_163.as_str()).string(value_164.as_str());
}
}
object_162.finish();
}
if let Some(var_165) = &input.source_key_id {
object.key("SourceKeyId").string(var_165.as_str());
}
if let Some(var_166) = &input.destination_key_id {
object.key("DestinationKeyId").string(var_166.as_str());
}
if let Some(var_167) = &input.destination_encryption_context {
#[allow(unused_mut)]
let mut object_168 = object.key("DestinationEncryptionContext").start_object();
for (key_169, value_170) in var_167 {
{
object_168.key(key_169.as_str()).string(value_170.as_str());
}
}
object_168.finish();
}
if let Some(var_171) = &input.source_encryption_algorithm {
object
.key("SourceEncryptionAlgorithm")
.string(var_171.as_str());
}
if let Some(var_172) = &input.destination_encryption_algorithm {
object
.key("DestinationEncryptionAlgorithm")
.string(var_172.as_str());
}
if let Some(var_173) = &input.grant_tokens {
let mut array_174 = object.key("GrantTokens").start_array();
for item_175 in var_173 {
{
array_174.value().string(item_175.as_str());
}
}
array_174.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_replicate_key_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ReplicateKeyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_176) = &input.key_id {
object.key("KeyId").string(var_176.as_str());
}
if let Some(var_177) = &input.replica_region {
object.key("ReplicaRegion").string(var_177.as_str());
}
if let Some(var_178) = &input.policy {
object.key("Policy").string(var_178.as_str());
}
if input.bypass_policy_lockout_safety_check {
object
.key("BypassPolicyLockoutSafetyCheck")
.boolean(input.bypass_policy_lockout_safety_check);
}
if let Some(var_179) = &input.description {
object.key("Description").string(var_179.as_str());
}
if let Some(var_180) = &input.tags {
let mut array_181 = object.key("Tags").start_array();
for item_182 in var_180 {
{
#[allow(unused_mut)]
let mut object_183 = array_181.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_183, item_182)?;
object_183.finish();
}
}
array_181.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_retire_grant_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RetireGrantInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_184) = &input.grant_token {
object.key("GrantToken").string(var_184.as_str());
}
if let Some(var_185) = &input.key_id {
object.key("KeyId").string(var_185.as_str());
}
if let Some(var_186) = &input.grant_id {
object.key("GrantId").string(var_186.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_revoke_grant_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RevokeGrantInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_187) = &input.key_id {
object.key("KeyId").string(var_187.as_str());
}
if let Some(var_188) = &input.grant_id {
object.key("GrantId").string(var_188.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_schedule_key_deletion_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ScheduleKeyDeletionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_189) = &input.key_id {
object.key("KeyId").string(var_189.as_str());
}
if let Some(var_190) = &input.pending_window_in_days {
object.key("PendingWindowInDays").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_190).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_sign_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::SignInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_191) = &input.key_id {
object.key("KeyId").string(var_191.as_str());
}
if let Some(var_192) = &input.message {
object
.key("Message")
.string_unchecked(&aws_smithy_types::base64::encode(var_192));
}
if let Some(var_193) = &input.message_type {
object.key("MessageType").string(var_193.as_str());
}
if let Some(var_194) = &input.grant_tokens {
let mut array_195 = object.key("GrantTokens").start_array();
for item_196 in var_194 {
{
array_195.value().string(item_196.as_str());
}
}
array_195.finish();
}
if let Some(var_197) = &input.signing_algorithm {
object.key("SigningAlgorithm").string(var_197.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_198) = &input.key_id {
object.key("KeyId").string(var_198.as_str());
}
if let Some(var_199) = &input.tags {
let mut array_200 = object.key("Tags").start_array();
for item_201 in var_199 {
{
#[allow(unused_mut)]
let mut object_202 = array_200.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_202, item_201)?;
object_202.finish();
}
}
array_200.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_203) = &input.key_id {
object.key("KeyId").string(var_203.as_str());
}
if let Some(var_204) = &input.tag_keys {
let mut array_205 = object.key("TagKeys").start_array();
for item_206 in var_204 {
{
array_205.value().string(item_206.as_str());
}
}
array_205.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_alias_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateAliasInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_207) = &input.alias_name {
object.key("AliasName").string(var_207.as_str());
}
if let Some(var_208) = &input.target_key_id {
object.key("TargetKeyId").string(var_208.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_custom_key_store_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateCustomKeyStoreInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_209) = &input.custom_key_store_id {
object.key("CustomKeyStoreId").string(var_209.as_str());
}
if let Some(var_210) = &input.new_custom_key_store_name {
object.key("NewCustomKeyStoreName").string(var_210.as_str());
}
if let Some(var_211) = &input.key_store_password {
object.key("KeyStorePassword").string(var_211.as_str());
}
if let Some(var_212) = &input.cloud_hsm_cluster_id {
object.key("CloudHsmClusterId").string(var_212.as_str());
}
if let Some(var_213) = &input.xks_proxy_uri_endpoint {
object.key("XksProxyUriEndpoint").string(var_213.as_str());
}
if let Some(var_214) = &input.xks_proxy_uri_path {
object.key("XksProxyUriPath").string(var_214.as_str());
}
if let Some(var_215) = &input.xks_proxy_vpc_endpoint_service_name {
object
.key("XksProxyVpcEndpointServiceName")
.string(var_215.as_str());
}
if let Some(var_216) = &input.xks_proxy_authentication_credential {
#[allow(unused_mut)]
let mut object_217 = object
.key("XksProxyAuthenticationCredential")
.start_object();
crate::json_ser::serialize_structure_crate_model_xks_proxy_authentication_credential_type(
&mut object_217,
var_216,
)?;
object_217.finish();
}
if let Some(var_218) = &input.xks_proxy_connectivity {
object.key("XksProxyConnectivity").string(var_218.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_key_description_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateKeyDescriptionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_219) = &input.key_id {
object.key("KeyId").string(var_219.as_str());
}
if let Some(var_220) = &input.description {
object.key("Description").string(var_220.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_primary_region_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdatePrimaryRegionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_221) = &input.key_id {
object.key("KeyId").string(var_221.as_str());
}
if let Some(var_222) = &input.primary_region {
object.key("PrimaryRegion").string(var_222.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_verify_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::VerifyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_223) = &input.key_id {
object.key("KeyId").string(var_223.as_str());
}
if let Some(var_224) = &input.message {
object
.key("Message")
.string_unchecked(&aws_smithy_types::base64::encode(var_224));
}
if let Some(var_225) = &input.message_type {
object.key("MessageType").string(var_225.as_str());
}
if let Some(var_226) = &input.signature {
object
.key("Signature")
.string_unchecked(&aws_smithy_types::base64::encode(var_226));
}
if let Some(var_227) = &input.signing_algorithm {
object.key("SigningAlgorithm").string(var_227.as_str());
}
if let Some(var_228) = &input.grant_tokens {
let mut array_229 = object.key("GrantTokens").start_array();
for item_230 in var_228 {
{
array_229.value().string(item_230.as_str());
}
}
array_229.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_verify_mac_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::VerifyMacInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_231) = &input.message {
object
.key("Message")
.string_unchecked(&aws_smithy_types::base64::encode(var_231));
}
if let Some(var_232) = &input.key_id {
object.key("KeyId").string(var_232.as_str());
}
if let Some(var_233) = &input.mac_algorithm {
object.key("MacAlgorithm").string(var_233.as_str());
}
if let Some(var_234) = &input.mac {
object
.key("Mac")
.string_unchecked(&aws_smithy_types::base64::encode(var_234));
}
if let Some(var_235) = &input.grant_tokens {
let mut array_236 = object.key("GrantTokens").start_array();
for item_237 in var_235 {
{
array_236.value().string(item_237.as_str());
}
}
array_236.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_xks_proxy_authentication_credential_type(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::XksProxyAuthenticationCredentialType,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_238) = &input.access_key_id {
object.key("AccessKeyId").string(var_238.as_str());
}
if let Some(var_239) = &input.raw_secret_access_key {
object.key("RawSecretAccessKey").string(var_239.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_grant_constraints(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GrantConstraints,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_240) = &input.encryption_context_subset {
#[allow(unused_mut)]
let mut object_241 = object.key("EncryptionContextSubset").start_object();
for (key_242, value_243) in var_240 {
{
object_241.key(key_242.as_str()).string(value_243.as_str());
}
}
object_241.finish();
}
if let Some(var_244) = &input.encryption_context_equals {
#[allow(unused_mut)]
let mut object_245 = object.key("EncryptionContextEquals").start_object();
for (key_246, value_247) in var_244 {
{
object_245.key(key_246.as_str()).string(value_247.as_str());
}
}
object_245.finish();
}
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_248) = &input.tag_key {
object.key("TagKey").string(var_248.as_str());
}
if let Some(var_249) = &input.tag_value {
object.key("TagValue").string(var_249.as_str());
}
Ok(())
}