pub fn serialize_structure_crate_input_batch_get_collection_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchGetCollectionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.ids {
let mut array_2 = object.key("ids").start_array();
for item_3 in var_1 {
{
array_2.value().string(item_3.as_str());
}
}
array_2.finish();
}
if let Some(var_4) = &input.names {
let mut array_5 = object.key("names").start_array();
for item_6 in var_4 {
{
array_5.value().string(item_6.as_str());
}
}
array_5.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_batch_get_vpc_endpoint_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchGetVpcEndpointInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_7) = &input.ids {
let mut array_8 = object.key("ids").start_array();
for item_9 in var_7 {
{
array_8.value().string(item_9.as_str());
}
}
array_8.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_access_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateAccessPolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_10) = &input.r#type {
object.key("type").string(var_10.as_str());
}
if let Some(var_11) = &input.name {
object.key("name").string(var_11.as_str());
}
if let Some(var_12) = &input.description {
object.key("description").string(var_12.as_str());
}
if let Some(var_13) = &input.policy {
object.key("policy").string(var_13.as_str());
}
if let Some(var_14) = &input.client_token {
object.key("clientToken").string(var_14.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_collection_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateCollectionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_15) = &input.name {
object.key("name").string(var_15.as_str());
}
if let Some(var_16) = &input.r#type {
object.key("type").string(var_16.as_str());
}
if let Some(var_17) = &input.description {
object.key("description").string(var_17.as_str());
}
if let Some(var_18) = &input.tags {
let mut array_19 = object.key("tags").start_array();
for item_20 in var_18 {
{
#[allow(unused_mut)]
let mut object_21 = array_19.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_21, item_20)?;
object_21.finish();
}
}
array_19.finish();
}
if let Some(var_22) = &input.client_token {
object.key("clientToken").string(var_22.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_security_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateSecurityConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_23) = &input.r#type {
object.key("type").string(var_23.as_str());
}
if let Some(var_24) = &input.name {
object.key("name").string(var_24.as_str());
}
if let Some(var_25) = &input.description {
object.key("description").string(var_25.as_str());
}
if let Some(var_26) = &input.saml_options {
#[allow(unused_mut)]
let mut object_27 = object.key("samlOptions").start_object();
crate::json_ser::serialize_structure_crate_model_saml_config_options(
&mut object_27,
var_26,
)?;
object_27.finish();
}
if let Some(var_28) = &input.client_token {
object.key("clientToken").string(var_28.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_security_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateSecurityPolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_29) = &input.r#type {
object.key("type").string(var_29.as_str());
}
if let Some(var_30) = &input.name {
object.key("name").string(var_30.as_str());
}
if let Some(var_31) = &input.description {
object.key("description").string(var_31.as_str());
}
if let Some(var_32) = &input.policy {
object.key("policy").string(var_32.as_str());
}
if let Some(var_33) = &input.client_token {
object.key("clientToken").string(var_33.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_vpc_endpoint_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateVpcEndpointInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_34) = &input.name {
object.key("name").string(var_34.as_str());
}
if let Some(var_35) = &input.vpc_id {
object.key("vpcId").string(var_35.as_str());
}
if let Some(var_36) = &input.subnet_ids {
let mut array_37 = object.key("subnetIds").start_array();
for item_38 in var_36 {
{
array_37.value().string(item_38.as_str());
}
}
array_37.finish();
}
if let Some(var_39) = &input.security_group_ids {
let mut array_40 = object.key("securityGroupIds").start_array();
for item_41 in var_39 {
{
array_40.value().string(item_41.as_str());
}
}
array_40.finish();
}
if let Some(var_42) = &input.client_token {
object.key("clientToken").string(var_42.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_access_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteAccessPolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_43) = &input.r#type {
object.key("type").string(var_43.as_str());
}
if let Some(var_44) = &input.name {
object.key("name").string(var_44.as_str());
}
if let Some(var_45) = &input.client_token {
object.key("clientToken").string(var_45.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_collection_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteCollectionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_46) = &input.id {
object.key("id").string(var_46.as_str());
}
if let Some(var_47) = &input.client_token {
object.key("clientToken").string(var_47.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_security_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteSecurityConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_48) = &input.id {
object.key("id").string(var_48.as_str());
}
if let Some(var_49) = &input.client_token {
object.key("clientToken").string(var_49.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_security_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteSecurityPolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_50) = &input.r#type {
object.key("type").string(var_50.as_str());
}
if let Some(var_51) = &input.name {
object.key("name").string(var_51.as_str());
}
if let Some(var_52) = &input.client_token {
object.key("clientToken").string(var_52.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_vpc_endpoint_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteVpcEndpointInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_53) = &input.id {
object.key("id").string(var_53.as_str());
}
if let Some(var_54) = &input.client_token {
object.key("clientToken").string(var_54.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_access_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetAccessPolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_55) = &input.r#type {
object.key("type").string(var_55.as_str());
}
if let Some(var_56) = &input.name {
object.key("name").string(var_56.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_security_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetSecurityConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_57) = &input.id {
object.key("id").string(var_57.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_security_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetSecurityPolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_58) = &input.r#type {
object.key("type").string(var_58.as_str());
}
if let Some(var_59) = &input.name {
object.key("name").string(var_59.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_access_policies_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListAccessPoliciesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_60) = &input.r#type {
object.key("type").string(var_60.as_str());
}
if let Some(var_61) = &input.resource {
let mut array_62 = object.key("resource").start_array();
for item_63 in var_61 {
{
array_62.value().string(item_63.as_str());
}
}
array_62.finish();
}
if let Some(var_64) = &input.next_token {
object.key("nextToken").string(var_64.as_str());
}
if let Some(var_65) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_65).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_collections_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListCollectionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_66) = &input.collection_filters {
#[allow(unused_mut)]
let mut object_67 = object.key("collectionFilters").start_object();
crate::json_ser::serialize_structure_crate_model_collection_filters(
&mut object_67,
var_66,
)?;
object_67.finish();
}
if let Some(var_68) = &input.next_token {
object.key("nextToken").string(var_68.as_str());
}
if let Some(var_69) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_69).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_security_configs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListSecurityConfigsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_70) = &input.r#type {
object.key("type").string(var_70.as_str());
}
if let Some(var_71) = &input.next_token {
object.key("nextToken").string(var_71.as_str());
}
if let Some(var_72) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_72).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_security_policies_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListSecurityPoliciesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_73) = &input.r#type {
object.key("type").string(var_73.as_str());
}
if let Some(var_74) = &input.resource {
let mut array_75 = object.key("resource").start_array();
for item_76 in var_74 {
{
array_75.value().string(item_76.as_str());
}
}
array_75.finish();
}
if let Some(var_77) = &input.next_token {
object.key("nextToken").string(var_77.as_str());
}
if let Some(var_78) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_78).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_79) = &input.resource_arn {
object.key("resourceArn").string(var_79.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_vpc_endpoints_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListVpcEndpointsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_80) = &input.vpc_endpoint_filters {
#[allow(unused_mut)]
let mut object_81 = object.key("vpcEndpointFilters").start_object();
crate::json_ser::serialize_structure_crate_model_vpc_endpoint_filters(
&mut object_81,
var_80,
)?;
object_81.finish();
}
if let Some(var_82) = &input.next_token {
object.key("nextToken").string(var_82.as_str());
}
if let Some(var_83) = &input.max_results {
object.key("maxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_83).into()),
);
}
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_84) = &input.resource_arn {
object.key("resourceArn").string(var_84.as_str());
}
if let Some(var_85) = &input.tags {
let mut array_86 = object.key("tags").start_array();
for item_87 in var_85 {
{
#[allow(unused_mut)]
let mut object_88 = array_86.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_88, item_87)?;
object_88.finish();
}
}
array_86.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_89) = &input.resource_arn {
object.key("resourceArn").string(var_89.as_str());
}
if let Some(var_90) = &input.tag_keys {
let mut array_91 = object.key("tagKeys").start_array();
for item_92 in var_90 {
{
array_91.value().string(item_92.as_str());
}
}
array_91.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_access_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateAccessPolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_93) = &input.r#type {
object.key("type").string(var_93.as_str());
}
if let Some(var_94) = &input.name {
object.key("name").string(var_94.as_str());
}
if let Some(var_95) = &input.policy_version {
object.key("policyVersion").string(var_95.as_str());
}
if let Some(var_96) = &input.description {
object.key("description").string(var_96.as_str());
}
if let Some(var_97) = &input.policy {
object.key("policy").string(var_97.as_str());
}
if let Some(var_98) = &input.client_token {
object.key("clientToken").string(var_98.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_account_settings_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateAccountSettingsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_99) = &input.capacity_limits {
#[allow(unused_mut)]
let mut object_100 = object.key("capacityLimits").start_object();
crate::json_ser::serialize_structure_crate_model_capacity_limits(&mut object_100, var_99)?;
object_100.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_collection_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateCollectionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_101) = &input.id {
object.key("id").string(var_101.as_str());
}
if let Some(var_102) = &input.description {
object.key("description").string(var_102.as_str());
}
if let Some(var_103) = &input.client_token {
object.key("clientToken").string(var_103.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_security_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateSecurityConfigInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_104) = &input.id {
object.key("id").string(var_104.as_str());
}
if let Some(var_105) = &input.config_version {
object.key("configVersion").string(var_105.as_str());
}
if let Some(var_106) = &input.description {
object.key("description").string(var_106.as_str());
}
if let Some(var_107) = &input.saml_options {
#[allow(unused_mut)]
let mut object_108 = object.key("samlOptions").start_object();
crate::json_ser::serialize_structure_crate_model_saml_config_options(
&mut object_108,
var_107,
)?;
object_108.finish();
}
if let Some(var_109) = &input.client_token {
object.key("clientToken").string(var_109.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_security_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateSecurityPolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_110) = &input.r#type {
object.key("type").string(var_110.as_str());
}
if let Some(var_111) = &input.name {
object.key("name").string(var_111.as_str());
}
if let Some(var_112) = &input.policy_version {
object.key("policyVersion").string(var_112.as_str());
}
if let Some(var_113) = &input.description {
object.key("description").string(var_113.as_str());
}
if let Some(var_114) = &input.policy {
object.key("policy").string(var_114.as_str());
}
if let Some(var_115) = &input.client_token {
object.key("clientToken").string(var_115.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_vpc_endpoint_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateVpcEndpointInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_116) = &input.id {
object.key("id").string(var_116.as_str());
}
if let Some(var_117) = &input.add_subnet_ids {
let mut array_118 = object.key("addSubnetIds").start_array();
for item_119 in var_117 {
{
array_118.value().string(item_119.as_str());
}
}
array_118.finish();
}
if let Some(var_120) = &input.remove_subnet_ids {
let mut array_121 = object.key("removeSubnetIds").start_array();
for item_122 in var_120 {
{
array_121.value().string(item_122.as_str());
}
}
array_121.finish();
}
if let Some(var_123) = &input.add_security_group_ids {
let mut array_124 = object.key("addSecurityGroupIds").start_array();
for item_125 in var_123 {
{
array_124.value().string(item_125.as_str());
}
}
array_124.finish();
}
if let Some(var_126) = &input.remove_security_group_ids {
let mut array_127 = object.key("removeSecurityGroupIds").start_array();
for item_128 in var_126 {
{
array_127.value().string(item_128.as_str());
}
}
array_127.finish();
}
if let Some(var_129) = &input.client_token {
object.key("clientToken").string(var_129.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_130) = &input.key {
object.key("key").string(var_130.as_str());
}
if let Some(var_131) = &input.value {
object.key("value").string(var_131.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_saml_config_options(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SamlConfigOptions,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_132) = &input.metadata {
object.key("metadata").string(var_132.as_str());
}
if let Some(var_133) = &input.user_attribute {
object.key("userAttribute").string(var_133.as_str());
}
if let Some(var_134) = &input.group_attribute {
object.key("groupAttribute").string(var_134.as_str());
}
if let Some(var_135) = &input.session_timeout {
object.key("sessionTimeout").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_135).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_collection_filters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CollectionFilters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_136) = &input.name {
object.key("name").string(var_136.as_str());
}
if let Some(var_137) = &input.status {
object.key("status").string(var_137.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_vpc_endpoint_filters(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::VpcEndpointFilters,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_138) = &input.status {
object.key("status").string(var_138.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_capacity_limits(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CapacityLimits,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_139) = &input.max_indexing_capacity_in_ocu {
object.key("maxIndexingCapacityInOCU").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_139).into()),
);
}
if let Some(var_140) = &input.max_search_capacity_in_ocu {
object.key("maxSearchCapacityInOCU").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_140).into()),
);
}
Ok(())
}