pub fn serialize_structure_crate_input_accept_shared_directory_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AcceptSharedDirectoryInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.shared_directory_id {
object.key("SharedDirectoryId").string(var_1.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_add_ip_routes_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AddIpRoutesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_2) = &input.directory_id {
object.key("DirectoryId").string(var_2.as_str());
}
if let Some(var_3) = &input.ip_routes {
let mut array_4 = object.key("IpRoutes").start_array();
for item_5 in var_3 {
{
#[allow(unused_mut)]
let mut object_6 = array_4.value().start_object();
crate::json_ser::serialize_structure_crate_model_ip_route(&mut object_6, item_5)?;
object_6.finish();
}
}
array_4.finish();
}
if input.update_security_group_for_directory_controllers {
object
.key("UpdateSecurityGroupForDirectoryControllers")
.boolean(input.update_security_group_for_directory_controllers);
}
Ok(())
}
pub fn serialize_structure_crate_input_add_region_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AddRegionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_7) = &input.directory_id {
object.key("DirectoryId").string(var_7.as_str());
}
if let Some(var_8) = &input.region_name {
object.key("RegionName").string(var_8.as_str());
}
if let Some(var_9) = &input.vpc_settings {
#[allow(unused_mut)]
let mut object_10 = object.key("VPCSettings").start_object();
crate::json_ser::serialize_structure_crate_model_directory_vpc_settings(
&mut object_10,
var_9,
)?;
object_10.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_add_tags_to_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AddTagsToResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_11) = &input.resource_id {
object.key("ResourceId").string(var_11.as_str());
}
if let Some(var_12) = &input.tags {
let mut array_13 = object.key("Tags").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_tag(&mut object_15, item_14)?;
object_15.finish();
}
}
array_13.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_cancel_schema_extension_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CancelSchemaExtensionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_16) = &input.directory_id {
object.key("DirectoryId").string(var_16.as_str());
}
if let Some(var_17) = &input.schema_extension_id {
object.key("SchemaExtensionId").string(var_17.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_connect_directory_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ConnectDirectoryInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_18) = &input.name {
object.key("Name").string(var_18.as_str());
}
if let Some(var_19) = &input.short_name {
object.key("ShortName").string(var_19.as_str());
}
if let Some(var_20) = &input.password {
object.key("Password").string(var_20.as_str());
}
if let Some(var_21) = &input.description {
object.key("Description").string(var_21.as_str());
}
if let Some(var_22) = &input.size {
object.key("Size").string(var_22.as_str());
}
if let Some(var_23) = &input.connect_settings {
#[allow(unused_mut)]
let mut object_24 = object.key("ConnectSettings").start_object();
crate::json_ser::serialize_structure_crate_model_directory_connect_settings(
&mut object_24,
var_23,
)?;
object_24.finish();
}
if let Some(var_25) = &input.tags {
let mut array_26 = object.key("Tags").start_array();
for item_27 in var_25 {
{
#[allow(unused_mut)]
let mut object_28 = array_26.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_28, item_27)?;
object_28.finish();
}
}
array_26.finish();
}
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_29) = &input.directory_id {
object.key("DirectoryId").string(var_29.as_str());
}
if let Some(var_30) = &input.alias {
object.key("Alias").string(var_30.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_computer_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateComputerInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_31) = &input.directory_id {
object.key("DirectoryId").string(var_31.as_str());
}
if let Some(var_32) = &input.computer_name {
object.key("ComputerName").string(var_32.as_str());
}
if let Some(var_33) = &input.password {
object.key("Password").string(var_33.as_str());
}
if let Some(var_34) = &input.organizational_unit_distinguished_name {
object
.key("OrganizationalUnitDistinguishedName")
.string(var_34.as_str());
}
if let Some(var_35) = &input.computer_attributes {
let mut array_36 = object.key("ComputerAttributes").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_attribute(
&mut object_38,
item_37,
)?;
object_38.finish();
}
}
array_36.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_conditional_forwarder_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateConditionalForwarderInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_39) = &input.directory_id {
object.key("DirectoryId").string(var_39.as_str());
}
if let Some(var_40) = &input.remote_domain_name {
object.key("RemoteDomainName").string(var_40.as_str());
}
if let Some(var_41) = &input.dns_ip_addrs {
let mut array_42 = object.key("DnsIpAddrs").start_array();
for item_43 in var_41 {
{
array_42.value().string(item_43.as_str());
}
}
array_42.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_directory_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateDirectoryInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_44) = &input.name {
object.key("Name").string(var_44.as_str());
}
if let Some(var_45) = &input.short_name {
object.key("ShortName").string(var_45.as_str());
}
if let Some(var_46) = &input.password {
object.key("Password").string(var_46.as_str());
}
if let Some(var_47) = &input.description {
object.key("Description").string(var_47.as_str());
}
if let Some(var_48) = &input.size {
object.key("Size").string(var_48.as_str());
}
if let Some(var_49) = &input.vpc_settings {
#[allow(unused_mut)]
let mut object_50 = object.key("VpcSettings").start_object();
crate::json_ser::serialize_structure_crate_model_directory_vpc_settings(
&mut object_50,
var_49,
)?;
object_50.finish();
}
if let Some(var_51) = &input.tags {
let mut array_52 = object.key("Tags").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_tag(&mut object_54, item_53)?;
object_54.finish();
}
}
array_52.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_log_subscription_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateLogSubscriptionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_55) = &input.directory_id {
object.key("DirectoryId").string(var_55.as_str());
}
if let Some(var_56) = &input.log_group_name {
object.key("LogGroupName").string(var_56.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_microsoft_ad_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateMicrosoftAdInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_57) = &input.name {
object.key("Name").string(var_57.as_str());
}
if let Some(var_58) = &input.short_name {
object.key("ShortName").string(var_58.as_str());
}
if let Some(var_59) = &input.password {
object.key("Password").string(var_59.as_str());
}
if let Some(var_60) = &input.description {
object.key("Description").string(var_60.as_str());
}
if let Some(var_61) = &input.vpc_settings {
#[allow(unused_mut)]
let mut object_62 = object.key("VpcSettings").start_object();
crate::json_ser::serialize_structure_crate_model_directory_vpc_settings(
&mut object_62,
var_61,
)?;
object_62.finish();
}
if let Some(var_63) = &input.edition {
object.key("Edition").string(var_63.as_str());
}
if let Some(var_64) = &input.tags {
let mut array_65 = object.key("Tags").start_array();
for item_66 in var_64 {
{
#[allow(unused_mut)]
let mut object_67 = array_65.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_67, item_66)?;
object_67.finish();
}
}
array_65.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_snapshot_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateSnapshotInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_68) = &input.directory_id {
object.key("DirectoryId").string(var_68.as_str());
}
if let Some(var_69) = &input.name {
object.key("Name").string(var_69.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_trust_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateTrustInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_70) = &input.directory_id {
object.key("DirectoryId").string(var_70.as_str());
}
if let Some(var_71) = &input.remote_domain_name {
object.key("RemoteDomainName").string(var_71.as_str());
}
if let Some(var_72) = &input.trust_password {
object.key("TrustPassword").string(var_72.as_str());
}
if let Some(var_73) = &input.trust_direction {
object.key("TrustDirection").string(var_73.as_str());
}
if let Some(var_74) = &input.trust_type {
object.key("TrustType").string(var_74.as_str());
}
if let Some(var_75) = &input.conditional_forwarder_ip_addrs {
let mut array_76 = object.key("ConditionalForwarderIpAddrs").start_array();
for item_77 in var_75 {
{
array_76.value().string(item_77.as_str());
}
}
array_76.finish();
}
if let Some(var_78) = &input.selective_auth {
object.key("SelectiveAuth").string(var_78.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_conditional_forwarder_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteConditionalForwarderInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_79) = &input.directory_id {
object.key("DirectoryId").string(var_79.as_str());
}
if let Some(var_80) = &input.remote_domain_name {
object.key("RemoteDomainName").string(var_80.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_directory_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteDirectoryInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_81) = &input.directory_id {
object.key("DirectoryId").string(var_81.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_log_subscription_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteLogSubscriptionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_82) = &input.directory_id {
object.key("DirectoryId").string(var_82.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_snapshot_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteSnapshotInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_83) = &input.snapshot_id {
object.key("SnapshotId").string(var_83.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_trust_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteTrustInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_84) = &input.trust_id {
object.key("TrustId").string(var_84.as_str());
}
if input.delete_associated_conditional_forwarder {
object
.key("DeleteAssociatedConditionalForwarder")
.boolean(input.delete_associated_conditional_forwarder);
}
Ok(())
}
pub fn serialize_structure_crate_input_deregister_certificate_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeregisterCertificateInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_85) = &input.directory_id {
object.key("DirectoryId").string(var_85.as_str());
}
if let Some(var_86) = &input.certificate_id {
object.key("CertificateId").string(var_86.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_deregister_event_topic_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeregisterEventTopicInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_87) = &input.directory_id {
object.key("DirectoryId").string(var_87.as_str());
}
if let Some(var_88) = &input.topic_name {
object.key("TopicName").string(var_88.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_certificate_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeCertificateInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_89) = &input.directory_id {
object.key("DirectoryId").string(var_89.as_str());
}
if let Some(var_90) = &input.certificate_id {
object.key("CertificateId").string(var_90.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_client_authentication_settings_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeClientAuthenticationSettingsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_91) = &input.directory_id {
object.key("DirectoryId").string(var_91.as_str());
}
if let Some(var_92) = &input.r#type {
object.key("Type").string(var_92.as_str());
}
if let Some(var_93) = &input.next_token {
object.key("NextToken").string(var_93.as_str());
}
if let Some(var_94) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_94).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_conditional_forwarders_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeConditionalForwardersInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_95) = &input.directory_id {
object.key("DirectoryId").string(var_95.as_str());
}
if let Some(var_96) = &input.remote_domain_names {
let mut array_97 = object.key("RemoteDomainNames").start_array();
for item_98 in var_96 {
{
array_97.value().string(item_98.as_str());
}
}
array_97.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_directories_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeDirectoriesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_99) = &input.directory_ids {
let mut array_100 = object.key("DirectoryIds").start_array();
for item_101 in var_99 {
{
array_100.value().string(item_101.as_str());
}
}
array_100.finish();
}
if let Some(var_102) = &input.next_token {
object.key("NextToken").string(var_102.as_str());
}
if let Some(var_103) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_103).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_domain_controllers_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeDomainControllersInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_104) = &input.directory_id {
object.key("DirectoryId").string(var_104.as_str());
}
if let Some(var_105) = &input.domain_controller_ids {
let mut array_106 = object.key("DomainControllerIds").start_array();
for item_107 in var_105 {
{
array_106.value().string(item_107.as_str());
}
}
array_106.finish();
}
if let Some(var_108) = &input.next_token {
object.key("NextToken").string(var_108.as_str());
}
if let Some(var_109) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_109).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_event_topics_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeEventTopicsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_110) = &input.directory_id {
object.key("DirectoryId").string(var_110.as_str());
}
if let Some(var_111) = &input.topic_names {
let mut array_112 = object.key("TopicNames").start_array();
for item_113 in var_111 {
{
array_112.value().string(item_113.as_str());
}
}
array_112.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_ldaps_settings_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeLdapsSettingsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_114) = &input.directory_id {
object.key("DirectoryId").string(var_114.as_str());
}
if let Some(var_115) = &input.r#type {
object.key("Type").string(var_115.as_str());
}
if let Some(var_116) = &input.next_token {
object.key("NextToken").string(var_116.as_str());
}
if let Some(var_117) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_117).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_regions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeRegionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_118) = &input.directory_id {
object.key("DirectoryId").string(var_118.as_str());
}
if let Some(var_119) = &input.region_name {
object.key("RegionName").string(var_119.as_str());
}
if let Some(var_120) = &input.next_token {
object.key("NextToken").string(var_120.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_settings_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeSettingsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_121) = &input.directory_id {
object.key("DirectoryId").string(var_121.as_str());
}
if let Some(var_122) = &input.status {
object.key("Status").string(var_122.as_str());
}
if let Some(var_123) = &input.next_token {
object.key("NextToken").string(var_123.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_shared_directories_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeSharedDirectoriesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_124) = &input.owner_directory_id {
object.key("OwnerDirectoryId").string(var_124.as_str());
}
if let Some(var_125) = &input.shared_directory_ids {
let mut array_126 = object.key("SharedDirectoryIds").start_array();
for item_127 in var_125 {
{
array_126.value().string(item_127.as_str());
}
}
array_126.finish();
}
if let Some(var_128) = &input.next_token {
object.key("NextToken").string(var_128.as_str());
}
if let Some(var_129) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_129).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_snapshots_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeSnapshotsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_130) = &input.directory_id {
object.key("DirectoryId").string(var_130.as_str());
}
if let Some(var_131) = &input.snapshot_ids {
let mut array_132 = object.key("SnapshotIds").start_array();
for item_133 in var_131 {
{
array_132.value().string(item_133.as_str());
}
}
array_132.finish();
}
if let Some(var_134) = &input.next_token {
object.key("NextToken").string(var_134.as_str());
}
if let Some(var_135) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_135).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_trusts_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeTrustsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_136) = &input.directory_id {
object.key("DirectoryId").string(var_136.as_str());
}
if let Some(var_137) = &input.trust_ids {
let mut array_138 = object.key("TrustIds").start_array();
for item_139 in var_137 {
{
array_138.value().string(item_139.as_str());
}
}
array_138.finish();
}
if let Some(var_140) = &input.next_token {
object.key("NextToken").string(var_140.as_str());
}
if let Some(var_141) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_141).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_update_directory_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeUpdateDirectoryInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_142) = &input.directory_id {
object.key("DirectoryId").string(var_142.as_str());
}
if let Some(var_143) = &input.update_type {
object.key("UpdateType").string(var_143.as_str());
}
if let Some(var_144) = &input.region_name {
object.key("RegionName").string(var_144.as_str());
}
if let Some(var_145) = &input.next_token {
object.key("NextToken").string(var_145.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_disable_client_authentication_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DisableClientAuthenticationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_146) = &input.directory_id {
object.key("DirectoryId").string(var_146.as_str());
}
if let Some(var_147) = &input.r#type {
object.key("Type").string(var_147.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_disable_ldaps_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DisableLdapsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_148) = &input.directory_id {
object.key("DirectoryId").string(var_148.as_str());
}
if let Some(var_149) = &input.r#type {
object.key("Type").string(var_149.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_disable_radius_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DisableRadiusInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_150) = &input.directory_id {
object.key("DirectoryId").string(var_150.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_disable_sso_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DisableSsoInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_151) = &input.directory_id {
object.key("DirectoryId").string(var_151.as_str());
}
if let Some(var_152) = &input.user_name {
object.key("UserName").string(var_152.as_str());
}
if let Some(var_153) = &input.password {
object.key("Password").string(var_153.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_enable_client_authentication_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::EnableClientAuthenticationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_154) = &input.directory_id {
object.key("DirectoryId").string(var_154.as_str());
}
if let Some(var_155) = &input.r#type {
object.key("Type").string(var_155.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_enable_ldaps_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::EnableLdapsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_156) = &input.directory_id {
object.key("DirectoryId").string(var_156.as_str());
}
if let Some(var_157) = &input.r#type {
object.key("Type").string(var_157.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_enable_radius_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::EnableRadiusInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_158) = &input.directory_id {
object.key("DirectoryId").string(var_158.as_str());
}
if let Some(var_159) = &input.radius_settings {
#[allow(unused_mut)]
let mut object_160 = object.key("RadiusSettings").start_object();
crate::json_ser::serialize_structure_crate_model_radius_settings(&mut object_160, var_159)?;
object_160.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_enable_sso_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::EnableSsoInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_161) = &input.directory_id {
object.key("DirectoryId").string(var_161.as_str());
}
if let Some(var_162) = &input.user_name {
object.key("UserName").string(var_162.as_str());
}
if let Some(var_163) = &input.password {
object.key("Password").string(var_163.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_snapshot_limits_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetSnapshotLimitsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_164) = &input.directory_id {
object.key("DirectoryId").string(var_164.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_certificates_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListCertificatesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_165) = &input.directory_id {
object.key("DirectoryId").string(var_165.as_str());
}
if let Some(var_166) = &input.next_token {
object.key("NextToken").string(var_166.as_str());
}
if let Some(var_167) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_167).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_ip_routes_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListIpRoutesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_168) = &input.directory_id {
object.key("DirectoryId").string(var_168.as_str());
}
if let Some(var_169) = &input.next_token {
object.key("NextToken").string(var_169.as_str());
}
if let Some(var_170) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_170).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_log_subscriptions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListLogSubscriptionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_171) = &input.directory_id {
object.key("DirectoryId").string(var_171.as_str());
}
if let Some(var_172) = &input.next_token {
object.key("NextToken").string(var_172.as_str());
}
if let Some(var_173) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_173).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_schema_extensions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListSchemaExtensionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_174) = &input.directory_id {
object.key("DirectoryId").string(var_174.as_str());
}
if let Some(var_175) = &input.next_token {
object.key("NextToken").string(var_175.as_str());
}
if let Some(var_176) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_176).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_tags_for_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListTagsForResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_177) = &input.resource_id {
object.key("ResourceId").string(var_177.as_str());
}
if let Some(var_178) = &input.next_token {
object.key("NextToken").string(var_178.as_str());
}
if let Some(var_179) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_179).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_register_certificate_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RegisterCertificateInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_180) = &input.directory_id {
object.key("DirectoryId").string(var_180.as_str());
}
if let Some(var_181) = &input.certificate_data {
object.key("CertificateData").string(var_181.as_str());
}
if let Some(var_182) = &input.r#type {
object.key("Type").string(var_182.as_str());
}
if let Some(var_183) = &input.client_cert_auth_settings {
#[allow(unused_mut)]
let mut object_184 = object.key("ClientCertAuthSettings").start_object();
crate::json_ser::serialize_structure_crate_model_client_cert_auth_settings(
&mut object_184,
var_183,
)?;
object_184.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_register_event_topic_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RegisterEventTopicInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_185) = &input.directory_id {
object.key("DirectoryId").string(var_185.as_str());
}
if let Some(var_186) = &input.topic_name {
object.key("TopicName").string(var_186.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_reject_shared_directory_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RejectSharedDirectoryInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_187) = &input.shared_directory_id {
object.key("SharedDirectoryId").string(var_187.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_remove_ip_routes_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RemoveIpRoutesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_188) = &input.directory_id {
object.key("DirectoryId").string(var_188.as_str());
}
if let Some(var_189) = &input.cidr_ips {
let mut array_190 = object.key("CidrIps").start_array();
for item_191 in var_189 {
{
array_190.value().string(item_191.as_str());
}
}
array_190.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_remove_region_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RemoveRegionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_192) = &input.directory_id {
object.key("DirectoryId").string(var_192.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_remove_tags_from_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RemoveTagsFromResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_193) = &input.resource_id {
object.key("ResourceId").string(var_193.as_str());
}
if let Some(var_194) = &input.tag_keys {
let mut array_195 = object.key("TagKeys").start_array();
for item_196 in var_194 {
{
array_195.value().string(item_196.as_str());
}
}
array_195.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_reset_user_password_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ResetUserPasswordInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_197) = &input.directory_id {
object.key("DirectoryId").string(var_197.as_str());
}
if let Some(var_198) = &input.user_name {
object.key("UserName").string(var_198.as_str());
}
if let Some(var_199) = &input.new_password {
object.key("NewPassword").string(var_199.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_restore_from_snapshot_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RestoreFromSnapshotInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_200) = &input.snapshot_id {
object.key("SnapshotId").string(var_200.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_share_directory_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ShareDirectoryInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_201) = &input.directory_id {
object.key("DirectoryId").string(var_201.as_str());
}
if let Some(var_202) = &input.share_notes {
object.key("ShareNotes").string(var_202.as_str());
}
if let Some(var_203) = &input.share_target {
#[allow(unused_mut)]
let mut object_204 = object.key("ShareTarget").start_object();
crate::json_ser::serialize_structure_crate_model_share_target(&mut object_204, var_203)?;
object_204.finish();
}
if let Some(var_205) = &input.share_method {
object.key("ShareMethod").string(var_205.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_start_schema_extension_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartSchemaExtensionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_206) = &input.directory_id {
object.key("DirectoryId").string(var_206.as_str());
}
{
object
.key("CreateSnapshotBeforeSchemaExtension")
.boolean(input.create_snapshot_before_schema_extension);
}
if let Some(var_207) = &input.ldif_content {
object.key("LdifContent").string(var_207.as_str());
}
if let Some(var_208) = &input.description {
object.key("Description").string(var_208.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_unshare_directory_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UnshareDirectoryInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_209) = &input.directory_id {
object.key("DirectoryId").string(var_209.as_str());
}
if let Some(var_210) = &input.unshare_target {
#[allow(unused_mut)]
let mut object_211 = object.key("UnshareTarget").start_object();
crate::json_ser::serialize_structure_crate_model_unshare_target(&mut object_211, var_210)?;
object_211.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_conditional_forwarder_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateConditionalForwarderInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_212) = &input.directory_id {
object.key("DirectoryId").string(var_212.as_str());
}
if let Some(var_213) = &input.remote_domain_name {
object.key("RemoteDomainName").string(var_213.as_str());
}
if let Some(var_214) = &input.dns_ip_addrs {
let mut array_215 = object.key("DnsIpAddrs").start_array();
for item_216 in var_214 {
{
array_215.value().string(item_216.as_str());
}
}
array_215.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_directory_setup_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateDirectorySetupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_217) = &input.directory_id {
object.key("DirectoryId").string(var_217.as_str());
}
if let Some(var_218) = &input.update_type {
object.key("UpdateType").string(var_218.as_str());
}
if let Some(var_219) = &input.os_update_settings {
#[allow(unused_mut)]
let mut object_220 = object.key("OSUpdateSettings").start_object();
crate::json_ser::serialize_structure_crate_model_os_update_settings(
&mut object_220,
var_219,
)?;
object_220.finish();
}
if let Some(var_221) = &input.create_snapshot_before_update {
object.key("CreateSnapshotBeforeUpdate").boolean(*var_221);
}
Ok(())
}
pub fn serialize_structure_crate_input_update_number_of_domain_controllers_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateNumberOfDomainControllersInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_222) = &input.directory_id {
object.key("DirectoryId").string(var_222.as_str());
}
{
object.key("DesiredNumber").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.desired_number).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_update_radius_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateRadiusInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_223) = &input.directory_id {
object.key("DirectoryId").string(var_223.as_str());
}
if let Some(var_224) = &input.radius_settings {
#[allow(unused_mut)]
let mut object_225 = object.key("RadiusSettings").start_object();
crate::json_ser::serialize_structure_crate_model_radius_settings(&mut object_225, var_224)?;
object_225.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_settings_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateSettingsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_226) = &input.directory_id {
object.key("DirectoryId").string(var_226.as_str());
}
if let Some(var_227) = &input.settings {
let mut array_228 = object.key("Settings").start_array();
for item_229 in var_227 {
{
#[allow(unused_mut)]
let mut object_230 = array_228.value().start_object();
crate::json_ser::serialize_structure_crate_model_setting(
&mut object_230,
item_229,
)?;
object_230.finish();
}
}
array_228.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_trust_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateTrustInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_231) = &input.trust_id {
object.key("TrustId").string(var_231.as_str());
}
if let Some(var_232) = &input.selective_auth {
object.key("SelectiveAuth").string(var_232.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_verify_trust_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::VerifyTrustInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_233) = &input.trust_id {
object.key("TrustId").string(var_233.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_ip_route(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::IpRoute,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_234) = &input.cidr_ip {
object.key("CidrIp").string(var_234.as_str());
}
if let Some(var_235) = &input.description {
object.key("Description").string(var_235.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_directory_vpc_settings(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DirectoryVpcSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_236) = &input.vpc_id {
object.key("VpcId").string(var_236.as_str());
}
if let Some(var_237) = &input.subnet_ids {
let mut array_238 = object.key("SubnetIds").start_array();
for item_239 in var_237 {
{
array_238.value().string(item_239.as_str());
}
}
array_238.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_240) = &input.key {
object.key("Key").string(var_240.as_str());
}
if let Some(var_241) = &input.value {
object.key("Value").string(var_241.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_directory_connect_settings(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DirectoryConnectSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_242) = &input.vpc_id {
object.key("VpcId").string(var_242.as_str());
}
if let Some(var_243) = &input.subnet_ids {
let mut array_244 = object.key("SubnetIds").start_array();
for item_245 in var_243 {
{
array_244.value().string(item_245.as_str());
}
}
array_244.finish();
}
if let Some(var_246) = &input.customer_dns_ips {
let mut array_247 = object.key("CustomerDnsIps").start_array();
for item_248 in var_246 {
{
array_247.value().string(item_248.as_str());
}
}
array_247.finish();
}
if let Some(var_249) = &input.customer_user_name {
object.key("CustomerUserName").string(var_249.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_attribute(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Attribute,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_250) = &input.name {
object.key("Name").string(var_250.as_str());
}
if let Some(var_251) = &input.value {
object.key("Value").string(var_251.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_radius_settings(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RadiusSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_252) = &input.radius_servers {
let mut array_253 = object.key("RadiusServers").start_array();
for item_254 in var_252 {
{
array_253.value().string(item_254.as_str());
}
}
array_253.finish();
}
if input.radius_port != 0 {
object.key("RadiusPort").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.radius_port).into()),
);
}
if input.radius_timeout != 0 {
object.key("RadiusTimeout").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.radius_timeout).into()),
);
}
if input.radius_retries != 0 {
object.key("RadiusRetries").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.radius_retries).into()),
);
}
if let Some(var_255) = &input.shared_secret {
object.key("SharedSecret").string(var_255.as_str());
}
if let Some(var_256) = &input.authentication_protocol {
object
.key("AuthenticationProtocol")
.string(var_256.as_str());
}
if let Some(var_257) = &input.display_label {
object.key("DisplayLabel").string(var_257.as_str());
}
if input.use_same_username {
object
.key("UseSameUsername")
.boolean(input.use_same_username);
}
Ok(())
}
pub fn serialize_structure_crate_model_client_cert_auth_settings(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ClientCertAuthSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_258) = &input.ocsp_url {
object.key("OCSPUrl").string(var_258.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_share_target(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ShareTarget,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_259) = &input.id {
object.key("Id").string(var_259.as_str());
}
if let Some(var_260) = &input.r#type {
object.key("Type").string(var_260.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_unshare_target(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UnshareTarget,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_261) = &input.id {
object.key("Id").string(var_261.as_str());
}
if let Some(var_262) = &input.r#type {
object.key("Type").string(var_262.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_os_update_settings(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::OsUpdateSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_263) = &input.os_version {
object.key("OSVersion").string(var_263.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_setting(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Setting,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_264) = &input.name {
object.key("Name").string(var_264.as_str());
}
if let Some(var_265) = &input.value {
object.key("Value").string(var_265.as_str());
}
Ok(())
}