pub fn serialize_structure_crate_input_associate_connection_alias_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociateConnectionAliasInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_1) = &input.alias_id {
object.key("AliasId").string(var_1.as_str());
}
if let Some(var_2) = &input.resource_id {
object.key("ResourceId").string(var_2.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_associate_ip_groups_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AssociateIpGroupsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_3) = &input.directory_id {
object.key("DirectoryId").string(var_3.as_str());
}
if let Some(var_4) = &input.group_ids {
let mut array_5 = object.key("GroupIds").start_array();
for item_6 in var_4 {
{
array_5.value().string(item_6.as_str());
}
}
array_5.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_authorize_ip_rules_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AuthorizeIpRulesInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_7) = &input.group_id {
object.key("GroupId").string(var_7.as_str());
}
if let Some(var_8) = &input.user_rules {
let mut array_9 = object.key("UserRules").start_array();
for item_10 in var_8 {
{
let mut object_11 = array_9.value().start_object();
crate::json_ser::serialize_structure_crate_model_ip_rule_item(
&mut object_11,
item_10,
)?;
object_11.finish();
}
}
array_9.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_copy_workspace_image_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CopyWorkspaceImageInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_12) = &input.name {
object.key("Name").string(var_12.as_str());
}
if let Some(var_13) = &input.description {
object.key("Description").string(var_13.as_str());
}
if let Some(var_14) = &input.source_image_id {
object.key("SourceImageId").string(var_14.as_str());
}
if let Some(var_15) = &input.source_region {
object.key("SourceRegion").string(var_15.as_str());
}
if let Some(var_16) = &input.tags {
let mut array_17 = object.key("Tags").start_array();
for item_18 in var_16 {
{
let mut object_19 = array_17.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_19, item_18)?;
object_19.finish();
}
}
array_17.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_connect_client_add_in_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateConnectClientAddInInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_20) = &input.resource_id {
object.key("ResourceId").string(var_20.as_str());
}
if let Some(var_21) = &input.name {
object.key("Name").string(var_21.as_str());
}
if let Some(var_22) = &input.url {
object.key("URL").string(var_22.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_connection_alias_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateConnectionAliasInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_23) = &input.connection_string {
object.key("ConnectionString").string(var_23.as_str());
}
if let Some(var_24) = &input.tags {
let mut array_25 = object.key("Tags").start_array();
for item_26 in var_24 {
{
let mut object_27 = array_25.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_27, item_26)?;
object_27.finish();
}
}
array_25.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_ip_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateIpGroupInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_28) = &input.group_name {
object.key("GroupName").string(var_28.as_str());
}
if let Some(var_29) = &input.group_desc {
object.key("GroupDesc").string(var_29.as_str());
}
if let Some(var_30) = &input.user_rules {
let mut array_31 = object.key("UserRules").start_array();
for item_32 in var_30 {
{
let mut object_33 = array_31.value().start_object();
crate::json_ser::serialize_structure_crate_model_ip_rule_item(
&mut object_33,
item_32,
)?;
object_33.finish();
}
}
array_31.finish();
}
if let Some(var_34) = &input.tags {
let mut array_35 = object.key("Tags").start_array();
for item_36 in var_34 {
{
let mut object_37 = array_35.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_37, item_36)?;
object_37.finish();
}
}
array_35.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_tags_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateTagsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_38) = &input.resource_id {
object.key("ResourceId").string(var_38.as_str());
}
if let Some(var_39) = &input.tags {
let mut array_40 = object.key("Tags").start_array();
for item_41 in var_39 {
{
let mut object_42 = array_40.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_42, item_41)?;
object_42.finish();
}
}
array_40.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_updated_workspace_image_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateUpdatedWorkspaceImageInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_43) = &input.name {
object.key("Name").string(var_43.as_str());
}
if let Some(var_44) = &input.description {
object.key("Description").string(var_44.as_str());
}
if let Some(var_45) = &input.source_image_id {
object.key("SourceImageId").string(var_45.as_str());
}
if let Some(var_46) = &input.tags {
let mut array_47 = object.key("Tags").start_array();
for item_48 in var_46 {
{
let mut object_49 = array_47.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_49, item_48)?;
object_49.finish();
}
}
array_47.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_workspace_bundle_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateWorkspaceBundleInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_50) = &input.bundle_name {
object.key("BundleName").string(var_50.as_str());
}
if let Some(var_51) = &input.bundle_description {
object.key("BundleDescription").string(var_51.as_str());
}
if let Some(var_52) = &input.image_id {
object.key("ImageId").string(var_52.as_str());
}
if let Some(var_53) = &input.compute_type {
let mut object_54 = object.key("ComputeType").start_object();
crate::json_ser::serialize_structure_crate_model_compute_type(&mut object_54, var_53)?;
object_54.finish();
}
if let Some(var_55) = &input.user_storage {
let mut object_56 = object.key("UserStorage").start_object();
crate::json_ser::serialize_structure_crate_model_user_storage(&mut object_56, var_55)?;
object_56.finish();
}
if let Some(var_57) = &input.root_storage {
let mut object_58 = object.key("RootStorage").start_object();
crate::json_ser::serialize_structure_crate_model_root_storage(&mut object_58, var_57)?;
object_58.finish();
}
if let Some(var_59) = &input.tags {
let mut array_60 = object.key("Tags").start_array();
for item_61 in var_59 {
{
let mut object_62 = array_60.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_62, item_61)?;
object_62.finish();
}
}
array_60.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_workspaces_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateWorkspacesInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_63) = &input.workspaces {
let mut array_64 = object.key("Workspaces").start_array();
for item_65 in var_63 {
{
let mut object_66 = array_64.value().start_object();
crate::json_ser::serialize_structure_crate_model_workspace_request(
&mut object_66,
item_65,
)?;
object_66.finish();
}
}
array_64.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_client_branding_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteClientBrandingInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_67) = &input.resource_id {
object.key("ResourceId").string(var_67.as_str());
}
if let Some(var_68) = &input.platforms {
let mut array_69 = object.key("Platforms").start_array();
for item_70 in var_68 {
{
array_69.value().string(item_70.as_str());
}
}
array_69.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_connect_client_add_in_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteConnectClientAddInInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_71) = &input.add_in_id {
object.key("AddInId").string(var_71.as_str());
}
if let Some(var_72) = &input.resource_id {
object.key("ResourceId").string(var_72.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_connection_alias_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteConnectionAliasInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_73) = &input.alias_id {
object.key("AliasId").string(var_73.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_ip_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteIpGroupInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_74) = &input.group_id {
object.key("GroupId").string(var_74.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_tags_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteTagsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_75) = &input.resource_id {
object.key("ResourceId").string(var_75.as_str());
}
if let Some(var_76) = &input.tag_keys {
let mut array_77 = object.key("TagKeys").start_array();
for item_78 in var_76 {
{
array_77.value().string(item_78.as_str());
}
}
array_77.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_workspace_bundle_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteWorkspaceBundleInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_79) = &input.bundle_id {
object.key("BundleId").string(var_79.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_workspace_image_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteWorkspaceImageInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_80) = &input.image_id {
object.key("ImageId").string(var_80.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_deregister_workspace_directory_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeregisterWorkspaceDirectoryInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_81) = &input.directory_id {
object.key("DirectoryId").string(var_81.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_account_modifications_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeAccountModificationsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_82) = &input.next_token {
object.key("NextToken").string(var_82.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_client_branding_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeClientBrandingInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_83) = &input.resource_id {
object.key("ResourceId").string(var_83.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_client_properties_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeClientPropertiesInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_84) = &input.resource_ids {
let mut array_85 = object.key("ResourceIds").start_array();
for item_86 in var_84 {
{
array_85.value().string(item_86.as_str());
}
}
array_85.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_connect_client_add_ins_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeConnectClientAddInsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_87) = &input.resource_id {
object.key("ResourceId").string(var_87.as_str());
}
if let Some(var_88) = &input.next_token {
object.key("NextToken").string(var_88.as_str());
}
if let Some(var_89) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_89).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_connection_aliases_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeConnectionAliasesInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_90) = &input.alias_ids {
let mut array_91 = object.key("AliasIds").start_array();
for item_92 in var_90 {
{
array_91.value().string(item_92.as_str());
}
}
array_91.finish();
}
if let Some(var_93) = &input.resource_id {
object.key("ResourceId").string(var_93.as_str());
}
if let Some(var_94) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_94).into()),
);
}
if let Some(var_95) = &input.next_token {
object.key("NextToken").string(var_95.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_connection_alias_permissions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeConnectionAliasPermissionsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_96) = &input.alias_id {
object.key("AliasId").string(var_96.as_str());
}
if let Some(var_97) = &input.next_token {
object.key("NextToken").string(var_97.as_str());
}
if let Some(var_98) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_98).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_ip_groups_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeIpGroupsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_99) = &input.group_ids {
let mut array_100 = object.key("GroupIds").start_array();
for item_101 in var_99 {
{
array_100.value().string(item_101.as_str());
}
}
array_100.finish();
}
if let Some(var_102) = &input.next_token {
object.key("NextToken").string(var_102.as_str());
}
if let Some(var_103) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_103).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_tags_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeTagsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_104) = &input.resource_id {
object.key("ResourceId").string(var_104.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_workspace_bundles_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeWorkspaceBundlesInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_105) = &input.bundle_ids {
let mut array_106 = object.key("BundleIds").start_array();
for item_107 in var_105 {
{
array_106.value().string(item_107.as_str());
}
}
array_106.finish();
}
if let Some(var_108) = &input.owner {
object.key("Owner").string(var_108.as_str());
}
if let Some(var_109) = &input.next_token {
object.key("NextToken").string(var_109.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_workspace_directories_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeWorkspaceDirectoriesInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_110) = &input.directory_ids {
let mut array_111 = object.key("DirectoryIds").start_array();
for item_112 in var_110 {
{
array_111.value().string(item_112.as_str());
}
}
array_111.finish();
}
if let Some(var_113) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_113).into()),
);
}
if let Some(var_114) = &input.next_token {
object.key("NextToken").string(var_114.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_workspace_image_permissions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeWorkspaceImagePermissionsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_115) = &input.image_id {
object.key("ImageId").string(var_115.as_str());
}
if let Some(var_116) = &input.next_token {
object.key("NextToken").string(var_116.as_str());
}
if let Some(var_117) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_117).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_workspace_images_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeWorkspaceImagesInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_118) = &input.image_ids {
let mut array_119 = object.key("ImageIds").start_array();
for item_120 in var_118 {
{
array_119.value().string(item_120.as_str());
}
}
array_119.finish();
}
if let Some(var_121) = &input.image_type {
object.key("ImageType").string(var_121.as_str());
}
if let Some(var_122) = &input.next_token {
object.key("NextToken").string(var_122.as_str());
}
if let Some(var_123) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_123).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_workspaces_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeWorkspacesInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_124) = &input.workspace_ids {
let mut array_125 = object.key("WorkspaceIds").start_array();
for item_126 in var_124 {
{
array_125.value().string(item_126.as_str());
}
}
array_125.finish();
}
if let Some(var_127) = &input.directory_id {
object.key("DirectoryId").string(var_127.as_str());
}
if let Some(var_128) = &input.user_name {
object.key("UserName").string(var_128.as_str());
}
if let Some(var_129) = &input.bundle_id {
object.key("BundleId").string(var_129.as_str());
}
if let Some(var_130) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_130).into()),
);
}
if let Some(var_131) = &input.next_token {
object.key("NextToken").string(var_131.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_workspaces_connection_status_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeWorkspacesConnectionStatusInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_132) = &input.workspace_ids {
let mut array_133 = object.key("WorkspaceIds").start_array();
for item_134 in var_132 {
{
array_133.value().string(item_134.as_str());
}
}
array_133.finish();
}
if let Some(var_135) = &input.next_token {
object.key("NextToken").string(var_135.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_workspace_snapshots_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeWorkspaceSnapshotsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_136) = &input.workspace_id {
object.key("WorkspaceId").string(var_136.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_disassociate_connection_alias_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DisassociateConnectionAliasInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_137) = &input.alias_id {
object.key("AliasId").string(var_137.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_disassociate_ip_groups_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DisassociateIpGroupsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_138) = &input.directory_id {
object.key("DirectoryId").string(var_138.as_str());
}
if let Some(var_139) = &input.group_ids {
let mut array_140 = object.key("GroupIds").start_array();
for item_141 in var_139 {
{
array_140.value().string(item_141.as_str());
}
}
array_140.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_import_client_branding_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ImportClientBrandingInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_142) = &input.resource_id {
object.key("ResourceId").string(var_142.as_str());
}
if let Some(var_143) = &input.device_type_windows {
let mut object_144 = object.key("DeviceTypeWindows").start_object();
crate::json_ser::serialize_structure_crate_model_default_import_client_branding_attributes(
&mut object_144,
var_143,
)?;
object_144.finish();
}
if let Some(var_145) = &input.device_type_osx {
let mut object_146 = object.key("DeviceTypeOsx").start_object();
crate::json_ser::serialize_structure_crate_model_default_import_client_branding_attributes(
&mut object_146,
var_145,
)?;
object_146.finish();
}
if let Some(var_147) = &input.device_type_android {
let mut object_148 = object.key("DeviceTypeAndroid").start_object();
crate::json_ser::serialize_structure_crate_model_default_import_client_branding_attributes(
&mut object_148,
var_147,
)?;
object_148.finish();
}
if let Some(var_149) = &input.device_type_ios {
let mut object_150 = object.key("DeviceTypeIos").start_object();
crate::json_ser::serialize_structure_crate_model_ios_import_client_branding_attributes(
&mut object_150,
var_149,
)?;
object_150.finish();
}
if let Some(var_151) = &input.device_type_linux {
let mut object_152 = object.key("DeviceTypeLinux").start_object();
crate::json_ser::serialize_structure_crate_model_default_import_client_branding_attributes(
&mut object_152,
var_151,
)?;
object_152.finish();
}
if let Some(var_153) = &input.device_type_web {
let mut object_154 = object.key("DeviceTypeWeb").start_object();
crate::json_ser::serialize_structure_crate_model_default_import_client_branding_attributes(
&mut object_154,
var_153,
)?;
object_154.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_import_workspace_image_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ImportWorkspaceImageInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_155) = &input.ec2_image_id {
object.key("Ec2ImageId").string(var_155.as_str());
}
if let Some(var_156) = &input.ingestion_process {
object.key("IngestionProcess").string(var_156.as_str());
}
if let Some(var_157) = &input.image_name {
object.key("ImageName").string(var_157.as_str());
}
if let Some(var_158) = &input.image_description {
object.key("ImageDescription").string(var_158.as_str());
}
if let Some(var_159) = &input.tags {
let mut array_160 = object.key("Tags").start_array();
for item_161 in var_159 {
{
let mut object_162 = array_160.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_162, item_161)?;
object_162.finish();
}
}
array_160.finish();
}
if let Some(var_163) = &input.applications {
let mut array_164 = object.key("Applications").start_array();
for item_165 in var_163 {
{
array_164.value().string(item_165.as_str());
}
}
array_164.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_list_available_management_cidr_ranges_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListAvailableManagementCidrRangesInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_166) = &input.management_cidr_range_constraint {
object
.key("ManagementCidrRangeConstraint")
.string(var_166.as_str());
}
if let Some(var_167) = &input.max_results {
object.key("MaxResults").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_167).into()),
);
}
if let Some(var_168) = &input.next_token {
object.key("NextToken").string(var_168.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_migrate_workspace_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::MigrateWorkspaceInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_169) = &input.source_workspace_id {
object.key("SourceWorkspaceId").string(var_169.as_str());
}
if let Some(var_170) = &input.bundle_id {
object.key("BundleId").string(var_170.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_modify_account_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ModifyAccountInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_171) = &input.dedicated_tenancy_support {
object
.key("DedicatedTenancySupport")
.string(var_171.as_str());
}
if let Some(var_172) = &input.dedicated_tenancy_management_cidr_range {
object
.key("DedicatedTenancyManagementCidrRange")
.string(var_172.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_modify_client_properties_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ModifyClientPropertiesInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_173) = &input.resource_id {
object.key("ResourceId").string(var_173.as_str());
}
if let Some(var_174) = &input.client_properties {
let mut object_175 = object.key("ClientProperties").start_object();
crate::json_ser::serialize_structure_crate_model_client_properties(
&mut object_175,
var_174,
)?;
object_175.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_modify_selfservice_permissions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ModifySelfservicePermissionsInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_176) = &input.resource_id {
object.key("ResourceId").string(var_176.as_str());
}
if let Some(var_177) = &input.selfservice_permissions {
let mut object_178 = object.key("SelfservicePermissions").start_object();
crate::json_ser::serialize_structure_crate_model_selfservice_permissions(
&mut object_178,
var_177,
)?;
object_178.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_modify_workspace_access_properties_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ModifyWorkspaceAccessPropertiesInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_179) = &input.resource_id {
object.key("ResourceId").string(var_179.as_str());
}
if let Some(var_180) = &input.workspace_access_properties {
let mut object_181 = object.key("WorkspaceAccessProperties").start_object();
crate::json_ser::serialize_structure_crate_model_workspace_access_properties(
&mut object_181,
var_180,
)?;
object_181.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_modify_workspace_creation_properties_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ModifyWorkspaceCreationPropertiesInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_182) = &input.resource_id {
object.key("ResourceId").string(var_182.as_str());
}
if let Some(var_183) = &input.workspace_creation_properties {
let mut object_184 = object.key("WorkspaceCreationProperties").start_object();
crate::json_ser::serialize_structure_crate_model_workspace_creation_properties(
&mut object_184,
var_183,
)?;
object_184.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_modify_workspace_properties_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ModifyWorkspacePropertiesInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_185) = &input.workspace_id {
object.key("WorkspaceId").string(var_185.as_str());
}
if let Some(var_186) = &input.workspace_properties {
let mut object_187 = object.key("WorkspaceProperties").start_object();
crate::json_ser::serialize_structure_crate_model_workspace_properties(
&mut object_187,
var_186,
)?;
object_187.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_modify_workspace_state_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ModifyWorkspaceStateInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_188) = &input.workspace_id {
object.key("WorkspaceId").string(var_188.as_str());
}
if let Some(var_189) = &input.workspace_state {
object.key("WorkspaceState").string(var_189.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_reboot_workspaces_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RebootWorkspacesInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_190) = &input.reboot_workspace_requests {
let mut array_191 = object.key("RebootWorkspaceRequests").start_array();
for item_192 in var_190 {
{
let mut object_193 = array_191.value().start_object();
crate::json_ser::serialize_structure_crate_model_reboot_request(
&mut object_193,
item_192,
)?;
object_193.finish();
}
}
array_191.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_rebuild_workspaces_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RebuildWorkspacesInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_194) = &input.rebuild_workspace_requests {
let mut array_195 = object.key("RebuildWorkspaceRequests").start_array();
for item_196 in var_194 {
{
let mut object_197 = array_195.value().start_object();
crate::json_ser::serialize_structure_crate_model_rebuild_request(
&mut object_197,
item_196,
)?;
object_197.finish();
}
}
array_195.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_register_workspace_directory_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RegisterWorkspaceDirectoryInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_198) = &input.directory_id {
object.key("DirectoryId").string(var_198.as_str());
}
if let Some(var_199) = &input.subnet_ids {
let mut array_200 = object.key("SubnetIds").start_array();
for item_201 in var_199 {
{
array_200.value().string(item_201.as_str());
}
}
array_200.finish();
}
if let Some(var_202) = &input.enable_work_docs {
object.key("EnableWorkDocs").boolean(*var_202);
}
if let Some(var_203) = &input.enable_self_service {
object.key("EnableSelfService").boolean(*var_203);
}
if let Some(var_204) = &input.tenancy {
object.key("Tenancy").string(var_204.as_str());
}
if let Some(var_205) = &input.tags {
let mut array_206 = object.key("Tags").start_array();
for item_207 in var_205 {
{
let mut object_208 = array_206.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_208, item_207)?;
object_208.finish();
}
}
array_206.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_restore_workspace_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RestoreWorkspaceInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_209) = &input.workspace_id {
object.key("WorkspaceId").string(var_209.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_revoke_ip_rules_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RevokeIpRulesInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_210) = &input.group_id {
object.key("GroupId").string(var_210.as_str());
}
if let Some(var_211) = &input.user_rules {
let mut array_212 = object.key("UserRules").start_array();
for item_213 in var_211 {
{
array_212.value().string(item_213.as_str());
}
}
array_212.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_start_workspaces_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartWorkspacesInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_214) = &input.start_workspace_requests {
let mut array_215 = object.key("StartWorkspaceRequests").start_array();
for item_216 in var_214 {
{
let mut object_217 = array_215.value().start_object();
crate::json_ser::serialize_structure_crate_model_start_request(
&mut object_217,
item_216,
)?;
object_217.finish();
}
}
array_215.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_stop_workspaces_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StopWorkspacesInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_218) = &input.stop_workspace_requests {
let mut array_219 = object.key("StopWorkspaceRequests").start_array();
for item_220 in var_218 {
{
let mut object_221 = array_219.value().start_object();
crate::json_ser::serialize_structure_crate_model_stop_request(
&mut object_221,
item_220,
)?;
object_221.finish();
}
}
array_219.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_terminate_workspaces_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::TerminateWorkspacesInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_222) = &input.terminate_workspace_requests {
let mut array_223 = object.key("TerminateWorkspaceRequests").start_array();
for item_224 in var_222 {
{
let mut object_225 = array_223.value().start_object();
crate::json_ser::serialize_structure_crate_model_terminate_request(
&mut object_225,
item_224,
)?;
object_225.finish();
}
}
array_223.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_connect_client_add_in_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateConnectClientAddInInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_226) = &input.add_in_id {
object.key("AddInId").string(var_226.as_str());
}
if let Some(var_227) = &input.resource_id {
object.key("ResourceId").string(var_227.as_str());
}
if let Some(var_228) = &input.name {
object.key("Name").string(var_228.as_str());
}
if let Some(var_229) = &input.url {
object.key("URL").string(var_229.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_connection_alias_permission_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateConnectionAliasPermissionInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_230) = &input.alias_id {
object.key("AliasId").string(var_230.as_str());
}
if let Some(var_231) = &input.connection_alias_permission {
let mut object_232 = object.key("ConnectionAliasPermission").start_object();
crate::json_ser::serialize_structure_crate_model_connection_alias_permission(
&mut object_232,
var_231,
)?;
object_232.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_rules_of_ip_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateRulesOfIpGroupInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_233) = &input.group_id {
object.key("GroupId").string(var_233.as_str());
}
if let Some(var_234) = &input.user_rules {
let mut array_235 = object.key("UserRules").start_array();
for item_236 in var_234 {
{
let mut object_237 = array_235.value().start_object();
crate::json_ser::serialize_structure_crate_model_ip_rule_item(
&mut object_237,
item_236,
)?;
object_237.finish();
}
}
array_235.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_workspace_bundle_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateWorkspaceBundleInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_238) = &input.bundle_id {
object.key("BundleId").string(var_238.as_str());
}
if let Some(var_239) = &input.image_id {
object.key("ImageId").string(var_239.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_workspace_image_permission_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateWorkspaceImagePermissionInput,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_240) = &input.image_id {
object.key("ImageId").string(var_240.as_str());
}
if let Some(var_241) = &input.allow_copy_image {
object.key("AllowCopyImage").boolean(*var_241);
}
if let Some(var_242) = &input.shared_account_id {
object.key("SharedAccountId").string(var_242.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_ip_rule_item(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::IpRuleItem,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_243) = &input.ip_rule {
object.key("ipRule").string(var_243.as_str());
}
if let Some(var_244) = &input.rule_desc {
object.key("ruleDesc").string(var_244.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_tag(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Tag,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_245) = &input.key {
object.key("Key").string(var_245.as_str());
}
if let Some(var_246) = &input.value {
object.key("Value").string(var_246.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_compute_type(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ComputeType,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_247) = &input.name {
object.key("Name").string(var_247.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_user_storage(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::UserStorage,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_248) = &input.capacity {
object.key("Capacity").string(var_248.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_root_storage(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RootStorage,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_249) = &input.capacity {
object.key("Capacity").string(var_249.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_workspace_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::WorkspaceRequest,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_250) = &input.directory_id {
object.key("DirectoryId").string(var_250.as_str());
}
if let Some(var_251) = &input.user_name {
object.key("UserName").string(var_251.as_str());
}
if let Some(var_252) = &input.bundle_id {
object.key("BundleId").string(var_252.as_str());
}
if let Some(var_253) = &input.volume_encryption_key {
object.key("VolumeEncryptionKey").string(var_253.as_str());
}
if let Some(var_254) = &input.user_volume_encryption_enabled {
object.key("UserVolumeEncryptionEnabled").boolean(*var_254);
}
if let Some(var_255) = &input.root_volume_encryption_enabled {
object.key("RootVolumeEncryptionEnabled").boolean(*var_255);
}
if let Some(var_256) = &input.workspace_properties {
let mut object_257 = object.key("WorkspaceProperties").start_object();
crate::json_ser::serialize_structure_crate_model_workspace_properties(
&mut object_257,
var_256,
)?;
object_257.finish();
}
if let Some(var_258) = &input.tags {
let mut array_259 = object.key("Tags").start_array();
for item_260 in var_258 {
{
let mut object_261 = array_259.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_261, item_260)?;
object_261.finish();
}
}
array_259.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_default_import_client_branding_attributes(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DefaultImportClientBrandingAttributes,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_262) = &input.logo {
object
.key("Logo")
.string_unchecked(&aws_smithy_types::base64::encode(var_262));
}
if let Some(var_263) = &input.support_email {
object.key("SupportEmail").string(var_263.as_str());
}
if let Some(var_264) = &input.support_link {
object.key("SupportLink").string(var_264.as_str());
}
if let Some(var_265) = &input.forgot_password_link {
object.key("ForgotPasswordLink").string(var_265.as_str());
}
if let Some(var_266) = &input.login_message {
let mut object_267 = object.key("LoginMessage").start_object();
for (key_268, value_269) in var_266 {
{
object_267.key(key_268).string(value_269.as_str());
}
}
object_267.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_ios_import_client_branding_attributes(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::IosImportClientBrandingAttributes,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_270) = &input.logo {
object
.key("Logo")
.string_unchecked(&aws_smithy_types::base64::encode(var_270));
}
if let Some(var_271) = &input.logo2x {
object
.key("Logo2x")
.string_unchecked(&aws_smithy_types::base64::encode(var_271));
}
if let Some(var_272) = &input.logo3x {
object
.key("Logo3x")
.string_unchecked(&aws_smithy_types::base64::encode(var_272));
}
if let Some(var_273) = &input.support_email {
object.key("SupportEmail").string(var_273.as_str());
}
if let Some(var_274) = &input.support_link {
object.key("SupportLink").string(var_274.as_str());
}
if let Some(var_275) = &input.forgot_password_link {
object.key("ForgotPasswordLink").string(var_275.as_str());
}
if let Some(var_276) = &input.login_message {
let mut object_277 = object.key("LoginMessage").start_object();
for (key_278, value_279) in var_276 {
{
object_277.key(key_278).string(value_279.as_str());
}
}
object_277.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_client_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ClientProperties,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_280) = &input.reconnect_enabled {
object.key("ReconnectEnabled").string(var_280.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_selfservice_permissions(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::SelfservicePermissions,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_281) = &input.restart_workspace {
object.key("RestartWorkspace").string(var_281.as_str());
}
if let Some(var_282) = &input.increase_volume_size {
object.key("IncreaseVolumeSize").string(var_282.as_str());
}
if let Some(var_283) = &input.change_compute_type {
object.key("ChangeComputeType").string(var_283.as_str());
}
if let Some(var_284) = &input.switch_running_mode {
object.key("SwitchRunningMode").string(var_284.as_str());
}
if let Some(var_285) = &input.rebuild_workspace {
object.key("RebuildWorkspace").string(var_285.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_workspace_access_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::WorkspaceAccessProperties,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_286) = &input.device_type_windows {
object.key("DeviceTypeWindows").string(var_286.as_str());
}
if let Some(var_287) = &input.device_type_osx {
object.key("DeviceTypeOsx").string(var_287.as_str());
}
if let Some(var_288) = &input.device_type_web {
object.key("DeviceTypeWeb").string(var_288.as_str());
}
if let Some(var_289) = &input.device_type_ios {
object.key("DeviceTypeIos").string(var_289.as_str());
}
if let Some(var_290) = &input.device_type_android {
object.key("DeviceTypeAndroid").string(var_290.as_str());
}
if let Some(var_291) = &input.device_type_chrome_os {
object.key("DeviceTypeChromeOs").string(var_291.as_str());
}
if let Some(var_292) = &input.device_type_zero_client {
object.key("DeviceTypeZeroClient").string(var_292.as_str());
}
if let Some(var_293) = &input.device_type_linux {
object.key("DeviceTypeLinux").string(var_293.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_workspace_creation_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::WorkspaceCreationProperties,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_294) = &input.enable_work_docs {
object.key("EnableWorkDocs").boolean(*var_294);
}
if let Some(var_295) = &input.enable_internet_access {
object.key("EnableInternetAccess").boolean(*var_295);
}
if let Some(var_296) = &input.default_ou {
object.key("DefaultOu").string(var_296.as_str());
}
if let Some(var_297) = &input.custom_security_group_id {
object.key("CustomSecurityGroupId").string(var_297.as_str());
}
if let Some(var_298) = &input.user_enabled_as_local_administrator {
object
.key("UserEnabledAsLocalAdministrator")
.boolean(*var_298);
}
if let Some(var_299) = &input.enable_maintenance_mode {
object.key("EnableMaintenanceMode").boolean(*var_299);
}
Ok(())
}
pub fn serialize_structure_crate_model_workspace_properties(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::WorkspaceProperties,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_300) = &input.running_mode {
object.key("RunningMode").string(var_300.as_str());
}
if let Some(var_301) = &input.running_mode_auto_stop_timeout_in_minutes {
object.key("RunningModeAutoStopTimeoutInMinutes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_301).into()),
);
}
if let Some(var_302) = &input.root_volume_size_gib {
object.key("RootVolumeSizeGib").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_302).into()),
);
}
if let Some(var_303) = &input.user_volume_size_gib {
object.key("UserVolumeSizeGib").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_303).into()),
);
}
if let Some(var_304) = &input.compute_type_name {
object.key("ComputeTypeName").string(var_304.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_reboot_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RebootRequest,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_305) = &input.workspace_id {
object.key("WorkspaceId").string(var_305.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_rebuild_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RebuildRequest,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_306) = &input.workspace_id {
object.key("WorkspaceId").string(var_306.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_start_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StartRequest,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_307) = &input.workspace_id {
object.key("WorkspaceId").string(var_307.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_stop_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::StopRequest,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_308) = &input.workspace_id {
object.key("WorkspaceId").string(var_308.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_terminate_request(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TerminateRequest,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_309) = &input.workspace_id {
object.key("WorkspaceId").string(var_309.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_connection_alias_permission(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ConnectionAliasPermission,
) -> Result<(), aws_smithy_http::operation::SerializationError> {
if let Some(var_310) = &input.shared_account_id {
object.key("SharedAccountId").string(var_310.as_str());
}
if let Some(var_311) = &input.allow_association {
object.key("AllowAssociation").boolean(*var_311);
}
Ok(())
}