pub fn serialize_structure_crate_input_associate_application_fleet_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociateApplicationFleetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.fleet_name {
object.key("FleetName").string(var_1.as_str());
}
if let Some(var_2) = &input.application_arn {
object.key("ApplicationArn").string(var_2.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_associate_application_to_entitlement_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociateApplicationToEntitlementInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_3) = &input.stack_name {
object.key("StackName").string(var_3.as_str());
}
if let Some(var_4) = &input.entitlement_name {
object.key("EntitlementName").string(var_4.as_str());
}
if let Some(var_5) = &input.application_identifier {
object.key("ApplicationIdentifier").string(var_5.as_str());
}
Ok(())
}
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::error::SerializationError> {
if let Some(var_6) = &input.fleet_name {
object.key("FleetName").string(var_6.as_str());
}
if let Some(var_7) = &input.stack_name {
object.key("StackName").string(var_7.as_str());
}
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::error::SerializationError> {
if let Some(var_8) = &input.user_stack_associations {
let mut array_9 = object.key("UserStackAssociations").start_array();
for item_10 in var_8 {
{
#[allow(unused_mut)]
let mut object_11 = array_9.value().start_object();
crate::json_ser::serialize_structure_crate_model_user_stack_association(
&mut object_11,
item_10,
)?;
object_11.finish();
}
}
array_9.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::error::SerializationError> {
if let Some(var_12) = &input.user_stack_associations {
let mut array_13 = object.key("UserStackAssociations").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_user_stack_association(
&mut object_15,
item_14,
)?;
object_15.finish();
}
}
array_13.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::error::SerializationError> {
if let Some(var_16) = &input.source_image_name {
object.key("SourceImageName").string(var_16.as_str());
}
if let Some(var_17) = &input.destination_image_name {
object.key("DestinationImageName").string(var_17.as_str());
}
if let Some(var_18) = &input.destination_region {
object.key("DestinationRegion").string(var_18.as_str());
}
if let Some(var_19) = &input.destination_image_description {
object
.key("DestinationImageDescription")
.string(var_19.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_app_block_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateAppBlockInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_20) = &input.name {
object.key("Name").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.display_name {
object.key("DisplayName").string(var_22.as_str());
}
if let Some(var_23) = &input.source_s3_location {
#[allow(unused_mut)]
let mut object_24 = object.key("SourceS3Location").start_object();
crate::json_ser::serialize_structure_crate_model_s3_location(&mut object_24, var_23)?;
object_24.finish();
}
if let Some(var_25) = &input.setup_script_details {
#[allow(unused_mut)]
let mut object_26 = object.key("SetupScriptDetails").start_object();
crate::json_ser::serialize_structure_crate_model_script_details(&mut object_26, var_25)?;
object_26.finish();
}
if let Some(var_27) = &input.tags {
#[allow(unused_mut)]
let mut object_28 = object.key("Tags").start_object();
for (key_29, value_30) in var_27 {
{
object_28.key(key_29.as_str()).string(value_30.as_str());
}
}
object_28.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_application_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateApplicationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_31) = &input.name {
object.key("Name").string(var_31.as_str());
}
if let Some(var_32) = &input.display_name {
object.key("DisplayName").string(var_32.as_str());
}
if let Some(var_33) = &input.description {
object.key("Description").string(var_33.as_str());
}
if let Some(var_34) = &input.icon_s3_location {
#[allow(unused_mut)]
let mut object_35 = object.key("IconS3Location").start_object();
crate::json_ser::serialize_structure_crate_model_s3_location(&mut object_35, var_34)?;
object_35.finish();
}
if let Some(var_36) = &input.launch_path {
object.key("LaunchPath").string(var_36.as_str());
}
if let Some(var_37) = &input.working_directory {
object.key("WorkingDirectory").string(var_37.as_str());
}
if let Some(var_38) = &input.launch_parameters {
object.key("LaunchParameters").string(var_38.as_str());
}
if let Some(var_39) = &input.platforms {
let mut array_40 = object.key("Platforms").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.instance_families {
let mut array_43 = object.key("InstanceFamilies").start_array();
for item_44 in var_42 {
{
array_43.value().string(item_44.as_str());
}
}
array_43.finish();
}
if let Some(var_45) = &input.app_block_arn {
object.key("AppBlockArn").string(var_45.as_str());
}
if let Some(var_46) = &input.tags {
#[allow(unused_mut)]
let mut object_47 = object.key("Tags").start_object();
for (key_48, value_49) in var_46 {
{
object_47.key(key_48.as_str()).string(value_49.as_str());
}
}
object_47.finish();
}
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::error::SerializationError> {
if let Some(var_50) = &input.directory_name {
object.key("DirectoryName").string(var_50.as_str());
}
if let Some(var_51) = &input.organizational_unit_distinguished_names {
let mut array_52 = object
.key("OrganizationalUnitDistinguishedNames")
.start_array();
for item_53 in var_51 {
{
array_52.value().string(item_53.as_str());
}
}
array_52.finish();
}
if let Some(var_54) = &input.service_account_credentials {
#[allow(unused_mut)]
let mut object_55 = object.key("ServiceAccountCredentials").start_object();
crate::json_ser::serialize_structure_crate_model_service_account_credentials(
&mut object_55,
var_54,
)?;
object_55.finish();
}
if let Some(var_56) = &input.certificate_based_auth_properties {
#[allow(unused_mut)]
let mut object_57 = object.key("CertificateBasedAuthProperties").start_object();
crate::json_ser::serialize_structure_crate_model_certificate_based_auth_properties(
&mut object_57,
var_56,
)?;
object_57.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_entitlement_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateEntitlementInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_58) = &input.name {
object.key("Name").string(var_58.as_str());
}
if let Some(var_59) = &input.stack_name {
object.key("StackName").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.app_visibility {
object.key("AppVisibility").string(var_61.as_str());
}
if let Some(var_62) = &input.attributes {
let mut array_63 = object.key("Attributes").start_array();
for item_64 in var_62 {
{
#[allow(unused_mut)]
let mut object_65 = array_63.value().start_object();
crate::json_ser::serialize_structure_crate_model_entitlement_attribute(
&mut object_65,
item_64,
)?;
object_65.finish();
}
}
array_63.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::error::SerializationError> {
if let Some(var_66) = &input.name {
object.key("Name").string(var_66.as_str());
}
if let Some(var_67) = &input.image_name {
object.key("ImageName").string(var_67.as_str());
}
if let Some(var_68) = &input.image_arn {
object.key("ImageArn").string(var_68.as_str());
}
if let Some(var_69) = &input.instance_type {
object.key("InstanceType").string(var_69.as_str());
}
if let Some(var_70) = &input.fleet_type {
object.key("FleetType").string(var_70.as_str());
}
if let Some(var_71) = &input.compute_capacity {
#[allow(unused_mut)]
let mut object_72 = object.key("ComputeCapacity").start_object();
crate::json_ser::serialize_structure_crate_model_compute_capacity(&mut object_72, var_71)?;
object_72.finish();
}
if let Some(var_73) = &input.vpc_config {
#[allow(unused_mut)]
let mut object_74 = object.key("VpcConfig").start_object();
crate::json_ser::serialize_structure_crate_model_vpc_config(&mut object_74, var_73)?;
object_74.finish();
}
if let Some(var_75) = &input.max_user_duration_in_seconds {
object.key("MaxUserDurationInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_75).into()),
);
}
if let Some(var_76) = &input.disconnect_timeout_in_seconds {
object.key("DisconnectTimeoutInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_76).into()),
);
}
if let Some(var_77) = &input.description {
object.key("Description").string(var_77.as_str());
}
if let Some(var_78) = &input.display_name {
object.key("DisplayName").string(var_78.as_str());
}
if let Some(var_79) = &input.enable_default_internet_access {
object.key("EnableDefaultInternetAccess").boolean(*var_79);
}
if let Some(var_80) = &input.domain_join_info {
#[allow(unused_mut)]
let mut object_81 = object.key("DomainJoinInfo").start_object();
crate::json_ser::serialize_structure_crate_model_domain_join_info(&mut object_81, var_80)?;
object_81.finish();
}
if let Some(var_82) = &input.tags {
#[allow(unused_mut)]
let mut object_83 = object.key("Tags").start_object();
for (key_84, value_85) in var_82 {
{
object_83.key(key_84.as_str()).string(value_85.as_str());
}
}
object_83.finish();
}
if let Some(var_86) = &input.idle_disconnect_timeout_in_seconds {
object.key("IdleDisconnectTimeoutInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_86).into()),
);
}
if let Some(var_87) = &input.iam_role_arn {
object.key("IamRoleArn").string(var_87.as_str());
}
if let Some(var_88) = &input.stream_view {
object.key("StreamView").string(var_88.as_str());
}
if let Some(var_89) = &input.platform {
object.key("Platform").string(var_89.as_str());
}
if let Some(var_90) = &input.max_concurrent_sessions {
object.key("MaxConcurrentSessions").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_90).into()),
);
}
if let Some(var_91) = &input.usb_device_filter_strings {
let mut array_92 = object.key("UsbDeviceFilterStrings").start_array();
for item_93 in var_91 {
{
array_92.value().string(item_93.as_str());
}
}
array_92.finish();
}
if let Some(var_94) = &input.session_script_s3_location {
#[allow(unused_mut)]
let mut object_95 = object.key("SessionScriptS3Location").start_object();
crate::json_ser::serialize_structure_crate_model_s3_location(&mut object_95, var_94)?;
object_95.finish();
}
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::error::SerializationError> {
if let Some(var_96) = &input.name {
object.key("Name").string(var_96.as_str());
}
if let Some(var_97) = &input.image_name {
object.key("ImageName").string(var_97.as_str());
}
if let Some(var_98) = &input.image_arn {
object.key("ImageArn").string(var_98.as_str());
}
if let Some(var_99) = &input.instance_type {
object.key("InstanceType").string(var_99.as_str());
}
if let Some(var_100) = &input.description {
object.key("Description").string(var_100.as_str());
}
if let Some(var_101) = &input.display_name {
object.key("DisplayName").string(var_101.as_str());
}
if let Some(var_102) = &input.vpc_config {
#[allow(unused_mut)]
let mut object_103 = object.key("VpcConfig").start_object();
crate::json_ser::serialize_structure_crate_model_vpc_config(&mut object_103, var_102)?;
object_103.finish();
}
if let Some(var_104) = &input.iam_role_arn {
object.key("IamRoleArn").string(var_104.as_str());
}
if let Some(var_105) = &input.enable_default_internet_access {
object.key("EnableDefaultInternetAccess").boolean(*var_105);
}
if let Some(var_106) = &input.domain_join_info {
#[allow(unused_mut)]
let mut object_107 = object.key("DomainJoinInfo").start_object();
crate::json_ser::serialize_structure_crate_model_domain_join_info(
&mut object_107,
var_106,
)?;
object_107.finish();
}
if let Some(var_108) = &input.appstream_agent_version {
object.key("AppstreamAgentVersion").string(var_108.as_str());
}
if let Some(var_109) = &input.tags {
#[allow(unused_mut)]
let mut object_110 = object.key("Tags").start_object();
for (key_111, value_112) in var_109 {
{
object_110.key(key_111.as_str()).string(value_112.as_str());
}
}
object_110.finish();
}
if let Some(var_113) = &input.access_endpoints {
let mut array_114 = object.key("AccessEndpoints").start_array();
for item_115 in var_113 {
{
#[allow(unused_mut)]
let mut object_116 = array_114.value().start_object();
crate::json_ser::serialize_structure_crate_model_access_endpoint(
&mut object_116,
item_115,
)?;
object_116.finish();
}
}
array_114.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::error::SerializationError> {
if let Some(var_117) = &input.name {
object.key("Name").string(var_117.as_str());
}
if let Some(var_118) = &input.validity {
object.key("Validity").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_118).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::error::SerializationError> {
if let Some(var_119) = &input.name {
object.key("Name").string(var_119.as_str());
}
if let Some(var_120) = &input.description {
object.key("Description").string(var_120.as_str());
}
if let Some(var_121) = &input.display_name {
object.key("DisplayName").string(var_121.as_str());
}
if let Some(var_122) = &input.storage_connectors {
let mut array_123 = object.key("StorageConnectors").start_array();
for item_124 in var_122 {
{
#[allow(unused_mut)]
let mut object_125 = array_123.value().start_object();
crate::json_ser::serialize_structure_crate_model_storage_connector(
&mut object_125,
item_124,
)?;
object_125.finish();
}
}
array_123.finish();
}
if let Some(var_126) = &input.redirect_url {
object.key("RedirectURL").string(var_126.as_str());
}
if let Some(var_127) = &input.feedback_url {
object.key("FeedbackURL").string(var_127.as_str());
}
if let Some(var_128) = &input.user_settings {
let mut array_129 = object.key("UserSettings").start_array();
for item_130 in var_128 {
{
#[allow(unused_mut)]
let mut object_131 = array_129.value().start_object();
crate::json_ser::serialize_structure_crate_model_user_setting(
&mut object_131,
item_130,
)?;
object_131.finish();
}
}
array_129.finish();
}
if let Some(var_132) = &input.application_settings {
#[allow(unused_mut)]
let mut object_133 = object.key("ApplicationSettings").start_object();
crate::json_ser::serialize_structure_crate_model_application_settings(
&mut object_133,
var_132,
)?;
object_133.finish();
}
if let Some(var_134) = &input.tags {
#[allow(unused_mut)]
let mut object_135 = object.key("Tags").start_object();
for (key_136, value_137) in var_134 {
{
object_135.key(key_136.as_str()).string(value_137.as_str());
}
}
object_135.finish();
}
if let Some(var_138) = &input.access_endpoints {
let mut array_139 = object.key("AccessEndpoints").start_array();
for item_140 in var_138 {
{
#[allow(unused_mut)]
let mut object_141 = array_139.value().start_object();
crate::json_ser::serialize_structure_crate_model_access_endpoint(
&mut object_141,
item_140,
)?;
object_141.finish();
}
}
array_139.finish();
}
if let Some(var_142) = &input.embed_host_domains {
let mut array_143 = object.key("EmbedHostDomains").start_array();
for item_144 in var_142 {
{
array_143.value().string(item_144.as_str());
}
}
array_143.finish();
}
if let Some(var_145) = &input.streaming_experience_settings {
#[allow(unused_mut)]
let mut object_146 = object.key("StreamingExperienceSettings").start_object();
crate::json_ser::serialize_structure_crate_model_streaming_experience_settings(
&mut object_146,
var_145,
)?;
object_146.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::error::SerializationError> {
if let Some(var_147) = &input.stack_name {
object.key("StackName").string(var_147.as_str());
}
if let Some(var_148) = &input.fleet_name {
object.key("FleetName").string(var_148.as_str());
}
if let Some(var_149) = &input.user_id {
object.key("UserId").string(var_149.as_str());
}
if let Some(var_150) = &input.application_id {
object.key("ApplicationId").string(var_150.as_str());
}
if let Some(var_151) = &input.validity {
object.key("Validity").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_151).into()),
);
}
if let Some(var_152) = &input.session_context {
object.key("SessionContext").string(var_152.as_str());
}
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::error::SerializationError> {
if let Some(var_153) = &input.existing_image_name {
object.key("existingImageName").string(var_153.as_str());
}
if let Some(var_154) = &input.new_image_name {
object.key("newImageName").string(var_154.as_str());
}
if let Some(var_155) = &input.new_image_description {
object.key("newImageDescription").string(var_155.as_str());
}
if let Some(var_156) = &input.new_image_display_name {
object.key("newImageDisplayName").string(var_156.as_str());
}
if let Some(var_157) = &input.new_image_tags {
#[allow(unused_mut)]
let mut object_158 = object.key("newImageTags").start_object();
for (key_159, value_160) in var_157 {
{
object_158.key(key_159.as_str()).string(value_160.as_str());
}
}
object_158.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::error::SerializationError> {
if let Some(var_161) = &input.user_name {
object.key("UserName").string(var_161.as_str());
}
if let Some(var_162) = &input.message_action {
object.key("MessageAction").string(var_162.as_str());
}
if let Some(var_163) = &input.first_name {
object.key("FirstName").string(var_163.as_str());
}
if let Some(var_164) = &input.last_name {
object.key("LastName").string(var_164.as_str());
}
if let Some(var_165) = &input.authentication_type {
object.key("AuthenticationType").string(var_165.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_app_block_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteAppBlockInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_166) = &input.name {
object.key("Name").string(var_166.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_application_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteApplicationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_167) = &input.name {
object.key("Name").string(var_167.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::error::SerializationError> {
if let Some(var_168) = &input.directory_name {
object.key("DirectoryName").string(var_168.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_entitlement_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteEntitlementInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_169) = &input.name {
object.key("Name").string(var_169.as_str());
}
if let Some(var_170) = &input.stack_name {
object.key("StackName").string(var_170.as_str());
}
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::error::SerializationError> {
if let Some(var_171) = &input.name {
object.key("Name").string(var_171.as_str());
}
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::error::SerializationError> {
if let Some(var_172) = &input.name {
object.key("Name").string(var_172.as_str());
}
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::error::SerializationError> {
if let Some(var_173) = &input.name {
object.key("Name").string(var_173.as_str());
}
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::error::SerializationError> {
if let Some(var_174) = &input.name {
object.key("Name").string(var_174.as_str());
}
if let Some(var_175) = &input.shared_account_id {
object.key("SharedAccountId").string(var_175.as_str());
}
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::error::SerializationError> {
if let Some(var_176) = &input.name {
object.key("Name").string(var_176.as_str());
}
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::error::SerializationError> {
if let Some(var_177) = &input.user_name {
object.key("UserName").string(var_177.as_str());
}
if let Some(var_178) = &input.authentication_type {
object.key("AuthenticationType").string(var_178.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_app_blocks_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeAppBlocksInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_179) = &input.arns {
let mut array_180 = object.key("Arns").start_array();
for item_181 in var_179 {
{
array_180.value().string(item_181.as_str());
}
}
array_180.finish();
}
if let Some(var_182) = &input.next_token {
object.key("NextToken").string(var_182.as_str());
}
if let Some(var_183) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_183).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_application_fleet_associations_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeApplicationFleetAssociationsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_184) = &input.fleet_name {
object.key("FleetName").string(var_184.as_str());
}
if let Some(var_185) = &input.application_arn {
object.key("ApplicationArn").string(var_185.as_str());
}
if let Some(var_186) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_186).into()),
);
}
if let Some(var_187) = &input.next_token {
object.key("NextToken").string(var_187.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_applications_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeApplicationsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_188) = &input.arns {
let mut array_189 = object.key("Arns").start_array();
for item_190 in var_188 {
{
array_189.value().string(item_190.as_str());
}
}
array_189.finish();
}
if let Some(var_191) = &input.next_token {
object.key("NextToken").string(var_191.as_str());
}
if let Some(var_192) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_192).into()),
);
}
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::error::SerializationError> {
if let Some(var_193) = &input.directory_names {
let mut array_194 = object.key("DirectoryNames").start_array();
for item_195 in var_193 {
{
array_194.value().string(item_195.as_str());
}
}
array_194.finish();
}
if let Some(var_196) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_196).into()),
);
}
if let Some(var_197) = &input.next_token {
object.key("NextToken").string(var_197.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_entitlements_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeEntitlementsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_198) = &input.name {
object.key("Name").string(var_198.as_str());
}
if let Some(var_199) = &input.stack_name {
object.key("StackName").string(var_199.as_str());
}
if let Some(var_200) = &input.next_token {
object.key("NextToken").string(var_200.as_str());
}
if let Some(var_201) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_201).into()),
);
}
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::error::SerializationError> {
if let Some(var_202) = &input.names {
let mut array_203 = object.key("Names").start_array();
for item_204 in var_202 {
{
array_203.value().string(item_204.as_str());
}
}
array_203.finish();
}
if let Some(var_205) = &input.next_token {
object.key("NextToken").string(var_205.as_str());
}
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::error::SerializationError> {
if let Some(var_206) = &input.names {
let mut array_207 = object.key("Names").start_array();
for item_208 in var_206 {
{
array_207.value().string(item_208.as_str());
}
}
array_207.finish();
}
if let Some(var_209) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_209).into()),
);
}
if let Some(var_210) = &input.next_token {
object.key("NextToken").string(var_210.as_str());
}
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::error::SerializationError> {
if let Some(var_211) = &input.name {
object.key("Name").string(var_211.as_str());
}
if let Some(var_212) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_212).into()),
);
}
if let Some(var_213) = &input.shared_aws_account_ids {
let mut array_214 = object.key("SharedAwsAccountIds").start_array();
for item_215 in var_213 {
{
array_214.value().string(item_215.as_str());
}
}
array_214.finish();
}
if let Some(var_216) = &input.next_token {
object.key("NextToken").string(var_216.as_str());
}
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::error::SerializationError> {
if let Some(var_217) = &input.names {
let mut array_218 = object.key("Names").start_array();
for item_219 in var_217 {
{
array_218.value().string(item_219.as_str());
}
}
array_218.finish();
}
if let Some(var_220) = &input.arns {
let mut array_221 = object.key("Arns").start_array();
for item_222 in var_220 {
{
array_221.value().string(item_222.as_str());
}
}
array_221.finish();
}
if let Some(var_223) = &input.r#type {
object.key("Type").string(var_223.as_str());
}
if let Some(var_224) = &input.next_token {
object.key("NextToken").string(var_224.as_str());
}
if let Some(var_225) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_225).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::error::SerializationError> {
if let Some(var_226) = &input.stack_name {
object.key("StackName").string(var_226.as_str());
}
if let Some(var_227) = &input.fleet_name {
object.key("FleetName").string(var_227.as_str());
}
if let Some(var_228) = &input.user_id {
object.key("UserId").string(var_228.as_str());
}
if let Some(var_229) = &input.next_token {
object.key("NextToken").string(var_229.as_str());
}
if let Some(var_230) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_230).into()),
);
}
if let Some(var_231) = &input.authentication_type {
object.key("AuthenticationType").string(var_231.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::error::SerializationError> {
if let Some(var_232) = &input.names {
let mut array_233 = object.key("Names").start_array();
for item_234 in var_232 {
{
array_233.value().string(item_234.as_str());
}
}
array_233.finish();
}
if let Some(var_235) = &input.next_token {
object.key("NextToken").string(var_235.as_str());
}
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::error::SerializationError> {
if let Some(var_236) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_236).into()),
);
}
if let Some(var_237) = &input.next_token {
object.key("NextToken").string(var_237.as_str());
}
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::error::SerializationError> {
if let Some(var_238) = &input.authentication_type {
object.key("AuthenticationType").string(var_238.as_str());
}
if let Some(var_239) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_239).into()),
);
}
if let Some(var_240) = &input.next_token {
object.key("NextToken").string(var_240.as_str());
}
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::error::SerializationError> {
if let Some(var_241) = &input.stack_name {
object.key("StackName").string(var_241.as_str());
}
if let Some(var_242) = &input.user_name {
object.key("UserName").string(var_242.as_str());
}
if let Some(var_243) = &input.authentication_type {
object.key("AuthenticationType").string(var_243.as_str());
}
if let Some(var_244) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_244).into()),
);
}
if let Some(var_245) = &input.next_token {
object.key("NextToken").string(var_245.as_str());
}
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::error::SerializationError> {
if let Some(var_246) = &input.user_name {
object.key("UserName").string(var_246.as_str());
}
if let Some(var_247) = &input.authentication_type {
object.key("AuthenticationType").string(var_247.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_disassociate_application_fleet_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DisassociateApplicationFleetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_248) = &input.fleet_name {
object.key("FleetName").string(var_248.as_str());
}
if let Some(var_249) = &input.application_arn {
object.key("ApplicationArn").string(var_249.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_disassociate_application_from_entitlement_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DisassociateApplicationFromEntitlementInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_250) = &input.stack_name {
object.key("StackName").string(var_250.as_str());
}
if let Some(var_251) = &input.entitlement_name {
object.key("EntitlementName").string(var_251.as_str());
}
if let Some(var_252) = &input.application_identifier {
object.key("ApplicationIdentifier").string(var_252.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::error::SerializationError> {
if let Some(var_253) = &input.fleet_name {
object.key("FleetName").string(var_253.as_str());
}
if let Some(var_254) = &input.stack_name {
object.key("StackName").string(var_254.as_str());
}
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::error::SerializationError> {
if let Some(var_255) = &input.user_name {
object.key("UserName").string(var_255.as_str());
}
if let Some(var_256) = &input.authentication_type {
object.key("AuthenticationType").string(var_256.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::error::SerializationError> {
if let Some(var_257) = &input.session_id {
object.key("SessionId").string(var_257.as_str());
}
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::error::SerializationError> {
if let Some(var_258) = &input.stack_name {
object.key("StackName").string(var_258.as_str());
}
if let Some(var_259) = &input.next_token {
object.key("NextToken").string(var_259.as_str());
}
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::error::SerializationError> {
if let Some(var_260) = &input.fleet_name {
object.key("FleetName").string(var_260.as_str());
}
if let Some(var_261) = &input.next_token {
object.key("NextToken").string(var_261.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_entitled_applications_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListEntitledApplicationsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_262) = &input.stack_name {
object.key("StackName").string(var_262.as_str());
}
if let Some(var_263) = &input.entitlement_name {
object.key("EntitlementName").string(var_263.as_str());
}
if let Some(var_264) = &input.next_token {
object.key("NextToken").string(var_264.as_str());
}
if let Some(var_265) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_265).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_266) = &input.resource_arn {
object.key("ResourceArn").string(var_266.as_str());
}
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::error::SerializationError> {
if let Some(var_267) = &input.name {
object.key("Name").string(var_267.as_str());
}
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::error::SerializationError> {
if let Some(var_268) = &input.name {
object.key("Name").string(var_268.as_str());
}
if let Some(var_269) = &input.appstream_agent_version {
object.key("AppstreamAgentVersion").string(var_269.as_str());
}
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::error::SerializationError> {
if let Some(var_270) = &input.name {
object.key("Name").string(var_270.as_str());
}
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::error::SerializationError> {
if let Some(var_271) = &input.name {
object.key("Name").string(var_271.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_tag_resource_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::TagResourceInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_272) = &input.resource_arn {
object.key("ResourceArn").string(var_272.as_str());
}
if let Some(var_273) = &input.tags {
#[allow(unused_mut)]
let mut object_274 = object.key("Tags").start_object();
for (key_275, value_276) in var_273 {
{
object_274.key(key_275.as_str()).string(value_276.as_str());
}
}
object_274.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_277) = &input.resource_arn {
object.key("ResourceArn").string(var_277.as_str());
}
if let Some(var_278) = &input.tag_keys {
let mut array_279 = object.key("TagKeys").start_array();
for item_280 in var_278 {
{
array_279.value().string(item_280.as_str());
}
}
array_279.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_application_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateApplicationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_281) = &input.name {
object.key("Name").string(var_281.as_str());
}
if let Some(var_282) = &input.display_name {
object.key("DisplayName").string(var_282.as_str());
}
if let Some(var_283) = &input.description {
object.key("Description").string(var_283.as_str());
}
if let Some(var_284) = &input.icon_s3_location {
#[allow(unused_mut)]
let mut object_285 = object.key("IconS3Location").start_object();
crate::json_ser::serialize_structure_crate_model_s3_location(&mut object_285, var_284)?;
object_285.finish();
}
if let Some(var_286) = &input.launch_path {
object.key("LaunchPath").string(var_286.as_str());
}
if let Some(var_287) = &input.working_directory {
object.key("WorkingDirectory").string(var_287.as_str());
}
if let Some(var_288) = &input.launch_parameters {
object.key("LaunchParameters").string(var_288.as_str());
}
if let Some(var_289) = &input.app_block_arn {
object.key("AppBlockArn").string(var_289.as_str());
}
if let Some(var_290) = &input.attributes_to_delete {
let mut array_291 = object.key("AttributesToDelete").start_array();
for item_292 in var_290 {
{
array_291.value().string(item_292.as_str());
}
}
array_291.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::error::SerializationError> {
if let Some(var_293) = &input.directory_name {
object.key("DirectoryName").string(var_293.as_str());
}
if let Some(var_294) = &input.organizational_unit_distinguished_names {
let mut array_295 = object
.key("OrganizationalUnitDistinguishedNames")
.start_array();
for item_296 in var_294 {
{
array_295.value().string(item_296.as_str());
}
}
array_295.finish();
}
if let Some(var_297) = &input.service_account_credentials {
#[allow(unused_mut)]
let mut object_298 = object.key("ServiceAccountCredentials").start_object();
crate::json_ser::serialize_structure_crate_model_service_account_credentials(
&mut object_298,
var_297,
)?;
object_298.finish();
}
if let Some(var_299) = &input.certificate_based_auth_properties {
#[allow(unused_mut)]
let mut object_300 = object.key("CertificateBasedAuthProperties").start_object();
crate::json_ser::serialize_structure_crate_model_certificate_based_auth_properties(
&mut object_300,
var_299,
)?;
object_300.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_entitlement_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateEntitlementInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_301) = &input.name {
object.key("Name").string(var_301.as_str());
}
if let Some(var_302) = &input.stack_name {
object.key("StackName").string(var_302.as_str());
}
if let Some(var_303) = &input.description {
object.key("Description").string(var_303.as_str());
}
if let Some(var_304) = &input.app_visibility {
object.key("AppVisibility").string(var_304.as_str());
}
if let Some(var_305) = &input.attributes {
let mut array_306 = object.key("Attributes").start_array();
for item_307 in var_305 {
{
#[allow(unused_mut)]
let mut object_308 = array_306.value().start_object();
crate::json_ser::serialize_structure_crate_model_entitlement_attribute(
&mut object_308,
item_307,
)?;
object_308.finish();
}
}
array_306.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::error::SerializationError> {
if let Some(var_309) = &input.image_name {
object.key("ImageName").string(var_309.as_str());
}
if let Some(var_310) = &input.image_arn {
object.key("ImageArn").string(var_310.as_str());
}
if let Some(var_311) = &input.name {
object.key("Name").string(var_311.as_str());
}
if let Some(var_312) = &input.instance_type {
object.key("InstanceType").string(var_312.as_str());
}
if let Some(var_313) = &input.compute_capacity {
#[allow(unused_mut)]
let mut object_314 = object.key("ComputeCapacity").start_object();
crate::json_ser::serialize_structure_crate_model_compute_capacity(
&mut object_314,
var_313,
)?;
object_314.finish();
}
if let Some(var_315) = &input.vpc_config {
#[allow(unused_mut)]
let mut object_316 = object.key("VpcConfig").start_object();
crate::json_ser::serialize_structure_crate_model_vpc_config(&mut object_316, var_315)?;
object_316.finish();
}
if let Some(var_317) = &input.max_user_duration_in_seconds {
object.key("MaxUserDurationInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_317).into()),
);
}
if let Some(var_318) = &input.disconnect_timeout_in_seconds {
object.key("DisconnectTimeoutInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_318).into()),
);
}
if input.delete_vpc_config {
object
.key("DeleteVpcConfig")
.boolean(input.delete_vpc_config);
}
if let Some(var_319) = &input.description {
object.key("Description").string(var_319.as_str());
}
if let Some(var_320) = &input.display_name {
object.key("DisplayName").string(var_320.as_str());
}
if let Some(var_321) = &input.enable_default_internet_access {
object.key("EnableDefaultInternetAccess").boolean(*var_321);
}
if let Some(var_322) = &input.domain_join_info {
#[allow(unused_mut)]
let mut object_323 = object.key("DomainJoinInfo").start_object();
crate::json_ser::serialize_structure_crate_model_domain_join_info(
&mut object_323,
var_322,
)?;
object_323.finish();
}
if let Some(var_324) = &input.idle_disconnect_timeout_in_seconds {
object.key("IdleDisconnectTimeoutInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_324).into()),
);
}
if let Some(var_325) = &input.attributes_to_delete {
let mut array_326 = object.key("AttributesToDelete").start_array();
for item_327 in var_325 {
{
array_326.value().string(item_327.as_str());
}
}
array_326.finish();
}
if let Some(var_328) = &input.iam_role_arn {
object.key("IamRoleArn").string(var_328.as_str());
}
if let Some(var_329) = &input.stream_view {
object.key("StreamView").string(var_329.as_str());
}
if let Some(var_330) = &input.platform {
object.key("Platform").string(var_330.as_str());
}
if let Some(var_331) = &input.max_concurrent_sessions {
object.key("MaxConcurrentSessions").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_331).into()),
);
}
if let Some(var_332) = &input.usb_device_filter_strings {
let mut array_333 = object.key("UsbDeviceFilterStrings").start_array();
for item_334 in var_332 {
{
array_333.value().string(item_334.as_str());
}
}
array_333.finish();
}
if let Some(var_335) = &input.session_script_s3_location {
#[allow(unused_mut)]
let mut object_336 = object.key("SessionScriptS3Location").start_object();
crate::json_ser::serialize_structure_crate_model_s3_location(&mut object_336, var_335)?;
object_336.finish();
}
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::error::SerializationError> {
if let Some(var_337) = &input.name {
object.key("Name").string(var_337.as_str());
}
if let Some(var_338) = &input.shared_account_id {
object.key("SharedAccountId").string(var_338.as_str());
}
if let Some(var_339) = &input.image_permissions {
#[allow(unused_mut)]
let mut object_340 = object.key("ImagePermissions").start_object();
crate::json_ser::serialize_structure_crate_model_image_permissions(
&mut object_340,
var_339,
)?;
object_340.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::error::SerializationError> {
if let Some(var_341) = &input.display_name {
object.key("DisplayName").string(var_341.as_str());
}
if let Some(var_342) = &input.description {
object.key("Description").string(var_342.as_str());
}
if let Some(var_343) = &input.name {
object.key("Name").string(var_343.as_str());
}
if let Some(var_344) = &input.storage_connectors {
let mut array_345 = object.key("StorageConnectors").start_array();
for item_346 in var_344 {
{
#[allow(unused_mut)]
let mut object_347 = array_345.value().start_object();
crate::json_ser::serialize_structure_crate_model_storage_connector(
&mut object_347,
item_346,
)?;
object_347.finish();
}
}
array_345.finish();
}
if input.delete_storage_connectors {
object
.key("DeleteStorageConnectors")
.boolean(input.delete_storage_connectors);
}
if let Some(var_348) = &input.redirect_url {
object.key("RedirectURL").string(var_348.as_str());
}
if let Some(var_349) = &input.feedback_url {
object.key("FeedbackURL").string(var_349.as_str());
}
if let Some(var_350) = &input.attributes_to_delete {
let mut array_351 = object.key("AttributesToDelete").start_array();
for item_352 in var_350 {
{
array_351.value().string(item_352.as_str());
}
}
array_351.finish();
}
if let Some(var_353) = &input.user_settings {
let mut array_354 = object.key("UserSettings").start_array();
for item_355 in var_353 {
{
#[allow(unused_mut)]
let mut object_356 = array_354.value().start_object();
crate::json_ser::serialize_structure_crate_model_user_setting(
&mut object_356,
item_355,
)?;
object_356.finish();
}
}
array_354.finish();
}
if let Some(var_357) = &input.application_settings {
#[allow(unused_mut)]
let mut object_358 = object.key("ApplicationSettings").start_object();
crate::json_ser::serialize_structure_crate_model_application_settings(
&mut object_358,
var_357,
)?;
object_358.finish();
}
if let Some(var_359) = &input.access_endpoints {
let mut array_360 = object.key("AccessEndpoints").start_array();
for item_361 in var_359 {
{
#[allow(unused_mut)]
let mut object_362 = array_360.value().start_object();
crate::json_ser::serialize_structure_crate_model_access_endpoint(
&mut object_362,
item_361,
)?;
object_362.finish();
}
}
array_360.finish();
}
if let Some(var_363) = &input.embed_host_domains {
let mut array_364 = object.key("EmbedHostDomains").start_array();
for item_365 in var_363 {
{
array_364.value().string(item_365.as_str());
}
}
array_364.finish();
}
if let Some(var_366) = &input.streaming_experience_settings {
#[allow(unused_mut)]
let mut object_367 = object.key("StreamingExperienceSettings").start_object();
crate::json_ser::serialize_structure_crate_model_streaming_experience_settings(
&mut object_367,
var_366,
)?;
object_367.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::error::SerializationError> {
if let Some(var_368) = &input.stack_name {
object.key("StackName").string(var_368.as_str());
}
if let Some(var_369) = &input.user_name {
object.key("UserName").string(var_369.as_str());
}
if let Some(var_370) = &input.authentication_type {
object.key("AuthenticationType").string(var_370.as_str());
}
if input.send_email_notification {
object
.key("SendEmailNotification")
.boolean(input.send_email_notification);
}
Ok(())
}
pub fn serialize_structure_crate_model_s3_location(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::S3Location,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_371) = &input.s3_bucket {
object.key("S3Bucket").string(var_371.as_str());
}
if let Some(var_372) = &input.s3_key {
object.key("S3Key").string(var_372.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_script_details(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ScriptDetails,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_373) = &input.script_s3_location {
#[allow(unused_mut)]
let mut object_374 = object.key("ScriptS3Location").start_object();
crate::json_ser::serialize_structure_crate_model_s3_location(&mut object_374, var_373)?;
object_374.finish();
}
if let Some(var_375) = &input.executable_path {
object.key("ExecutablePath").string(var_375.as_str());
}
if let Some(var_376) = &input.executable_parameters {
object.key("ExecutableParameters").string(var_376.as_str());
}
if let Some(var_377) = &input.timeout_in_seconds {
object.key("TimeoutInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_377).into()),
);
}
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::error::SerializationError> {
if let Some(var_378) = &input.account_name {
object.key("AccountName").string(var_378.as_str());
}
if let Some(var_379) = &input.account_password {
object.key("AccountPassword").string(var_379.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_certificate_based_auth_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CertificateBasedAuthProperties,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_380) = &input.status {
object.key("Status").string(var_380.as_str());
}
if let Some(var_381) = &input.certificate_authority_arn {
object
.key("CertificateAuthorityArn")
.string(var_381.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_entitlement_attribute(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::EntitlementAttribute,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_382) = &input.name {
object.key("Name").string(var_382.as_str());
}
if let Some(var_383) = &input.value {
object.key("Value").string(var_383.as_str());
}
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::error::SerializationError> {
if let Some(var_384) = &input.desired_instances {
object.key("DesiredInstances").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_384).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::error::SerializationError> {
if let Some(var_385) = &input.subnet_ids {
let mut array_386 = object.key("SubnetIds").start_array();
for item_387 in var_385 {
{
array_386.value().string(item_387.as_str());
}
}
array_386.finish();
}
if let Some(var_388) = &input.security_group_ids {
let mut array_389 = object.key("SecurityGroupIds").start_array();
for item_390 in var_388 {
{
array_389.value().string(item_390.as_str());
}
}
array_389.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::error::SerializationError> {
if let Some(var_391) = &input.directory_name {
object.key("DirectoryName").string(var_391.as_str());
}
if let Some(var_392) = &input.organizational_unit_distinguished_name {
object
.key("OrganizationalUnitDistinguishedName")
.string(var_392.as_str());
}
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::error::SerializationError> {
if let Some(var_393) = &input.endpoint_type {
object.key("EndpointType").string(var_393.as_str());
}
if let Some(var_394) = &input.vpce_id {
object.key("VpceId").string(var_394.as_str());
}
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::error::SerializationError> {
if let Some(var_395) = &input.connector_type {
object.key("ConnectorType").string(var_395.as_str());
}
if let Some(var_396) = &input.resource_identifier {
object.key("ResourceIdentifier").string(var_396.as_str());
}
if let Some(var_397) = &input.domains {
let mut array_398 = object.key("Domains").start_array();
for item_399 in var_397 {
{
array_398.value().string(item_399.as_str());
}
}
array_398.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::error::SerializationError> {
if let Some(var_400) = &input.action {
object.key("Action").string(var_400.as_str());
}
if let Some(var_401) = &input.permission {
object.key("Permission").string(var_401.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::error::SerializationError> {
{
object.key("Enabled").boolean(input.enabled);
}
if let Some(var_402) = &input.settings_group {
object.key("SettingsGroup").string(var_402.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_streaming_experience_settings(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StreamingExperienceSettings,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_403) = &input.preferred_protocol {
object.key("PreferredProtocol").string(var_403.as_str());
}
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::error::SerializationError> {
if let Some(var_404) = &input.allow_fleet {
object.key("allowFleet").boolean(*var_404);
}
if let Some(var_405) = &input.allow_image_builder {
object.key("allowImageBuilder").boolean(*var_405);
}
Ok(())
}