pub fn serialize_structure_crate_input_associate_fleet_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociateFleetInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_1) = &input.fleet_name {
object.key("FleetName").string(var_1);
}
if let Some(var_2) = &input.stack_name {
object.key("StackName").string(var_2);
}
Ok(())
}
pub fn serialize_structure_crate_input_batch_associate_user_stack_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchAssociateUserStackInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_3) = &input.user_stack_associations {
let mut array_4 = object.key("UserStackAssociations").start_array();
for item_5 in var_3 {
{
let mut object_6 = array_4.value().start_object();
crate::json_ser::serialize_structure_crate_model_user_stack_association(
&mut object_6,
item_5,
)?;
object_6.finish();
}
}
array_4.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_batch_disassociate_user_stack_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::BatchDisassociateUserStackInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_7) = &input.user_stack_associations {
let mut array_8 = object.key("UserStackAssociations").start_array();
for item_9 in var_7 {
{
let mut object_10 = array_8.value().start_object();
crate::json_ser::serialize_structure_crate_model_user_stack_association(
&mut object_10,
item_9,
)?;
object_10.finish();
}
}
array_8.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_copy_image_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CopyImageInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_11) = &input.source_image_name {
object.key("SourceImageName").string(var_11);
}
if let Some(var_12) = &input.destination_image_name {
object.key("DestinationImageName").string(var_12);
}
if let Some(var_13) = &input.destination_region {
object.key("DestinationRegion").string(var_13);
}
if let Some(var_14) = &input.destination_image_description {
object.key("DestinationImageDescription").string(var_14);
}
Ok(())
}
pub fn serialize_structure_crate_input_create_directory_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateDirectoryConfigInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_15) = &input.directory_name {
object.key("DirectoryName").string(var_15);
}
if let Some(var_16) = &input.organizational_unit_distinguished_names {
let mut array_17 = object
.key("OrganizationalUnitDistinguishedNames")
.start_array();
for item_18 in var_16 {
{
array_17.value().string(item_18);
}
}
array_17.finish();
}
if let Some(var_19) = &input.service_account_credentials {
let mut object_20 = object.key("ServiceAccountCredentials").start_object();
crate::json_ser::serialize_structure_crate_model_service_account_credentials(
&mut object_20,
var_19,
)?;
object_20.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_fleet_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateFleetInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_21) = &input.name {
object.key("Name").string(var_21);
}
if let Some(var_22) = &input.image_name {
object.key("ImageName").string(var_22);
}
if let Some(var_23) = &input.image_arn {
object.key("ImageArn").string(var_23);
}
if let Some(var_24) = &input.instance_type {
object.key("InstanceType").string(var_24);
}
if let Some(var_25) = &input.fleet_type {
object.key("FleetType").string(var_25.as_str());
}
if let Some(var_26) = &input.compute_capacity {
let mut object_27 = object.key("ComputeCapacity").start_object();
crate::json_ser::serialize_structure_crate_model_compute_capacity(&mut object_27, var_26)?;
object_27.finish();
}
if let Some(var_28) = &input.vpc_config {
let mut object_29 = object.key("VpcConfig").start_object();
crate::json_ser::serialize_structure_crate_model_vpc_config(&mut object_29, var_28)?;
object_29.finish();
}
if let Some(var_30) = &input.max_user_duration_in_seconds {
object.key("MaxUserDurationInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_30).into()),
);
}
if let Some(var_31) = &input.disconnect_timeout_in_seconds {
object.key("DisconnectTimeoutInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_31).into()),
);
}
if let Some(var_32) = &input.description {
object.key("Description").string(var_32);
}
if let Some(var_33) = &input.display_name {
object.key("DisplayName").string(var_33);
}
if let Some(var_34) = &input.enable_default_internet_access {
object.key("EnableDefaultInternetAccess").boolean(*var_34);
}
if let Some(var_35) = &input.domain_join_info {
let mut object_36 = object.key("DomainJoinInfo").start_object();
crate::json_ser::serialize_structure_crate_model_domain_join_info(&mut object_36, var_35)?;
object_36.finish();
}
if let Some(var_37) = &input.tags {
let mut object_38 = object.key("Tags").start_object();
for (key_39, value_40) in var_37 {
{
object_38.key(key_39).string(value_40);
}
}
object_38.finish();
}
if let Some(var_41) = &input.idle_disconnect_timeout_in_seconds {
object.key("IdleDisconnectTimeoutInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_41).into()),
);
}
if let Some(var_42) = &input.iam_role_arn {
object.key("IamRoleArn").string(var_42);
}
if let Some(var_43) = &input.stream_view {
object.key("StreamView").string(var_43.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_image_builder_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateImageBuilderInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_44) = &input.name {
object.key("Name").string(var_44);
}
if let Some(var_45) = &input.image_name {
object.key("ImageName").string(var_45);
}
if let Some(var_46) = &input.image_arn {
object.key("ImageArn").string(var_46);
}
if let Some(var_47) = &input.instance_type {
object.key("InstanceType").string(var_47);
}
if let Some(var_48) = &input.description {
object.key("Description").string(var_48);
}
if let Some(var_49) = &input.display_name {
object.key("DisplayName").string(var_49);
}
if let Some(var_50) = &input.vpc_config {
let mut object_51 = object.key("VpcConfig").start_object();
crate::json_ser::serialize_structure_crate_model_vpc_config(&mut object_51, var_50)?;
object_51.finish();
}
if let Some(var_52) = &input.iam_role_arn {
object.key("IamRoleArn").string(var_52);
}
if let Some(var_53) = &input.enable_default_internet_access {
object.key("EnableDefaultInternetAccess").boolean(*var_53);
}
if let Some(var_54) = &input.domain_join_info {
let mut object_55 = object.key("DomainJoinInfo").start_object();
crate::json_ser::serialize_structure_crate_model_domain_join_info(&mut object_55, var_54)?;
object_55.finish();
}
if let Some(var_56) = &input.appstream_agent_version {
object.key("AppstreamAgentVersion").string(var_56);
}
if let Some(var_57) = &input.tags {
let mut object_58 = object.key("Tags").start_object();
for (key_59, value_60) in var_57 {
{
object_58.key(key_59).string(value_60);
}
}
object_58.finish();
}
if let Some(var_61) = &input.access_endpoints {
let mut array_62 = object.key("AccessEndpoints").start_array();
for item_63 in var_61 {
{
let mut object_64 = array_62.value().start_object();
crate::json_ser::serialize_structure_crate_model_access_endpoint(
&mut object_64,
item_63,
)?;
object_64.finish();
}
}
array_62.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_image_builder_streaming_url_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateImageBuilderStreamingUrlInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_65) = &input.name {
object.key("Name").string(var_65);
}
if let Some(var_66) = &input.validity {
object.key("Validity").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_66).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_create_stack_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateStackInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_67) = &input.name {
object.key("Name").string(var_67);
}
if let Some(var_68) = &input.description {
object.key("Description").string(var_68);
}
if let Some(var_69) = &input.display_name {
object.key("DisplayName").string(var_69);
}
if let Some(var_70) = &input.storage_connectors {
let mut array_71 = object.key("StorageConnectors").start_array();
for item_72 in var_70 {
{
let mut object_73 = array_71.value().start_object();
crate::json_ser::serialize_structure_crate_model_storage_connector(
&mut object_73,
item_72,
)?;
object_73.finish();
}
}
array_71.finish();
}
if let Some(var_74) = &input.redirect_url {
object.key("RedirectURL").string(var_74);
}
if let Some(var_75) = &input.feedback_url {
object.key("FeedbackURL").string(var_75);
}
if let Some(var_76) = &input.user_settings {
let mut array_77 = object.key("UserSettings").start_array();
for item_78 in var_76 {
{
let mut object_79 = array_77.value().start_object();
crate::json_ser::serialize_structure_crate_model_user_setting(
&mut object_79,
item_78,
)?;
object_79.finish();
}
}
array_77.finish();
}
if let Some(var_80) = &input.application_settings {
let mut object_81 = object.key("ApplicationSettings").start_object();
crate::json_ser::serialize_structure_crate_model_application_settings(
&mut object_81,
var_80,
)?;
object_81.finish();
}
if let Some(var_82) = &input.tags {
let mut object_83 = object.key("Tags").start_object();
for (key_84, value_85) in var_82 {
{
object_83.key(key_84).string(value_85);
}
}
object_83.finish();
}
if let Some(var_86) = &input.access_endpoints {
let mut array_87 = object.key("AccessEndpoints").start_array();
for item_88 in var_86 {
{
let mut object_89 = array_87.value().start_object();
crate::json_ser::serialize_structure_crate_model_access_endpoint(
&mut object_89,
item_88,
)?;
object_89.finish();
}
}
array_87.finish();
}
if let Some(var_90) = &input.embed_host_domains {
let mut array_91 = object.key("EmbedHostDomains").start_array();
for item_92 in var_90 {
{
array_91.value().string(item_92);
}
}
array_91.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_streaming_url_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateStreamingUrlInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_93) = &input.stack_name {
object.key("StackName").string(var_93);
}
if let Some(var_94) = &input.fleet_name {
object.key("FleetName").string(var_94);
}
if let Some(var_95) = &input.user_id {
object.key("UserId").string(var_95);
}
if let Some(var_96) = &input.application_id {
object.key("ApplicationId").string(var_96);
}
if let Some(var_97) = &input.validity {
object.key("Validity").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_97).into()),
);
}
if let Some(var_98) = &input.session_context {
object.key("SessionContext").string(var_98);
}
Ok(())
}
pub fn serialize_structure_crate_input_create_updated_image_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateUpdatedImageInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_99) = &input.existing_image_name {
object.key("existingImageName").string(var_99);
}
if let Some(var_100) = &input.new_image_name {
object.key("newImageName").string(var_100);
}
if let Some(var_101) = &input.new_image_description {
object.key("newImageDescription").string(var_101);
}
if let Some(var_102) = &input.new_image_display_name {
object.key("newImageDisplayName").string(var_102);
}
if let Some(var_103) = &input.new_image_tags {
let mut object_104 = object.key("newImageTags").start_object();
for (key_105, value_106) in var_103 {
{
object_104.key(key_105).string(value_106);
}
}
object_104.finish();
}
if input.dry_run {
object.key("dryRun").boolean(input.dry_run);
}
Ok(())
}
pub fn serialize_structure_crate_input_create_user_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateUserInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_107) = &input.user_name {
object.key("UserName").string(var_107);
}
if let Some(var_108) = &input.message_action {
object.key("MessageAction").string(var_108.as_str());
}
if let Some(var_109) = &input.first_name {
object.key("FirstName").string(var_109);
}
if let Some(var_110) = &input.last_name {
object.key("LastName").string(var_110);
}
if let Some(var_111) = &input.authentication_type {
object.key("AuthenticationType").string(var_111.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_directory_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteDirectoryConfigInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_112) = &input.directory_name {
object.key("DirectoryName").string(var_112);
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_fleet_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteFleetInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_113) = &input.name {
object.key("Name").string(var_113);
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_image_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteImageInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_114) = &input.name {
object.key("Name").string(var_114);
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_image_builder_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteImageBuilderInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_115) = &input.name {
object.key("Name").string(var_115);
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_image_permissions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteImagePermissionsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_116) = &input.name {
object.key("Name").string(var_116);
}
if let Some(var_117) = &input.shared_account_id {
object.key("SharedAccountId").string(var_117);
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_stack_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteStackInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_118) = &input.name {
object.key("Name").string(var_118);
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_user_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteUserInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_119) = &input.user_name {
object.key("UserName").string(var_119);
}
if let Some(var_120) = &input.authentication_type {
object.key("AuthenticationType").string(var_120.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_directory_configs_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeDirectoryConfigsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_121) = &input.directory_names {
let mut array_122 = object.key("DirectoryNames").start_array();
for item_123 in var_121 {
{
array_122.value().string(item_123);
}
}
array_122.finish();
}
if let Some(var_124) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_124).into()),
);
}
if let Some(var_125) = &input.next_token {
object.key("NextToken").string(var_125);
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_fleets_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeFleetsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_126) = &input.names {
let mut array_127 = object.key("Names").start_array();
for item_128 in var_126 {
{
array_127.value().string(item_128);
}
}
array_127.finish();
}
if let Some(var_129) = &input.next_token {
object.key("NextToken").string(var_129);
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_image_builders_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeImageBuildersInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_130) = &input.names {
let mut array_131 = object.key("Names").start_array();
for item_132 in var_130 {
{
array_131.value().string(item_132);
}
}
array_131.finish();
}
if let Some(var_133) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_133).into()),
);
}
if let Some(var_134) = &input.next_token {
object.key("NextToken").string(var_134);
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_image_permissions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeImagePermissionsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_135) = &input.name {
object.key("Name").string(var_135);
}
if let Some(var_136) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_136).into()),
);
}
if let Some(var_137) = &input.shared_aws_account_ids {
let mut array_138 = object.key("SharedAwsAccountIds").start_array();
for item_139 in var_137 {
{
array_138.value().string(item_139);
}
}
array_138.finish();
}
if let Some(var_140) = &input.next_token {
object.key("NextToken").string(var_140);
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_images_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeImagesInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_141) = &input.names {
let mut array_142 = object.key("Names").start_array();
for item_143 in var_141 {
{
array_142.value().string(item_143);
}
}
array_142.finish();
}
if let Some(var_144) = &input.arns {
let mut array_145 = object.key("Arns").start_array();
for item_146 in var_144 {
{
array_145.value().string(item_146);
}
}
array_145.finish();
}
if let Some(var_147) = &input.r#type {
object.key("Type").string(var_147.as_str());
}
if let Some(var_148) = &input.next_token {
object.key("NextToken").string(var_148);
}
if let Some(var_149) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_149).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_sessions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeSessionsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_150) = &input.stack_name {
object.key("StackName").string(var_150);
}
if let Some(var_151) = &input.fleet_name {
object.key("FleetName").string(var_151);
}
if let Some(var_152) = &input.user_id {
object.key("UserId").string(var_152);
}
if let Some(var_153) = &input.next_token {
object.key("NextToken").string(var_153);
}
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.authentication_type {
object.key("AuthenticationType").string(var_155.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_stacks_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeStacksInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_156) = &input.names {
let mut array_157 = object.key("Names").start_array();
for item_158 in var_156 {
{
array_157.value().string(item_158);
}
}
array_157.finish();
}
if let Some(var_159) = &input.next_token {
object.key("NextToken").string(var_159);
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_usage_report_subscriptions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeUsageReportSubscriptionsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_160) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_160).into()),
);
}
if let Some(var_161) = &input.next_token {
object.key("NextToken").string(var_161);
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_users_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeUsersInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_162) = &input.authentication_type {
object.key("AuthenticationType").string(var_162.as_str());
}
if let Some(var_163) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_163).into()),
);
}
if let Some(var_164) = &input.next_token {
object.key("NextToken").string(var_164);
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_user_stack_associations_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeUserStackAssociationsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_165) = &input.stack_name {
object.key("StackName").string(var_165);
}
if let Some(var_166) = &input.user_name {
object.key("UserName").string(var_166);
}
if let Some(var_167) = &input.authentication_type {
object.key("AuthenticationType").string(var_167.as_str());
}
if let Some(var_168) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_168).into()),
);
}
if let Some(var_169) = &input.next_token {
object.key("NextToken").string(var_169);
}
Ok(())
}
pub fn serialize_structure_crate_input_disable_user_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DisableUserInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_170) = &input.user_name {
object.key("UserName").string(var_170);
}
if let Some(var_171) = &input.authentication_type {
object.key("AuthenticationType").string(var_171.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_disassociate_fleet_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DisassociateFleetInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_172) = &input.fleet_name {
object.key("FleetName").string(var_172);
}
if let Some(var_173) = &input.stack_name {
object.key("StackName").string(var_173);
}
Ok(())
}
pub fn serialize_structure_crate_input_enable_user_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::EnableUserInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_174) = &input.user_name {
object.key("UserName").string(var_174);
}
if let Some(var_175) = &input.authentication_type {
object.key("AuthenticationType").string(var_175.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_expire_session_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ExpireSessionInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_176) = &input.session_id {
object.key("SessionId").string(var_176);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_associated_fleets_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListAssociatedFleetsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_177) = &input.stack_name {
object.key("StackName").string(var_177);
}
if let Some(var_178) = &input.next_token {
object.key("NextToken").string(var_178);
}
Ok(())
}
pub fn serialize_structure_crate_input_list_associated_stacks_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListAssociatedStacksInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_179) = &input.fleet_name {
object.key("FleetName").string(var_179);
}
if let Some(var_180) = &input.next_token {
object.key("NextToken").string(var_180);
}
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::SerializationError> {
if let Some(var_181) = &input.resource_arn {
object.key("ResourceArn").string(var_181);
}
Ok(())
}
pub fn serialize_structure_crate_input_start_fleet_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartFleetInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_182) = &input.name {
object.key("Name").string(var_182);
}
Ok(())
}
pub fn serialize_structure_crate_input_start_image_builder_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartImageBuilderInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_183) = &input.name {
object.key("Name").string(var_183);
}
if let Some(var_184) = &input.appstream_agent_version {
object.key("AppstreamAgentVersion").string(var_184);
}
Ok(())
}
pub fn serialize_structure_crate_input_stop_fleet_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StopFleetInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_185) = &input.name {
object.key("Name").string(var_185);
}
Ok(())
}
pub fn serialize_structure_crate_input_stop_image_builder_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StopImageBuilderInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_186) = &input.name {
object.key("Name").string(var_186);
}
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::SerializationError> {
if let Some(var_187) = &input.resource_arn {
object.key("ResourceArn").string(var_187);
}
if let Some(var_188) = &input.tags {
let mut object_189 = object.key("Tags").start_object();
for (key_190, value_191) in var_188 {
{
object_189.key(key_190).string(value_191);
}
}
object_189.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::SerializationError> {
if let Some(var_192) = &input.resource_arn {
object.key("ResourceArn").string(var_192);
}
if let Some(var_193) = &input.tag_keys {
let mut array_194 = object.key("TagKeys").start_array();
for item_195 in var_193 {
{
array_194.value().string(item_195);
}
}
array_194.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_directory_config_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateDirectoryConfigInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_196) = &input.directory_name {
object.key("DirectoryName").string(var_196);
}
if let Some(var_197) = &input.organizational_unit_distinguished_names {
let mut array_198 = object
.key("OrganizationalUnitDistinguishedNames")
.start_array();
for item_199 in var_197 {
{
array_198.value().string(item_199);
}
}
array_198.finish();
}
if let Some(var_200) = &input.service_account_credentials {
let mut object_201 = object.key("ServiceAccountCredentials").start_object();
crate::json_ser::serialize_structure_crate_model_service_account_credentials(
&mut object_201,
var_200,
)?;
object_201.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_fleet_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateFleetInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_202) = &input.image_name {
object.key("ImageName").string(var_202);
}
if let Some(var_203) = &input.image_arn {
object.key("ImageArn").string(var_203);
}
if let Some(var_204) = &input.name {
object.key("Name").string(var_204);
}
if let Some(var_205) = &input.instance_type {
object.key("InstanceType").string(var_205);
}
if let Some(var_206) = &input.compute_capacity {
let mut object_207 = object.key("ComputeCapacity").start_object();
crate::json_ser::serialize_structure_crate_model_compute_capacity(
&mut object_207,
var_206,
)?;
object_207.finish();
}
if let Some(var_208) = &input.vpc_config {
let mut object_209 = object.key("VpcConfig").start_object();
crate::json_ser::serialize_structure_crate_model_vpc_config(&mut object_209, var_208)?;
object_209.finish();
}
if let Some(var_210) = &input.max_user_duration_in_seconds {
object.key("MaxUserDurationInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_210).into()),
);
}
if let Some(var_211) = &input.disconnect_timeout_in_seconds {
object.key("DisconnectTimeoutInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_211).into()),
);
}
if input.delete_vpc_config {
object
.key("DeleteVpcConfig")
.boolean(input.delete_vpc_config);
}
if let Some(var_212) = &input.description {
object.key("Description").string(var_212);
}
if let Some(var_213) = &input.display_name {
object.key("DisplayName").string(var_213);
}
if let Some(var_214) = &input.enable_default_internet_access {
object.key("EnableDefaultInternetAccess").boolean(*var_214);
}
if let Some(var_215) = &input.domain_join_info {
let mut object_216 = object.key("DomainJoinInfo").start_object();
crate::json_ser::serialize_structure_crate_model_domain_join_info(
&mut object_216,
var_215,
)?;
object_216.finish();
}
if let Some(var_217) = &input.idle_disconnect_timeout_in_seconds {
object.key("IdleDisconnectTimeoutInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_217).into()),
);
}
if let Some(var_218) = &input.attributes_to_delete {
let mut array_219 = object.key("AttributesToDelete").start_array();
for item_220 in var_218 {
{
array_219.value().string(item_220.as_str());
}
}
array_219.finish();
}
if let Some(var_221) = &input.iam_role_arn {
object.key("IamRoleArn").string(var_221);
}
if let Some(var_222) = &input.stream_view {
object.key("StreamView").string(var_222.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_image_permissions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateImagePermissionsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_223) = &input.name {
object.key("Name").string(var_223);
}
if let Some(var_224) = &input.shared_account_id {
object.key("SharedAccountId").string(var_224);
}
if let Some(var_225) = &input.image_permissions {
let mut object_226 = object.key("ImagePermissions").start_object();
crate::json_ser::serialize_structure_crate_model_image_permissions(
&mut object_226,
var_225,
)?;
object_226.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_stack_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateStackInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_227) = &input.display_name {
object.key("DisplayName").string(var_227);
}
if let Some(var_228) = &input.description {
object.key("Description").string(var_228);
}
if let Some(var_229) = &input.name {
object.key("Name").string(var_229);
}
if let Some(var_230) = &input.storage_connectors {
let mut array_231 = object.key("StorageConnectors").start_array();
for item_232 in var_230 {
{
let mut object_233 = array_231.value().start_object();
crate::json_ser::serialize_structure_crate_model_storage_connector(
&mut object_233,
item_232,
)?;
object_233.finish();
}
}
array_231.finish();
}
if input.delete_storage_connectors {
object
.key("DeleteStorageConnectors")
.boolean(input.delete_storage_connectors);
}
if let Some(var_234) = &input.redirect_url {
object.key("RedirectURL").string(var_234);
}
if let Some(var_235) = &input.feedback_url {
object.key("FeedbackURL").string(var_235);
}
if let Some(var_236) = &input.attributes_to_delete {
let mut array_237 = object.key("AttributesToDelete").start_array();
for item_238 in var_236 {
{
array_237.value().string(item_238.as_str());
}
}
array_237.finish();
}
if let Some(var_239) = &input.user_settings {
let mut array_240 = object.key("UserSettings").start_array();
for item_241 in var_239 {
{
let mut object_242 = array_240.value().start_object();
crate::json_ser::serialize_structure_crate_model_user_setting(
&mut object_242,
item_241,
)?;
object_242.finish();
}
}
array_240.finish();
}
if let Some(var_243) = &input.application_settings {
let mut object_244 = object.key("ApplicationSettings").start_object();
crate::json_ser::serialize_structure_crate_model_application_settings(
&mut object_244,
var_243,
)?;
object_244.finish();
}
if let Some(var_245) = &input.access_endpoints {
let mut array_246 = object.key("AccessEndpoints").start_array();
for item_247 in var_245 {
{
let mut object_248 = array_246.value().start_object();
crate::json_ser::serialize_structure_crate_model_access_endpoint(
&mut object_248,
item_247,
)?;
object_248.finish();
}
}
array_246.finish();
}
if let Some(var_249) = &input.embed_host_domains {
let mut array_250 = object.key("EmbedHostDomains").start_array();
for item_251 in var_249 {
{
array_250.value().string(item_251);
}
}
array_250.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_user_stack_association(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UserStackAssociation,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_252) = &input.stack_name {
object.key("StackName").string(var_252);
}
if let Some(var_253) = &input.user_name {
object.key("UserName").string(var_253);
}
if let Some(var_254) = &input.authentication_type {
object.key("AuthenticationType").string(var_254.as_str());
}
if input.send_email_notification {
object
.key("SendEmailNotification")
.boolean(input.send_email_notification);
}
Ok(())
}
pub fn serialize_structure_crate_model_service_account_credentials(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ServiceAccountCredentials,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_255) = &input.account_name {
object.key("AccountName").string(var_255);
}
if let Some(var_256) = &input.account_password {
object.key("AccountPassword").string(var_256);
}
Ok(())
}
pub fn serialize_structure_crate_model_compute_capacity(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ComputeCapacity,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_257) = &input.desired_instances {
object.key("DesiredInstances").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_257).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_vpc_config(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::VpcConfig,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_258) = &input.subnet_ids {
let mut array_259 = object.key("SubnetIds").start_array();
for item_260 in var_258 {
{
array_259.value().string(item_260);
}
}
array_259.finish();
}
if let Some(var_261) = &input.security_group_ids {
let mut array_262 = object.key("SecurityGroupIds").start_array();
for item_263 in var_261 {
{
array_262.value().string(item_263);
}
}
array_262.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_domain_join_info(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DomainJoinInfo,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_264) = &input.directory_name {
object.key("DirectoryName").string(var_264);
}
if let Some(var_265) = &input.organizational_unit_distinguished_name {
object
.key("OrganizationalUnitDistinguishedName")
.string(var_265);
}
Ok(())
}
pub fn serialize_structure_crate_model_access_endpoint(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AccessEndpoint,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_266) = &input.endpoint_type {
object.key("EndpointType").string(var_266.as_str());
}
if let Some(var_267) = &input.vpce_id {
object.key("VpceId").string(var_267);
}
Ok(())
}
pub fn serialize_structure_crate_model_storage_connector(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StorageConnector,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_268) = &input.connector_type {
object.key("ConnectorType").string(var_268.as_str());
}
if let Some(var_269) = &input.resource_identifier {
object.key("ResourceIdentifier").string(var_269);
}
if let Some(var_270) = &input.domains {
let mut array_271 = object.key("Domains").start_array();
for item_272 in var_270 {
{
array_271.value().string(item_272);
}
}
array_271.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_user_setting(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UserSetting,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_273) = &input.action {
object.key("Action").string(var_273.as_str());
}
if let Some(var_274) = &input.permission {
object.key("Permission").string(var_274.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_application_settings(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ApplicationSettings,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
{
object.key("Enabled").boolean(input.enabled);
}
if let Some(var_275) = &input.settings_group {
object.key("SettingsGroup").string(var_275);
}
Ok(())
}
pub fn serialize_structure_crate_model_image_permissions(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ImagePermissions,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_276) = &input.allow_fleet {
object.key("allowFleet").boolean(*var_276);
}
if let Some(var_277) = &input.allow_image_builder {
object.key("allowImageBuilder").boolean(*var_277);
}
Ok(())
}