pub fn serialize_structure_crate_input_accept_match_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::AcceptMatchInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_1) = &input.ticket_id {
object.key("TicketId").string(var_1.as_str());
}
if let Some(var_2) = &input.player_ids {
let mut array_3 = object.key("PlayerIds").start_array();
for item_4 in var_2 {
{
array_3.value().string(item_4.as_str());
}
}
array_3.finish();
}
if let Some(var_5) = &input.acceptance_type {
object.key("AcceptanceType").string(var_5.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_claim_game_server_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ClaimGameServerInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_6) = &input.game_server_group_name {
object.key("GameServerGroupName").string(var_6.as_str());
}
if let Some(var_7) = &input.game_server_id {
object.key("GameServerId").string(var_7.as_str());
}
if let Some(var_8) = &input.game_server_data {
object.key("GameServerData").string(var_8.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_alias_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateAliasInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_9) = &input.name {
object.key("Name").string(var_9.as_str());
}
if let Some(var_10) = &input.description {
object.key("Description").string(var_10.as_str());
}
if let Some(var_11) = &input.routing_strategy {
#[allow(unused_mut)]
let mut object_12 = object.key("RoutingStrategy").start_object();
crate::json_ser::serialize_structure_crate_model_routing_strategy(&mut object_12, var_11)?;
object_12.finish();
}
if let Some(var_13) = &input.tags {
let mut array_14 = object.key("Tags").start_array();
for item_15 in var_13 {
{
#[allow(unused_mut)]
let mut object_16 = array_14.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_16, item_15)?;
object_16.finish();
}
}
array_14.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_build_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateBuildInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_17) = &input.name {
object.key("Name").string(var_17.as_str());
}
if let Some(var_18) = &input.version {
object.key("Version").string(var_18.as_str());
}
if let Some(var_19) = &input.storage_location {
#[allow(unused_mut)]
let mut object_20 = object.key("StorageLocation").start_object();
crate::json_ser::serialize_structure_crate_model_s3_location(&mut object_20, var_19)?;
object_20.finish();
}
if let Some(var_21) = &input.operating_system {
object.key("OperatingSystem").string(var_21.as_str());
}
if let Some(var_22) = &input.tags {
let mut array_23 = object.key("Tags").start_array();
for item_24 in var_22 {
{
#[allow(unused_mut)]
let mut object_25 = array_23.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_25, item_24)?;
object_25.finish();
}
}
array_23.finish();
}
if let Some(var_26) = &input.server_sdk_version {
object.key("ServerSdkVersion").string(var_26.as_str());
}
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_27) = &input.name {
object.key("Name").string(var_27.as_str());
}
if let Some(var_28) = &input.description {
object.key("Description").string(var_28.as_str());
}
if let Some(var_29) = &input.build_id {
object.key("BuildId").string(var_29.as_str());
}
if let Some(var_30) = &input.script_id {
object.key("ScriptId").string(var_30.as_str());
}
if let Some(var_31) = &input.server_launch_path {
object.key("ServerLaunchPath").string(var_31.as_str());
}
if let Some(var_32) = &input.server_launch_parameters {
object.key("ServerLaunchParameters").string(var_32.as_str());
}
if let Some(var_33) = &input.log_paths {
let mut array_34 = object.key("LogPaths").start_array();
for item_35 in var_33 {
{
array_34.value().string(item_35.as_str());
}
}
array_34.finish();
}
if let Some(var_36) = &input.ec2_instance_type {
object.key("EC2InstanceType").string(var_36.as_str());
}
if let Some(var_37) = &input.ec2_inbound_permissions {
let mut array_38 = object.key("EC2InboundPermissions").start_array();
for item_39 in var_37 {
{
#[allow(unused_mut)]
let mut object_40 = array_38.value().start_object();
crate::json_ser::serialize_structure_crate_model_ip_permission(
&mut object_40,
item_39,
)?;
object_40.finish();
}
}
array_38.finish();
}
if let Some(var_41) = &input.new_game_session_protection_policy {
object
.key("NewGameSessionProtectionPolicy")
.string(var_41.as_str());
}
if let Some(var_42) = &input.runtime_configuration {
#[allow(unused_mut)]
let mut object_43 = object.key("RuntimeConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_runtime_configuration(
&mut object_43,
var_42,
)?;
object_43.finish();
}
if let Some(var_44) = &input.resource_creation_limit_policy {
#[allow(unused_mut)]
let mut object_45 = object.key("ResourceCreationLimitPolicy").start_object();
crate::json_ser::serialize_structure_crate_model_resource_creation_limit_policy(
&mut object_45,
var_44,
)?;
object_45.finish();
}
if let Some(var_46) = &input.metric_groups {
let mut array_47 = object.key("MetricGroups").start_array();
for item_48 in var_46 {
{
array_47.value().string(item_48.as_str());
}
}
array_47.finish();
}
if let Some(var_49) = &input.peer_vpc_aws_account_id {
object.key("PeerVpcAwsAccountId").string(var_49.as_str());
}
if let Some(var_50) = &input.peer_vpc_id {
object.key("PeerVpcId").string(var_50.as_str());
}
if let Some(var_51) = &input.fleet_type {
object.key("FleetType").string(var_51.as_str());
}
if let Some(var_52) = &input.instance_role_arn {
object.key("InstanceRoleArn").string(var_52.as_str());
}
if let Some(var_53) = &input.certificate_configuration {
#[allow(unused_mut)]
let mut object_54 = object.key("CertificateConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_certificate_configuration(
&mut object_54,
var_53,
)?;
object_54.finish();
}
if let Some(var_55) = &input.locations {
let mut array_56 = object.key("Locations").start_array();
for item_57 in var_55 {
{
#[allow(unused_mut)]
let mut object_58 = array_56.value().start_object();
crate::json_ser::serialize_structure_crate_model_location_configuration(
&mut object_58,
item_57,
)?;
object_58.finish();
}
}
array_56.finish();
}
if let Some(var_59) = &input.tags {
let mut array_60 = object.key("Tags").start_array();
for item_61 in var_59 {
{
#[allow(unused_mut)]
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();
}
if let Some(var_63) = &input.compute_type {
object.key("ComputeType").string(var_63.as_str());
}
if let Some(var_64) = &input.anywhere_configuration {
#[allow(unused_mut)]
let mut object_65 = object.key("AnywhereConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_anywhere_configuration(
&mut object_65,
var_64,
)?;
object_65.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_fleet_locations_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateFleetLocationsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_66) = &input.fleet_id {
object.key("FleetId").string(var_66.as_str());
}
if let Some(var_67) = &input.locations {
let mut array_68 = object.key("Locations").start_array();
for item_69 in var_67 {
{
#[allow(unused_mut)]
let mut object_70 = array_68.value().start_object();
crate::json_ser::serialize_structure_crate_model_location_configuration(
&mut object_70,
item_69,
)?;
object_70.finish();
}
}
array_68.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_game_server_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateGameServerGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_71) = &input.game_server_group_name {
object.key("GameServerGroupName").string(var_71.as_str());
}
if let Some(var_72) = &input.role_arn {
object.key("RoleArn").string(var_72.as_str());
}
if let Some(var_73) = &input.min_size {
object.key("MinSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_73).into()),
);
}
if let Some(var_74) = &input.max_size {
object.key("MaxSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_74).into()),
);
}
if let Some(var_75) = &input.launch_template {
#[allow(unused_mut)]
let mut object_76 = object.key("LaunchTemplate").start_object();
crate::json_ser::serialize_structure_crate_model_launch_template_specification(
&mut object_76,
var_75,
)?;
object_76.finish();
}
if let Some(var_77) = &input.instance_definitions {
let mut array_78 = object.key("InstanceDefinitions").start_array();
for item_79 in var_77 {
{
#[allow(unused_mut)]
let mut object_80 = array_78.value().start_object();
crate::json_ser::serialize_structure_crate_model_instance_definition(
&mut object_80,
item_79,
)?;
object_80.finish();
}
}
array_78.finish();
}
if let Some(var_81) = &input.auto_scaling_policy {
#[allow(unused_mut)]
let mut object_82 = object.key("AutoScalingPolicy").start_object();
crate::json_ser::serialize_structure_crate_model_game_server_group_auto_scaling_policy(
&mut object_82,
var_81,
)?;
object_82.finish();
}
if let Some(var_83) = &input.balancing_strategy {
object.key("BalancingStrategy").string(var_83.as_str());
}
if let Some(var_84) = &input.game_server_protection_policy {
object
.key("GameServerProtectionPolicy")
.string(var_84.as_str());
}
if let Some(var_85) = &input.vpc_subnets {
let mut array_86 = object.key("VpcSubnets").start_array();
for item_87 in var_85 {
{
array_86.value().string(item_87.as_str());
}
}
array_86.finish();
}
if let Some(var_88) = &input.tags {
let mut array_89 = object.key("Tags").start_array();
for item_90 in var_88 {
{
#[allow(unused_mut)]
let mut object_91 = array_89.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_91, item_90)?;
object_91.finish();
}
}
array_89.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_game_session_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateGameSessionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_92) = &input.fleet_id {
object.key("FleetId").string(var_92.as_str());
}
if let Some(var_93) = &input.alias_id {
object.key("AliasId").string(var_93.as_str());
}
if let Some(var_94) = &input.maximum_player_session_count {
object.key("MaximumPlayerSessionCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_94).into()),
);
}
if let Some(var_95) = &input.name {
object.key("Name").string(var_95.as_str());
}
if let Some(var_96) = &input.game_properties {
let mut array_97 = object.key("GameProperties").start_array();
for item_98 in var_96 {
{
#[allow(unused_mut)]
let mut object_99 = array_97.value().start_object();
crate::json_ser::serialize_structure_crate_model_game_property(
&mut object_99,
item_98,
)?;
object_99.finish();
}
}
array_97.finish();
}
if let Some(var_100) = &input.creator_id {
object.key("CreatorId").string(var_100.as_str());
}
if let Some(var_101) = &input.game_session_id {
object.key("GameSessionId").string(var_101.as_str());
}
if let Some(var_102) = &input.idempotency_token {
object.key("IdempotencyToken").string(var_102.as_str());
}
if let Some(var_103) = &input.game_session_data {
object.key("GameSessionData").string(var_103.as_str());
}
if let Some(var_104) = &input.location {
object.key("Location").string(var_104.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_game_session_queue_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateGameSessionQueueInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_105) = &input.name {
object.key("Name").string(var_105.as_str());
}
if let Some(var_106) = &input.timeout_in_seconds {
object.key("TimeoutInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_106).into()),
);
}
if let Some(var_107) = &input.player_latency_policies {
let mut array_108 = object.key("PlayerLatencyPolicies").start_array();
for item_109 in var_107 {
{
#[allow(unused_mut)]
let mut object_110 = array_108.value().start_object();
crate::json_ser::serialize_structure_crate_model_player_latency_policy(
&mut object_110,
item_109,
)?;
object_110.finish();
}
}
array_108.finish();
}
if let Some(var_111) = &input.destinations {
let mut array_112 = object.key("Destinations").start_array();
for item_113 in var_111 {
{
#[allow(unused_mut)]
let mut object_114 = array_112.value().start_object();
crate::json_ser::serialize_structure_crate_model_game_session_queue_destination(
&mut object_114,
item_113,
)?;
object_114.finish();
}
}
array_112.finish();
}
if let Some(var_115) = &input.filter_configuration {
#[allow(unused_mut)]
let mut object_116 = object.key("FilterConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_filter_configuration(
&mut object_116,
var_115,
)?;
object_116.finish();
}
if let Some(var_117) = &input.priority_configuration {
#[allow(unused_mut)]
let mut object_118 = object.key("PriorityConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_priority_configuration(
&mut object_118,
var_117,
)?;
object_118.finish();
}
if let Some(var_119) = &input.custom_event_data {
object.key("CustomEventData").string(var_119.as_str());
}
if let Some(var_120) = &input.notification_target {
object.key("NotificationTarget").string(var_120.as_str());
}
if let Some(var_121) = &input.tags {
let mut array_122 = object.key("Tags").start_array();
for item_123 in var_121 {
{
#[allow(unused_mut)]
let mut object_124 = array_122.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_124, item_123)?;
object_124.finish();
}
}
array_122.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_location_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateLocationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_125) = &input.location_name {
object.key("LocationName").string(var_125.as_str());
}
if let Some(var_126) = &input.tags {
let mut array_127 = object.key("Tags").start_array();
for item_128 in var_126 {
{
#[allow(unused_mut)]
let mut object_129 = array_127.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_129, item_128)?;
object_129.finish();
}
}
array_127.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_matchmaking_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateMatchmakingConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_130) = &input.name {
object.key("Name").string(var_130.as_str());
}
if let Some(var_131) = &input.description {
object.key("Description").string(var_131.as_str());
}
if let Some(var_132) = &input.game_session_queue_arns {
let mut array_133 = object.key("GameSessionQueueArns").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.request_timeout_seconds {
object.key("RequestTimeoutSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_135).into()),
);
}
if let Some(var_136) = &input.acceptance_timeout_seconds {
object.key("AcceptanceTimeoutSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_136).into()),
);
}
if let Some(var_137) = &input.acceptance_required {
object.key("AcceptanceRequired").boolean(*var_137);
}
if let Some(var_138) = &input.rule_set_name {
object.key("RuleSetName").string(var_138.as_str());
}
if let Some(var_139) = &input.notification_target {
object.key("NotificationTarget").string(var_139.as_str());
}
if let Some(var_140) = &input.additional_player_count {
object.key("AdditionalPlayerCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_140).into()),
);
}
if let Some(var_141) = &input.custom_event_data {
object.key("CustomEventData").string(var_141.as_str());
}
if let Some(var_142) = &input.game_properties {
let mut array_143 = object.key("GameProperties").start_array();
for item_144 in var_142 {
{
#[allow(unused_mut)]
let mut object_145 = array_143.value().start_object();
crate::json_ser::serialize_structure_crate_model_game_property(
&mut object_145,
item_144,
)?;
object_145.finish();
}
}
array_143.finish();
}
if let Some(var_146) = &input.game_session_data {
object.key("GameSessionData").string(var_146.as_str());
}
if let Some(var_147) = &input.backfill_mode {
object.key("BackfillMode").string(var_147.as_str());
}
if let Some(var_148) = &input.flex_match_mode {
object.key("FlexMatchMode").string(var_148.as_str());
}
if let Some(var_149) = &input.tags {
let mut array_150 = object.key("Tags").start_array();
for item_151 in var_149 {
{
#[allow(unused_mut)]
let mut object_152 = array_150.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_152, item_151)?;
object_152.finish();
}
}
array_150.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_matchmaking_rule_set_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateMatchmakingRuleSetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_153) = &input.name {
object.key("Name").string(var_153.as_str());
}
if let Some(var_154) = &input.rule_set_body {
object.key("RuleSetBody").string(var_154.as_str());
}
if let Some(var_155) = &input.tags {
let mut array_156 = object.key("Tags").start_array();
for item_157 in var_155 {
{
#[allow(unused_mut)]
let mut object_158 = array_156.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_158, item_157)?;
object_158.finish();
}
}
array_156.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_player_session_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreatePlayerSessionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_159) = &input.game_session_id {
object.key("GameSessionId").string(var_159.as_str());
}
if let Some(var_160) = &input.player_id {
object.key("PlayerId").string(var_160.as_str());
}
if let Some(var_161) = &input.player_data {
object.key("PlayerData").string(var_161.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_player_sessions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreatePlayerSessionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_162) = &input.game_session_id {
object.key("GameSessionId").string(var_162.as_str());
}
if let Some(var_163) = &input.player_ids {
let mut array_164 = object.key("PlayerIds").start_array();
for item_165 in var_163 {
{
array_164.value().string(item_165.as_str());
}
}
array_164.finish();
}
if let Some(var_166) = &input.player_data_map {
#[allow(unused_mut)]
let mut object_167 = object.key("PlayerDataMap").start_object();
for (key_168, value_169) in var_166 {
{
object_167.key(key_168.as_str()).string(value_169.as_str());
}
}
object_167.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_script_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateScriptInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_170) = &input.name {
object.key("Name").string(var_170.as_str());
}
if let Some(var_171) = &input.version {
object.key("Version").string(var_171.as_str());
}
if let Some(var_172) = &input.storage_location {
#[allow(unused_mut)]
let mut object_173 = object.key("StorageLocation").start_object();
crate::json_ser::serialize_structure_crate_model_s3_location(&mut object_173, var_172)?;
object_173.finish();
}
if let Some(var_174) = &input.zip_file {
object
.key("ZipFile")
.string_unchecked(&aws_smithy_types::base64::encode(var_174));
}
if let Some(var_175) = &input.tags {
let mut array_176 = object.key("Tags").start_array();
for item_177 in var_175 {
{
#[allow(unused_mut)]
let mut object_178 = array_176.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_178, item_177)?;
object_178.finish();
}
}
array_176.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_create_vpc_peering_authorization_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateVpcPeeringAuthorizationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_179) = &input.game_lift_aws_account_id {
object.key("GameLiftAwsAccountId").string(var_179.as_str());
}
if let Some(var_180) = &input.peer_vpc_id {
object.key("PeerVpcId").string(var_180.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_create_vpc_peering_connection_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::CreateVpcPeeringConnectionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_181) = &input.fleet_id {
object.key("FleetId").string(var_181.as_str());
}
if let Some(var_182) = &input.peer_vpc_aws_account_id {
object.key("PeerVpcAwsAccountId").string(var_182.as_str());
}
if let Some(var_183) = &input.peer_vpc_id {
object.key("PeerVpcId").string(var_183.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_alias_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteAliasInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_184) = &input.alias_id {
object.key("AliasId").string(var_184.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_build_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteBuildInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_185) = &input.build_id {
object.key("BuildId").string(var_185.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_186) = &input.fleet_id {
object.key("FleetId").string(var_186.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_fleet_locations_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteFleetLocationsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_187) = &input.fleet_id {
object.key("FleetId").string(var_187.as_str());
}
if let Some(var_188) = &input.locations {
let mut array_189 = object.key("Locations").start_array();
for item_190 in var_188 {
{
array_189.value().string(item_190.as_str());
}
}
array_189.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_game_server_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteGameServerGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_191) = &input.game_server_group_name {
object.key("GameServerGroupName").string(var_191.as_str());
}
if let Some(var_192) = &input.delete_option {
object.key("DeleteOption").string(var_192.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_game_session_queue_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteGameSessionQueueInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_193) = &input.name {
object.key("Name").string(var_193.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_location_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteLocationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_194) = &input.location_name {
object.key("LocationName").string(var_194.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_matchmaking_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteMatchmakingConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_195) = &input.name {
object.key("Name").string(var_195.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_matchmaking_rule_set_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteMatchmakingRuleSetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_196) = &input.name {
object.key("Name").string(var_196.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_scaling_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteScalingPolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_197) = &input.name {
object.key("Name").string(var_197.as_str());
}
if let Some(var_198) = &input.fleet_id {
object.key("FleetId").string(var_198.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_script_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteScriptInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_199) = &input.script_id {
object.key("ScriptId").string(var_199.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_vpc_peering_authorization_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteVpcPeeringAuthorizationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_200) = &input.game_lift_aws_account_id {
object.key("GameLiftAwsAccountId").string(var_200.as_str());
}
if let Some(var_201) = &input.peer_vpc_id {
object.key("PeerVpcId").string(var_201.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_delete_vpc_peering_connection_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeleteVpcPeeringConnectionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_202) = &input.fleet_id {
object.key("FleetId").string(var_202.as_str());
}
if let Some(var_203) = &input.vpc_peering_connection_id {
object
.key("VpcPeeringConnectionId")
.string(var_203.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_deregister_compute_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeregisterComputeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_204) = &input.fleet_id {
object.key("FleetId").string(var_204.as_str());
}
if let Some(var_205) = &input.compute_name {
object.key("ComputeName").string(var_205.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_deregister_game_server_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DeregisterGameServerInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_206) = &input.game_server_group_name {
object.key("GameServerGroupName").string(var_206.as_str());
}
if let Some(var_207) = &input.game_server_id {
object.key("GameServerId").string(var_207.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_alias_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeAliasInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_208) = &input.alias_id {
object.key("AliasId").string(var_208.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_build_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeBuildInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_209) = &input.build_id {
object.key("BuildId").string(var_209.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_compute_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeComputeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_210) = &input.fleet_id {
object.key("FleetId").string(var_210.as_str());
}
if let Some(var_211) = &input.compute_name {
object.key("ComputeName").string(var_211.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_ec2_instance_limits_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeEc2InstanceLimitsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_212) = &input.ec2_instance_type {
object.key("EC2InstanceType").string(var_212.as_str());
}
if let Some(var_213) = &input.location {
object.key("Location").string(var_213.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_fleet_attributes_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeFleetAttributesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_214) = &input.fleet_ids {
let mut array_215 = object.key("FleetIds").start_array();
for item_216 in var_214 {
{
array_215.value().string(item_216.as_str());
}
}
array_215.finish();
}
if let Some(var_217) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_217).into()),
);
}
if let Some(var_218) = &input.next_token {
object.key("NextToken").string(var_218.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_fleet_capacity_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeFleetCapacityInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_219) = &input.fleet_ids {
let mut array_220 = object.key("FleetIds").start_array();
for item_221 in var_219 {
{
array_220.value().string(item_221.as_str());
}
}
array_220.finish();
}
if let Some(var_222) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_222).into()),
);
}
if let Some(var_223) = &input.next_token {
object.key("NextToken").string(var_223.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_fleet_events_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeFleetEventsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_224) = &input.fleet_id {
object.key("FleetId").string(var_224.as_str());
}
if let Some(var_225) = &input.start_time {
object
.key("StartTime")
.date_time(var_225, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_226) = &input.end_time {
object
.key("EndTime")
.date_time(var_226, aws_smithy_types::date_time::Format::EpochSeconds)?;
}
if let Some(var_227) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_227).into()),
);
}
if let Some(var_228) = &input.next_token {
object.key("NextToken").string(var_228.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_fleet_location_attributes_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeFleetLocationAttributesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_229) = &input.fleet_id {
object.key("FleetId").string(var_229.as_str());
}
if let Some(var_230) = &input.locations {
let mut array_231 = object.key("Locations").start_array();
for item_232 in var_230 {
{
array_231.value().string(item_232.as_str());
}
}
array_231.finish();
}
if let Some(var_233) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_233).into()),
);
}
if let Some(var_234) = &input.next_token {
object.key("NextToken").string(var_234.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_fleet_location_capacity_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeFleetLocationCapacityInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_235) = &input.fleet_id {
object.key("FleetId").string(var_235.as_str());
}
if let Some(var_236) = &input.location {
object.key("Location").string(var_236.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_fleet_location_utilization_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeFleetLocationUtilizationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_237) = &input.fleet_id {
object.key("FleetId").string(var_237.as_str());
}
if let Some(var_238) = &input.location {
object.key("Location").string(var_238.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_fleet_port_settings_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeFleetPortSettingsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_239) = &input.fleet_id {
object.key("FleetId").string(var_239.as_str());
}
if let Some(var_240) = &input.location {
object.key("Location").string(var_240.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_fleet_utilization_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeFleetUtilizationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_241) = &input.fleet_ids {
let mut array_242 = object.key("FleetIds").start_array();
for item_243 in var_241 {
{
array_242.value().string(item_243.as_str());
}
}
array_242.finish();
}
if let Some(var_244) = &input.limit {
object.key("Limit").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_describe_game_server_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeGameServerInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_246) = &input.game_server_group_name {
object.key("GameServerGroupName").string(var_246.as_str());
}
if let Some(var_247) = &input.game_server_id {
object.key("GameServerId").string(var_247.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_game_server_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeGameServerGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_248) = &input.game_server_group_name {
object.key("GameServerGroupName").string(var_248.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_game_server_instances_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeGameServerInstancesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_249) = &input.game_server_group_name {
object.key("GameServerGroupName").string(var_249.as_str());
}
if let Some(var_250) = &input.instance_ids {
let mut array_251 = object.key("InstanceIds").start_array();
for item_252 in var_250 {
{
array_251.value().string(item_252.as_str());
}
}
array_251.finish();
}
if let Some(var_253) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_253).into()),
);
}
if let Some(var_254) = &input.next_token {
object.key("NextToken").string(var_254.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_game_session_details_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeGameSessionDetailsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_255) = &input.fleet_id {
object.key("FleetId").string(var_255.as_str());
}
if let Some(var_256) = &input.game_session_id {
object.key("GameSessionId").string(var_256.as_str());
}
if let Some(var_257) = &input.alias_id {
object.key("AliasId").string(var_257.as_str());
}
if let Some(var_258) = &input.location {
object.key("Location").string(var_258.as_str());
}
if let Some(var_259) = &input.status_filter {
object.key("StatusFilter").string(var_259.as_str());
}
if let Some(var_260) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_260).into()),
);
}
if let Some(var_261) = &input.next_token {
object.key("NextToken").string(var_261.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_game_session_placement_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeGameSessionPlacementInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_262) = &input.placement_id {
object.key("PlacementId").string(var_262.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_game_session_queues_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeGameSessionQueuesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_263) = &input.names {
let mut array_264 = object.key("Names").start_array();
for item_265 in var_263 {
{
array_264.value().string(item_265.as_str());
}
}
array_264.finish();
}
if let Some(var_266) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_266).into()),
);
}
if let Some(var_267) = &input.next_token {
object.key("NextToken").string(var_267.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_game_sessions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeGameSessionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_268) = &input.fleet_id {
object.key("FleetId").string(var_268.as_str());
}
if let Some(var_269) = &input.game_session_id {
object.key("GameSessionId").string(var_269.as_str());
}
if let Some(var_270) = &input.alias_id {
object.key("AliasId").string(var_270.as_str());
}
if let Some(var_271) = &input.location {
object.key("Location").string(var_271.as_str());
}
if let Some(var_272) = &input.status_filter {
object.key("StatusFilter").string(var_272.as_str());
}
if let Some(var_273) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_273).into()),
);
}
if let Some(var_274) = &input.next_token {
object.key("NextToken").string(var_274.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_instances_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeInstancesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_275) = &input.fleet_id {
object.key("FleetId").string(var_275.as_str());
}
if let Some(var_276) = &input.instance_id {
object.key("InstanceId").string(var_276.as_str());
}
if let Some(var_277) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_277).into()),
);
}
if let Some(var_278) = &input.next_token {
object.key("NextToken").string(var_278.as_str());
}
if let Some(var_279) = &input.location {
object.key("Location").string(var_279.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_matchmaking_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeMatchmakingInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_280) = &input.ticket_ids {
let mut array_281 = object.key("TicketIds").start_array();
for item_282 in var_280 {
{
array_281.value().string(item_282.as_str());
}
}
array_281.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_matchmaking_configurations_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeMatchmakingConfigurationsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_283) = &input.names {
let mut array_284 = object.key("Names").start_array();
for item_285 in var_283 {
{
array_284.value().string(item_285.as_str());
}
}
array_284.finish();
}
if let Some(var_286) = &input.rule_set_name {
object.key("RuleSetName").string(var_286.as_str());
}
if let Some(var_287) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_287).into()),
);
}
if let Some(var_288) = &input.next_token {
object.key("NextToken").string(var_288.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_matchmaking_rule_sets_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeMatchmakingRuleSetsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_289) = &input.names {
let mut array_290 = object.key("Names").start_array();
for item_291 in var_289 {
{
array_290.value().string(item_291.as_str());
}
}
array_290.finish();
}
if let Some(var_292) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_292).into()),
);
}
if let Some(var_293) = &input.next_token {
object.key("NextToken").string(var_293.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_player_sessions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribePlayerSessionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_294) = &input.game_session_id {
object.key("GameSessionId").string(var_294.as_str());
}
if let Some(var_295) = &input.player_id {
object.key("PlayerId").string(var_295.as_str());
}
if let Some(var_296) = &input.player_session_id {
object.key("PlayerSessionId").string(var_296.as_str());
}
if let Some(var_297) = &input.player_session_status_filter {
object
.key("PlayerSessionStatusFilter")
.string(var_297.as_str());
}
if let Some(var_298) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_298).into()),
);
}
if let Some(var_299) = &input.next_token {
object.key("NextToken").string(var_299.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_runtime_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeRuntimeConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_300) = &input.fleet_id {
object.key("FleetId").string(var_300.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_scaling_policies_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeScalingPoliciesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_301) = &input.fleet_id {
object.key("FleetId").string(var_301.as_str());
}
if let Some(var_302) = &input.status_filter {
object.key("StatusFilter").string(var_302.as_str());
}
if let Some(var_303) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_303).into()),
);
}
if let Some(var_304) = &input.next_token {
object.key("NextToken").string(var_304.as_str());
}
if let Some(var_305) = &input.location {
object.key("Location").string(var_305.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_script_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeScriptInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_306) = &input.script_id {
object.key("ScriptId").string(var_306.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_describe_vpc_peering_connections_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::DescribeVpcPeeringConnectionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_307) = &input.fleet_id {
object.key("FleetId").string(var_307.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_compute_access_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetComputeAccessInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_308) = &input.fleet_id {
object.key("FleetId").string(var_308.as_str());
}
if let Some(var_309) = &input.compute_name {
object.key("ComputeName").string(var_309.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_compute_auth_token_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetComputeAuthTokenInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_310) = &input.fleet_id {
object.key("FleetId").string(var_310.as_str());
}
if let Some(var_311) = &input.compute_name {
object.key("ComputeName").string(var_311.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_game_session_log_url_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetGameSessionLogUrlInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_312) = &input.game_session_id {
object.key("GameSessionId").string(var_312.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_get_instance_access_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::GetInstanceAccessInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_313) = &input.fleet_id {
object.key("FleetId").string(var_313.as_str());
}
if let Some(var_314) = &input.instance_id {
object.key("InstanceId").string(var_314.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_aliases_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListAliasesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_315) = &input.routing_strategy_type {
object.key("RoutingStrategyType").string(var_315.as_str());
}
if let Some(var_316) = &input.name {
object.key("Name").string(var_316.as_str());
}
if let Some(var_317) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_317).into()),
);
}
if let Some(var_318) = &input.next_token {
object.key("NextToken").string(var_318.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_builds_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListBuildsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_319) = &input.status {
object.key("Status").string(var_319.as_str());
}
if let Some(var_320) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_320).into()),
);
}
if let Some(var_321) = &input.next_token {
object.key("NextToken").string(var_321.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_compute_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListComputeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_322) = &input.fleet_id {
object.key("FleetId").string(var_322.as_str());
}
if let Some(var_323) = &input.location {
object.key("Location").string(var_323.as_str());
}
if let Some(var_324) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_324).into()),
);
}
if let Some(var_325) = &input.next_token {
object.key("NextToken").string(var_325.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_fleets_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListFleetsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_326) = &input.build_id {
object.key("BuildId").string(var_326.as_str());
}
if let Some(var_327) = &input.script_id {
object.key("ScriptId").string(var_327.as_str());
}
if let Some(var_328) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_328).into()),
);
}
if let Some(var_329) = &input.next_token {
object.key("NextToken").string(var_329.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_game_server_groups_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListGameServerGroupsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_330) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_330).into()),
);
}
if let Some(var_331) = &input.next_token {
object.key("NextToken").string(var_331.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_game_servers_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListGameServersInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_332) = &input.game_server_group_name {
object.key("GameServerGroupName").string(var_332.as_str());
}
if let Some(var_333) = &input.sort_order {
object.key("SortOrder").string(var_333.as_str());
}
if let Some(var_334) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_334).into()),
);
}
if let Some(var_335) = &input.next_token {
object.key("NextToken").string(var_335.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_locations_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListLocationsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_336) = &input.filters {
let mut array_337 = object.key("Filters").start_array();
for item_338 in var_336 {
{
array_337.value().string(item_338.as_str());
}
}
array_337.finish();
}
if let Some(var_339) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_339).into()),
);
}
if let Some(var_340) = &input.next_token {
object.key("NextToken").string(var_340.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_list_scripts_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ListScriptsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_341) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_341).into()),
);
}
if let Some(var_342) = &input.next_token {
object.key("NextToken").string(var_342.as_str());
}
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_343) = &input.resource_arn {
object.key("ResourceARN").string(var_343.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_put_scaling_policy_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::PutScalingPolicyInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_344) = &input.name {
object.key("Name").string(var_344.as_str());
}
if let Some(var_345) = &input.fleet_id {
object.key("FleetId").string(var_345.as_str());
}
if input.scaling_adjustment != 0 {
object.key("ScalingAdjustment").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((input.scaling_adjustment).into()),
);
}
if let Some(var_346) = &input.scaling_adjustment_type {
object.key("ScalingAdjustmentType").string(var_346.as_str());
}
if input.threshold != 0.0 {
object.key("Threshold").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((input.threshold).into()),
);
}
if let Some(var_347) = &input.comparison_operator {
object.key("ComparisonOperator").string(var_347.as_str());
}
if let Some(var_348) = &input.evaluation_periods {
object.key("EvaluationPeriods").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_348).into()),
);
}
if let Some(var_349) = &input.metric_name {
object.key("MetricName").string(var_349.as_str());
}
if let Some(var_350) = &input.policy_type {
object.key("PolicyType").string(var_350.as_str());
}
if let Some(var_351) = &input.target_configuration {
#[allow(unused_mut)]
let mut object_352 = object.key("TargetConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_target_configuration(
&mut object_352,
var_351,
)?;
object_352.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_register_compute_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RegisterComputeInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_353) = &input.fleet_id {
object.key("FleetId").string(var_353.as_str());
}
if let Some(var_354) = &input.compute_name {
object.key("ComputeName").string(var_354.as_str());
}
if let Some(var_355) = &input.certificate_path {
object.key("CertificatePath").string(var_355.as_str());
}
if let Some(var_356) = &input.dns_name {
object.key("DnsName").string(var_356.as_str());
}
if let Some(var_357) = &input.ip_address {
object.key("IpAddress").string(var_357.as_str());
}
if let Some(var_358) = &input.location {
object.key("Location").string(var_358.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_register_game_server_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RegisterGameServerInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_359) = &input.game_server_group_name {
object.key("GameServerGroupName").string(var_359.as_str());
}
if let Some(var_360) = &input.game_server_id {
object.key("GameServerId").string(var_360.as_str());
}
if let Some(var_361) = &input.instance_id {
object.key("InstanceId").string(var_361.as_str());
}
if let Some(var_362) = &input.connection_info {
object.key("ConnectionInfo").string(var_362.as_str());
}
if let Some(var_363) = &input.game_server_data {
object.key("GameServerData").string(var_363.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_request_upload_credentials_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::RequestUploadCredentialsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_364) = &input.build_id {
object.key("BuildId").string(var_364.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_resolve_alias_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ResolveAliasInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_365) = &input.alias_id {
object.key("AliasId").string(var_365.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_resume_game_server_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ResumeGameServerGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_366) = &input.game_server_group_name {
object.key("GameServerGroupName").string(var_366.as_str());
}
if let Some(var_367) = &input.resume_actions {
let mut array_368 = object.key("ResumeActions").start_array();
for item_369 in var_367 {
{
array_368.value().string(item_369.as_str());
}
}
array_368.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_search_game_sessions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::SearchGameSessionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_370) = &input.fleet_id {
object.key("FleetId").string(var_370.as_str());
}
if let Some(var_371) = &input.alias_id {
object.key("AliasId").string(var_371.as_str());
}
if let Some(var_372) = &input.location {
object.key("Location").string(var_372.as_str());
}
if let Some(var_373) = &input.filter_expression {
object.key("FilterExpression").string(var_373.as_str());
}
if let Some(var_374) = &input.sort_expression {
object.key("SortExpression").string(var_374.as_str());
}
if let Some(var_375) = &input.limit {
object.key("Limit").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_375).into()),
);
}
if let Some(var_376) = &input.next_token {
object.key("NextToken").string(var_376.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_start_fleet_actions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartFleetActionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_377) = &input.fleet_id {
object.key("FleetId").string(var_377.as_str());
}
if let Some(var_378) = &input.actions {
let mut array_379 = object.key("Actions").start_array();
for item_380 in var_378 {
{
array_379.value().string(item_380.as_str());
}
}
array_379.finish();
}
if let Some(var_381) = &input.location {
object.key("Location").string(var_381.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_start_game_session_placement_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartGameSessionPlacementInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_382) = &input.placement_id {
object.key("PlacementId").string(var_382.as_str());
}
if let Some(var_383) = &input.game_session_queue_name {
object.key("GameSessionQueueName").string(var_383.as_str());
}
if let Some(var_384) = &input.game_properties {
let mut array_385 = object.key("GameProperties").start_array();
for item_386 in var_384 {
{
#[allow(unused_mut)]
let mut object_387 = array_385.value().start_object();
crate::json_ser::serialize_structure_crate_model_game_property(
&mut object_387,
item_386,
)?;
object_387.finish();
}
}
array_385.finish();
}
if let Some(var_388) = &input.maximum_player_session_count {
object.key("MaximumPlayerSessionCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_388).into()),
);
}
if let Some(var_389) = &input.game_session_name {
object.key("GameSessionName").string(var_389.as_str());
}
if let Some(var_390) = &input.player_latencies {
let mut array_391 = object.key("PlayerLatencies").start_array();
for item_392 in var_390 {
{
#[allow(unused_mut)]
let mut object_393 = array_391.value().start_object();
crate::json_ser::serialize_structure_crate_model_player_latency(
&mut object_393,
item_392,
)?;
object_393.finish();
}
}
array_391.finish();
}
if let Some(var_394) = &input.desired_player_sessions {
let mut array_395 = object.key("DesiredPlayerSessions").start_array();
for item_396 in var_394 {
{
#[allow(unused_mut)]
let mut object_397 = array_395.value().start_object();
crate::json_ser::serialize_structure_crate_model_desired_player_session(
&mut object_397,
item_396,
)?;
object_397.finish();
}
}
array_395.finish();
}
if let Some(var_398) = &input.game_session_data {
object.key("GameSessionData").string(var_398.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_start_match_backfill_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartMatchBackfillInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_399) = &input.ticket_id {
object.key("TicketId").string(var_399.as_str());
}
if let Some(var_400) = &input.configuration_name {
object.key("ConfigurationName").string(var_400.as_str());
}
if let Some(var_401) = &input.game_session_arn {
object.key("GameSessionArn").string(var_401.as_str());
}
if let Some(var_402) = &input.players {
let mut array_403 = object.key("Players").start_array();
for item_404 in var_402 {
{
#[allow(unused_mut)]
let mut object_405 = array_403.value().start_object();
crate::json_ser::serialize_structure_crate_model_player(&mut object_405, item_404)?;
object_405.finish();
}
}
array_403.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_start_matchmaking_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StartMatchmakingInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_406) = &input.ticket_id {
object.key("TicketId").string(var_406.as_str());
}
if let Some(var_407) = &input.configuration_name {
object.key("ConfigurationName").string(var_407.as_str());
}
if let Some(var_408) = &input.players {
let mut array_409 = object.key("Players").start_array();
for item_410 in var_408 {
{
#[allow(unused_mut)]
let mut object_411 = array_409.value().start_object();
crate::json_ser::serialize_structure_crate_model_player(&mut object_411, item_410)?;
object_411.finish();
}
}
array_409.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_stop_fleet_actions_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StopFleetActionsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_412) = &input.fleet_id {
object.key("FleetId").string(var_412.as_str());
}
if let Some(var_413) = &input.actions {
let mut array_414 = object.key("Actions").start_array();
for item_415 in var_413 {
{
array_414.value().string(item_415.as_str());
}
}
array_414.finish();
}
if let Some(var_416) = &input.location {
object.key("Location").string(var_416.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_stop_game_session_placement_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StopGameSessionPlacementInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_417) = &input.placement_id {
object.key("PlacementId").string(var_417.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_stop_matchmaking_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::StopMatchmakingInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_418) = &input.ticket_id {
object.key("TicketId").string(var_418.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_suspend_game_server_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::SuspendGameServerGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_419) = &input.game_server_group_name {
object.key("GameServerGroupName").string(var_419.as_str());
}
if let Some(var_420) = &input.suspend_actions {
let mut array_421 = object.key("SuspendActions").start_array();
for item_422 in var_420 {
{
array_421.value().string(item_422.as_str());
}
}
array_421.finish();
}
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_423) = &input.resource_arn {
object.key("ResourceARN").string(var_423.as_str());
}
if let Some(var_424) = &input.tags {
let mut array_425 = object.key("Tags").start_array();
for item_426 in var_424 {
{
#[allow(unused_mut)]
let mut object_427 = array_425.value().start_object();
crate::json_ser::serialize_structure_crate_model_tag(&mut object_427, item_426)?;
object_427.finish();
}
}
array_425.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_428) = &input.resource_arn {
object.key("ResourceARN").string(var_428.as_str());
}
if let Some(var_429) = &input.tag_keys {
let mut array_430 = object.key("TagKeys").start_array();
for item_431 in var_429 {
{
array_430.value().string(item_431.as_str());
}
}
array_430.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_alias_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateAliasInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_432) = &input.alias_id {
object.key("AliasId").string(var_432.as_str());
}
if let Some(var_433) = &input.name {
object.key("Name").string(var_433.as_str());
}
if let Some(var_434) = &input.description {
object.key("Description").string(var_434.as_str());
}
if let Some(var_435) = &input.routing_strategy {
#[allow(unused_mut)]
let mut object_436 = object.key("RoutingStrategy").start_object();
crate::json_ser::serialize_structure_crate_model_routing_strategy(
&mut object_436,
var_435,
)?;
object_436.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_build_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateBuildInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_437) = &input.build_id {
object.key("BuildId").string(var_437.as_str());
}
if let Some(var_438) = &input.name {
object.key("Name").string(var_438.as_str());
}
if let Some(var_439) = &input.version {
object.key("Version").string(var_439.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_fleet_attributes_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateFleetAttributesInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_440) = &input.fleet_id {
object.key("FleetId").string(var_440.as_str());
}
if let Some(var_441) = &input.name {
object.key("Name").string(var_441.as_str());
}
if let Some(var_442) = &input.description {
object.key("Description").string(var_442.as_str());
}
if let Some(var_443) = &input.new_game_session_protection_policy {
object
.key("NewGameSessionProtectionPolicy")
.string(var_443.as_str());
}
if let Some(var_444) = &input.resource_creation_limit_policy {
#[allow(unused_mut)]
let mut object_445 = object.key("ResourceCreationLimitPolicy").start_object();
crate::json_ser::serialize_structure_crate_model_resource_creation_limit_policy(
&mut object_445,
var_444,
)?;
object_445.finish();
}
if let Some(var_446) = &input.metric_groups {
let mut array_447 = object.key("MetricGroups").start_array();
for item_448 in var_446 {
{
array_447.value().string(item_448.as_str());
}
}
array_447.finish();
}
if let Some(var_449) = &input.anywhere_configuration {
#[allow(unused_mut)]
let mut object_450 = object.key("AnywhereConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_anywhere_configuration(
&mut object_450,
var_449,
)?;
object_450.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_fleet_capacity_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateFleetCapacityInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_451) = &input.fleet_id {
object.key("FleetId").string(var_451.as_str());
}
if let Some(var_452) = &input.desired_instances {
object.key("DesiredInstances").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_452).into()),
);
}
if let Some(var_453) = &input.min_size {
object.key("MinSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_453).into()),
);
}
if let Some(var_454) = &input.max_size {
object.key("MaxSize").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_454).into()),
);
}
if let Some(var_455) = &input.location {
object.key("Location").string(var_455.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_fleet_port_settings_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateFleetPortSettingsInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_456) = &input.fleet_id {
object.key("FleetId").string(var_456.as_str());
}
if let Some(var_457) = &input.inbound_permission_authorizations {
let mut array_458 = object.key("InboundPermissionAuthorizations").start_array();
for item_459 in var_457 {
{
#[allow(unused_mut)]
let mut object_460 = array_458.value().start_object();
crate::json_ser::serialize_structure_crate_model_ip_permission(
&mut object_460,
item_459,
)?;
object_460.finish();
}
}
array_458.finish();
}
if let Some(var_461) = &input.inbound_permission_revocations {
let mut array_462 = object.key("InboundPermissionRevocations").start_array();
for item_463 in var_461 {
{
#[allow(unused_mut)]
let mut object_464 = array_462.value().start_object();
crate::json_ser::serialize_structure_crate_model_ip_permission(
&mut object_464,
item_463,
)?;
object_464.finish();
}
}
array_462.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_game_server_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateGameServerInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_465) = &input.game_server_group_name {
object.key("GameServerGroupName").string(var_465.as_str());
}
if let Some(var_466) = &input.game_server_id {
object.key("GameServerId").string(var_466.as_str());
}
if let Some(var_467) = &input.game_server_data {
object.key("GameServerData").string(var_467.as_str());
}
if let Some(var_468) = &input.utilization_status {
object.key("UtilizationStatus").string(var_468.as_str());
}
if let Some(var_469) = &input.health_check {
object.key("HealthCheck").string(var_469.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_game_server_group_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateGameServerGroupInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_470) = &input.game_server_group_name {
object.key("GameServerGroupName").string(var_470.as_str());
}
if let Some(var_471) = &input.role_arn {
object.key("RoleArn").string(var_471.as_str());
}
if let Some(var_472) = &input.instance_definitions {
let mut array_473 = object.key("InstanceDefinitions").start_array();
for item_474 in var_472 {
{
#[allow(unused_mut)]
let mut object_475 = array_473.value().start_object();
crate::json_ser::serialize_structure_crate_model_instance_definition(
&mut object_475,
item_474,
)?;
object_475.finish();
}
}
array_473.finish();
}
if let Some(var_476) = &input.game_server_protection_policy {
object
.key("GameServerProtectionPolicy")
.string(var_476.as_str());
}
if let Some(var_477) = &input.balancing_strategy {
object.key("BalancingStrategy").string(var_477.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_game_session_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateGameSessionInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_478) = &input.game_session_id {
object.key("GameSessionId").string(var_478.as_str());
}
if let Some(var_479) = &input.maximum_player_session_count {
object.key("MaximumPlayerSessionCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_479).into()),
);
}
if let Some(var_480) = &input.name {
object.key("Name").string(var_480.as_str());
}
if let Some(var_481) = &input.player_session_creation_policy {
object
.key("PlayerSessionCreationPolicy")
.string(var_481.as_str());
}
if let Some(var_482) = &input.protection_policy {
object.key("ProtectionPolicy").string(var_482.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_game_session_queue_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateGameSessionQueueInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_483) = &input.name {
object.key("Name").string(var_483.as_str());
}
if let Some(var_484) = &input.timeout_in_seconds {
object.key("TimeoutInSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_484).into()),
);
}
if let Some(var_485) = &input.player_latency_policies {
let mut array_486 = object.key("PlayerLatencyPolicies").start_array();
for item_487 in var_485 {
{
#[allow(unused_mut)]
let mut object_488 = array_486.value().start_object();
crate::json_ser::serialize_structure_crate_model_player_latency_policy(
&mut object_488,
item_487,
)?;
object_488.finish();
}
}
array_486.finish();
}
if let Some(var_489) = &input.destinations {
let mut array_490 = object.key("Destinations").start_array();
for item_491 in var_489 {
{
#[allow(unused_mut)]
let mut object_492 = array_490.value().start_object();
crate::json_ser::serialize_structure_crate_model_game_session_queue_destination(
&mut object_492,
item_491,
)?;
object_492.finish();
}
}
array_490.finish();
}
if let Some(var_493) = &input.filter_configuration {
#[allow(unused_mut)]
let mut object_494 = object.key("FilterConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_filter_configuration(
&mut object_494,
var_493,
)?;
object_494.finish();
}
if let Some(var_495) = &input.priority_configuration {
#[allow(unused_mut)]
let mut object_496 = object.key("PriorityConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_priority_configuration(
&mut object_496,
var_495,
)?;
object_496.finish();
}
if let Some(var_497) = &input.custom_event_data {
object.key("CustomEventData").string(var_497.as_str());
}
if let Some(var_498) = &input.notification_target {
object.key("NotificationTarget").string(var_498.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_matchmaking_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateMatchmakingConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_499) = &input.name {
object.key("Name").string(var_499.as_str());
}
if let Some(var_500) = &input.description {
object.key("Description").string(var_500.as_str());
}
if let Some(var_501) = &input.game_session_queue_arns {
let mut array_502 = object.key("GameSessionQueueArns").start_array();
for item_503 in var_501 {
{
array_502.value().string(item_503.as_str());
}
}
array_502.finish();
}
if let Some(var_504) = &input.request_timeout_seconds {
object.key("RequestTimeoutSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_504).into()),
);
}
if let Some(var_505) = &input.acceptance_timeout_seconds {
object.key("AcceptanceTimeoutSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_505).into()),
);
}
if let Some(var_506) = &input.acceptance_required {
object.key("AcceptanceRequired").boolean(*var_506);
}
if let Some(var_507) = &input.rule_set_name {
object.key("RuleSetName").string(var_507.as_str());
}
if let Some(var_508) = &input.notification_target {
object.key("NotificationTarget").string(var_508.as_str());
}
if let Some(var_509) = &input.additional_player_count {
object.key("AdditionalPlayerCount").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_509).into()),
);
}
if let Some(var_510) = &input.custom_event_data {
object.key("CustomEventData").string(var_510.as_str());
}
if let Some(var_511) = &input.game_properties {
let mut array_512 = object.key("GameProperties").start_array();
for item_513 in var_511 {
{
#[allow(unused_mut)]
let mut object_514 = array_512.value().start_object();
crate::json_ser::serialize_structure_crate_model_game_property(
&mut object_514,
item_513,
)?;
object_514.finish();
}
}
array_512.finish();
}
if let Some(var_515) = &input.game_session_data {
object.key("GameSessionData").string(var_515.as_str());
}
if let Some(var_516) = &input.backfill_mode {
object.key("BackfillMode").string(var_516.as_str());
}
if let Some(var_517) = &input.flex_match_mode {
object.key("FlexMatchMode").string(var_517.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_input_update_runtime_configuration_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateRuntimeConfigurationInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_518) = &input.fleet_id {
object.key("FleetId").string(var_518.as_str());
}
if let Some(var_519) = &input.runtime_configuration {
#[allow(unused_mut)]
let mut object_520 = object.key("RuntimeConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_runtime_configuration(
&mut object_520,
var_519,
)?;
object_520.finish();
}
Ok(())
}
pub fn serialize_structure_crate_input_update_script_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::UpdateScriptInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_521) = &input.script_id {
object.key("ScriptId").string(var_521.as_str());
}
if let Some(var_522) = &input.name {
object.key("Name").string(var_522.as_str());
}
if let Some(var_523) = &input.version {
object.key("Version").string(var_523.as_str());
}
if let Some(var_524) = &input.storage_location {
#[allow(unused_mut)]
let mut object_525 = object.key("StorageLocation").start_object();
crate::json_ser::serialize_structure_crate_model_s3_location(&mut object_525, var_524)?;
object_525.finish();
}
if let Some(var_526) = &input.zip_file {
object
.key("ZipFile")
.string_unchecked(&aws_smithy_types::base64::encode(var_526));
}
Ok(())
}
pub fn serialize_structure_crate_input_validate_matchmaking_rule_set_input(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::input::ValidateMatchmakingRuleSetInput,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_527) = &input.rule_set_body {
object.key("RuleSetBody").string(var_527.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_routing_strategy(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RoutingStrategy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_528) = &input.r#type {
object.key("Type").string(var_528.as_str());
}
if let Some(var_529) = &input.fleet_id {
object.key("FleetId").string(var_529.as_str());
}
if let Some(var_530) = &input.message {
object.key("Message").string(var_530.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_tag(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Tag,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_531) = &input.key {
object.key("Key").string(var_531.as_str());
}
if let Some(var_532) = &input.value {
object.key("Value").string(var_532.as_str());
}
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_533) = &input.bucket {
object.key("Bucket").string(var_533.as_str());
}
if let Some(var_534) = &input.key {
object.key("Key").string(var_534.as_str());
}
if let Some(var_535) = &input.role_arn {
object.key("RoleArn").string(var_535.as_str());
}
if let Some(var_536) = &input.object_version {
object.key("ObjectVersion").string(var_536.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_ip_permission(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::IpPermission,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_537) = &input.from_port {
object.key("FromPort").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_537).into()),
);
}
if let Some(var_538) = &input.to_port {
object.key("ToPort").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_538).into()),
);
}
if let Some(var_539) = &input.ip_range {
object.key("IpRange").string(var_539.as_str());
}
if let Some(var_540) = &input.protocol {
object.key("Protocol").string(var_540.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_runtime_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::RuntimeConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_541) = &input.server_processes {
let mut array_542 = object.key("ServerProcesses").start_array();
for item_543 in var_541 {
{
#[allow(unused_mut)]
let mut object_544 = array_542.value().start_object();
crate::json_ser::serialize_structure_crate_model_server_process(
&mut object_544,
item_543,
)?;
object_544.finish();
}
}
array_542.finish();
}
if let Some(var_545) = &input.max_concurrent_game_session_activations {
object.key("MaxConcurrentGameSessionActivations").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_545).into()),
);
}
if let Some(var_546) = &input.game_session_activation_timeout_seconds {
object.key("GameSessionActivationTimeoutSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_546).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_resource_creation_limit_policy(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ResourceCreationLimitPolicy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_547) = &input.new_game_sessions_per_creator {
object.key("NewGameSessionsPerCreator").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_547).into()),
);
}
if let Some(var_548) = &input.policy_period_in_minutes {
object.key("PolicyPeriodInMinutes").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_548).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_certificate_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::CertificateConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_549) = &input.certificate_type {
object.key("CertificateType").string(var_549.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_location_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LocationConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_550) = &input.location {
object.key("Location").string(var_550.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_anywhere_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AnywhereConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_551) = &input.cost {
object.key("Cost").string(var_551.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_launch_template_specification(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::LaunchTemplateSpecification,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_552) = &input.launch_template_id {
object.key("LaunchTemplateId").string(var_552.as_str());
}
if let Some(var_553) = &input.launch_template_name {
object.key("LaunchTemplateName").string(var_553.as_str());
}
if let Some(var_554) = &input.version {
object.key("Version").string(var_554.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_instance_definition(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::InstanceDefinition,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_555) = &input.instance_type {
object.key("InstanceType").string(var_555.as_str());
}
if let Some(var_556) = &input.weighted_capacity {
object.key("WeightedCapacity").string(var_556.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_game_server_group_auto_scaling_policy(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GameServerGroupAutoScalingPolicy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_557) = &input.estimated_instance_warmup {
object.key("EstimatedInstanceWarmup").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_557).into()),
);
}
if let Some(var_558) = &input.target_tracking_configuration {
#[allow(unused_mut)]
let mut object_559 = object.key("TargetTrackingConfiguration").start_object();
crate::json_ser::serialize_structure_crate_model_target_tracking_configuration(
&mut object_559,
var_558,
)?;
object_559.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_game_property(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GameProperty,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_560) = &input.key {
object.key("Key").string(var_560.as_str());
}
if let Some(var_561) = &input.value {
object.key("Value").string(var_561.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_player_latency_policy(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PlayerLatencyPolicy,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_562) = &input.maximum_individual_player_latency_milliseconds {
object
.key("MaximumIndividualPlayerLatencyMilliseconds")
.number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_562).into()),
);
}
if let Some(var_563) = &input.policy_duration_seconds {
object.key("PolicyDurationSeconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_563).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_game_session_queue_destination(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::GameSessionQueueDestination,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_564) = &input.destination_arn {
object.key("DestinationArn").string(var_564.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_filter_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::FilterConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_565) = &input.allowed_locations {
let mut array_566 = object.key("AllowedLocations").start_array();
for item_567 in var_565 {
{
array_566.value().string(item_567.as_str());
}
}
array_566.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_priority_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PriorityConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_568) = &input.priority_order {
let mut array_569 = object.key("PriorityOrder").start_array();
for item_570 in var_568 {
{
array_569.value().string(item_570.as_str());
}
}
array_569.finish();
}
if let Some(var_571) = &input.location_order {
let mut array_572 = object.key("LocationOrder").start_array();
for item_573 in var_571 {
{
array_572.value().string(item_573.as_str());
}
}
array_572.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_target_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TargetConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
{
object.key("TargetValue").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((input.target_value).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_player_latency(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::PlayerLatency,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_574) = &input.player_id {
object.key("PlayerId").string(var_574.as_str());
}
if let Some(var_575) = &input.region_identifier {
object.key("RegionIdentifier").string(var_575.as_str());
}
if input.latency_in_milliseconds != 0.0 {
object.key("LatencyInMilliseconds").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((input.latency_in_milliseconds).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_desired_player_session(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::DesiredPlayerSession,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_576) = &input.player_id {
object.key("PlayerId").string(var_576.as_str());
}
if let Some(var_577) = &input.player_data {
object.key("PlayerData").string(var_577.as_str());
}
Ok(())
}
pub fn serialize_structure_crate_model_player(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::Player,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_578) = &input.player_id {
object.key("PlayerId").string(var_578.as_str());
}
if let Some(var_579) = &input.player_attributes {
#[allow(unused_mut)]
let mut object_580 = object.key("PlayerAttributes").start_object();
for (key_581, value_582) in var_579 {
{
#[allow(unused_mut)]
let mut object_583 = object_580.key(key_581.as_str()).start_object();
crate::json_ser::serialize_structure_crate_model_attribute_value(
&mut object_583,
value_582,
)?;
object_583.finish();
}
}
object_580.finish();
}
if let Some(var_584) = &input.team {
object.key("Team").string(var_584.as_str());
}
if let Some(var_585) = &input.latency_in_ms {
#[allow(unused_mut)]
let mut object_586 = object.key("LatencyInMs").start_object();
for (key_587, value_588) in var_585 {
{
object_586.key(key_587.as_str()).number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*value_588).into()),
);
}
}
object_586.finish();
}
Ok(())
}
pub fn serialize_structure_crate_model_server_process(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::ServerProcess,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_589) = &input.launch_path {
object.key("LaunchPath").string(var_589.as_str());
}
if let Some(var_590) = &input.parameters {
object.key("Parameters").string(var_590.as_str());
}
if let Some(var_591) = &input.concurrent_executions {
object.key("ConcurrentExecutions").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::NegInt((*var_591).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_target_tracking_configuration(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::TargetTrackingConfiguration,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_592) = &input.target_value {
object.key("TargetValue").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_592).into()),
);
}
Ok(())
}
pub fn serialize_structure_crate_model_attribute_value(
object: &mut aws_smithy_json::serialize::JsonObjectWriter,
input: &crate::model::AttributeValue,
) -> Result<(), aws_smithy_http::operation::error::SerializationError> {
if let Some(var_593) = &input.s {
object.key("S").string(var_593.as_str());
}
if let Some(var_594) = &input.n {
object.key("N").number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*var_594).into()),
);
}
if let Some(var_595) = &input.sl {
let mut array_596 = object.key("SL").start_array();
for item_597 in var_595 {
{
array_596.value().string(item_597.as_str());
}
}
array_596.finish();
}
if let Some(var_598) = &input.sdm {
#[allow(unused_mut)]
let mut object_599 = object.key("SDM").start_object();
for (key_600, value_601) in var_598 {
{
object_599.key(key_600.as_str()).number(
#[allow(clippy::useless_conversion)]
aws_smithy_types::Number::Float((*value_601).into()),
);
}
}
object_599.finish();
}
Ok(())
}