{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# OPTIONS_GHC -fno-warn-unused-binds #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
{-# OPTIONS_GHC -fno-warn-unused-matches #-}

-- Derived from AWS service descriptions, licensed under Apache 2.0.

-- |
-- Module      : Amazonka.GameLift.CreateMatchmakingConfiguration
-- Copyright   : (c) 2013-2021 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay <brendan.g.hay+amazonka@gmail.com>
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Defines a new matchmaking configuration for use with FlexMatch. Whether
-- your are using FlexMatch with GameLift hosting or as a standalone
-- matchmaking service, the matchmaking configuration sets out rules for
-- matching players and forming teams. If you\'re also using GameLift
-- hosting, it defines how to start game sessions for each match. Your
-- matchmaking system can use multiple configurations to handle different
-- game scenarios. All matchmaking requests (StartMatchmaking or
-- StartMatchBackfill) identify the matchmaking configuration to use and
-- provide player attributes consistent with that configuration.
--
-- To create a matchmaking configuration, you must provide the following:
-- configuration name and FlexMatch mode (with or without GameLift
-- hosting); a rule set that specifies how to evaluate players and find
-- acceptable matches; whether player acceptance is required; and the
-- maximum time allowed for a matchmaking attempt. When using FlexMatch
-- with GameLift hosting, you also need to identify the game session queue
-- to use when starting a game session for the match.
--
-- In addition, you must set up an Amazon Simple Notification Service (SNS)
-- topic to receive matchmaking notifications. Provide the topic ARN in the
-- matchmaking configuration. An alternative method, continuously polling
-- ticket status with DescribeMatchmaking, is only suitable for games in
-- development with low matchmaking usage.
--
-- __Learn more__
--
-- <https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/match-configuration.html Design a FlexMatch matchmaker>
--
-- <https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/match-notification.html Set up FlexMatch event notification>
--
-- __Related actions__
--
-- CreateMatchmakingConfiguration | DescribeMatchmakingConfigurations |
-- UpdateMatchmakingConfiguration | DeleteMatchmakingConfiguration |
-- CreateMatchmakingRuleSet | DescribeMatchmakingRuleSets |
-- ValidateMatchmakingRuleSet | DeleteMatchmakingRuleSet |
-- <https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets All APIs by task>
module Amazonka.GameLift.CreateMatchmakingConfiguration
  ( -- * Creating a Request
    CreateMatchmakingConfiguration (..),
    newCreateMatchmakingConfiguration,

    -- * Request Lenses
    createMatchmakingConfiguration_backfillMode,
    createMatchmakingConfiguration_gameProperties,
    createMatchmakingConfiguration_acceptanceTimeoutSeconds,
    createMatchmakingConfiguration_notificationTarget,
    createMatchmakingConfiguration_flexMatchMode,
    createMatchmakingConfiguration_gameSessionQueueArns,
    createMatchmakingConfiguration_customEventData,
    createMatchmakingConfiguration_gameSessionData,
    createMatchmakingConfiguration_description,
    createMatchmakingConfiguration_tags,
    createMatchmakingConfiguration_additionalPlayerCount,
    createMatchmakingConfiguration_name,
    createMatchmakingConfiguration_requestTimeoutSeconds,
    createMatchmakingConfiguration_acceptanceRequired,
    createMatchmakingConfiguration_ruleSetName,

    -- * Destructuring the Response
    CreateMatchmakingConfigurationResponse (..),
    newCreateMatchmakingConfigurationResponse,

    -- * Response Lenses
    createMatchmakingConfigurationResponse_configuration,
    createMatchmakingConfigurationResponse_httpStatus,
  )
where

import qualified Amazonka.Core as Core
import Amazonka.GameLift.Types
import qualified Amazonka.Lens as Lens
import qualified Amazonka.Prelude as Prelude
import qualified Amazonka.Request as Request
import qualified Amazonka.Response as Response

-- | Represents the input for a request operation.
--
-- /See:/ 'newCreateMatchmakingConfiguration' smart constructor.
data CreateMatchmakingConfiguration = CreateMatchmakingConfiguration'
  { -- | The method used to backfill game sessions that are created with this
    -- matchmaking configuration. Specify @MANUAL@ when your game manages
    -- backfill requests manually or does not use the match backfill feature.
    -- Specify @AUTOMATIC@ to have GameLift create a StartMatchBackfill request
    -- whenever a game session has one or more open slots. Learn more about
    -- manual and automatic backfill in
    -- <https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/match-backfill.html Backfill Existing Games with FlexMatch>.
    -- Automatic backfill is not available when @FlexMatchMode@ is set to
    -- @STANDALONE@.
    CreateMatchmakingConfiguration -> Maybe BackfillMode
backfillMode :: Prelude.Maybe BackfillMode,
    -- | A set of custom properties for a game session, formatted as key:value
    -- pairs. These properties are passed to a game server process in the
    -- GameSession object with a request to start a new game session (see
    -- <https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-sdk-server-api.html#gamelift-sdk-server-startsession Start a Game Session>).
    -- This information is added to the new GameSession object that is created
    -- for a successful match. This parameter is not used if @FlexMatchMode@ is
    -- set to @STANDALONE@.
    CreateMatchmakingConfiguration -> Maybe [GameProperty]
gameProperties :: Prelude.Maybe [GameProperty],
    -- | The length of time (in seconds) to wait for players to accept a proposed
    -- match, if acceptance is required.
    CreateMatchmakingConfiguration -> Maybe Natural
acceptanceTimeoutSeconds :: Prelude.Maybe Prelude.Natural,
    -- | An SNS topic ARN that is set up to receive matchmaking notifications.
    -- See
    -- <https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/match-notification.html Setting up notifications for matchmaking>
    -- for more information.
    CreateMatchmakingConfiguration -> Maybe Text
notificationTarget :: Prelude.Maybe Prelude.Text,
    -- | Indicates whether this matchmaking configuration is being used with
    -- GameLift hosting or as a standalone matchmaking solution.
    --
    -- -   __STANDALONE__ - FlexMatch forms matches and returns match
    --     information, including players and team assignments, in a
    --     <https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/match-events.html#match-events-matchmakingsucceeded MatchmakingSucceeded>
    --     event.
    --
    -- -   __WITH_QUEUE__ - FlexMatch forms matches and uses the specified
    --     GameLift queue to start a game session for the match.
    CreateMatchmakingConfiguration -> Maybe FlexMatchMode
flexMatchMode :: Prelude.Maybe FlexMatchMode,
    -- | The Amazon Resource Name
    -- (<https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html ARN>)
    -- that is assigned to a GameLift game session queue resource and uniquely
    -- identifies it. ARNs are unique across all Regions. Format is
    -- @arn:aws:gamelift:\<region>::gamesessionqueue\/\<queue name>@. Queues
    -- can be located in any Region. Queues are used to start new
    -- GameLift-hosted game sessions for matches that are created with this
    -- matchmaking configuration. If @FlexMatchMode@ is set to @STANDALONE@, do
    -- not set this parameter.
    CreateMatchmakingConfiguration -> Maybe [Text]
gameSessionQueueArns :: Prelude.Maybe [Prelude.Text],
    -- | Information to be added to all events related to this matchmaking
    -- configuration.
    CreateMatchmakingConfiguration -> Maybe Text
customEventData :: Prelude.Maybe Prelude.Text,
    -- | A set of custom game session properties, formatted as a single string
    -- value. This data is passed to a game server process in the GameSession
    -- object with a request to start a new game session (see
    -- <https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-sdk-server-api.html#gamelift-sdk-server-startsession Start a Game Session>).
    -- This information is added to the new GameSession object that is created
    -- for a successful match. This parameter is not used if @FlexMatchMode@ is
    -- set to @STANDALONE@.
    CreateMatchmakingConfiguration -> Maybe Text
gameSessionData :: Prelude.Maybe Prelude.Text,
    -- | A human-readable description of the matchmaking configuration.
    CreateMatchmakingConfiguration -> Maybe Text
description :: Prelude.Maybe Prelude.Text,
    -- | A list of labels to assign to the new matchmaking configuration
    -- resource. Tags are developer-defined key-value pairs. Tagging AWS
    -- resources are useful for resource management, access management and cost
    -- allocation. For more information, see
    -- <https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html Tagging AWS Resources>
    -- in the /AWS General Reference/. Once the resource is created, you can
    -- use TagResource, UntagResource, and ListTagsForResource to add, remove,
    -- and view tags. The maximum tag limit may be lower than stated. See the
    -- AWS General Reference for actual tagging limits.
    CreateMatchmakingConfiguration -> Maybe [Tag]
tags :: Prelude.Maybe [Tag],
    -- | The number of player slots in a match to keep open for future players.
    -- For example, if the configuration\'s rule set specifies a match for a
    -- single 12-person team, and the additional player count is set to 2, only
    -- 10 players are selected for the match. This parameter is not used if
    -- @FlexMatchMode@ is set to @STANDALONE@.
    CreateMatchmakingConfiguration -> Maybe Natural
additionalPlayerCount :: Prelude.Maybe Prelude.Natural,
    -- | A unique identifier for the matchmaking configuration. This name is used
    -- to identify the configuration associated with a matchmaking request or
    -- ticket.
    CreateMatchmakingConfiguration -> Text
name :: Prelude.Text,
    -- | The maximum duration, in seconds, that a matchmaking ticket can remain
    -- in process before timing out. Requests that fail due to timing out can
    -- be resubmitted as needed.
    CreateMatchmakingConfiguration -> Natural
requestTimeoutSeconds :: Prelude.Natural,
    -- | A flag that determines whether a match that was created with this
    -- configuration must be accepted by the matched players. To require
    -- acceptance, set to @TRUE@. With this option enabled, matchmaking tickets
    -- use the status @REQUIRES_ACCEPTANCE@ to indicate when a completed
    -- potential match is waiting for player acceptance.
    CreateMatchmakingConfiguration -> Bool
acceptanceRequired :: Prelude.Bool,
    -- | A unique identifier for the matchmaking rule set to use with this
    -- configuration. You can use either the rule set name or ARN value. A
    -- matchmaking configuration can only use rule sets that are defined in the
    -- same Region.
    CreateMatchmakingConfiguration -> Text
ruleSetName :: Prelude.Text
  }
  deriving (CreateMatchmakingConfiguration
-> CreateMatchmakingConfiguration -> Bool
(CreateMatchmakingConfiguration
 -> CreateMatchmakingConfiguration -> Bool)
-> (CreateMatchmakingConfiguration
    -> CreateMatchmakingConfiguration -> Bool)
-> Eq CreateMatchmakingConfiguration
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateMatchmakingConfiguration
-> CreateMatchmakingConfiguration -> Bool
$c/= :: CreateMatchmakingConfiguration
-> CreateMatchmakingConfiguration -> Bool
== :: CreateMatchmakingConfiguration
-> CreateMatchmakingConfiguration -> Bool
$c== :: CreateMatchmakingConfiguration
-> CreateMatchmakingConfiguration -> Bool
Prelude.Eq, ReadPrec [CreateMatchmakingConfiguration]
ReadPrec CreateMatchmakingConfiguration
Int -> ReadS CreateMatchmakingConfiguration
ReadS [CreateMatchmakingConfiguration]
(Int -> ReadS CreateMatchmakingConfiguration)
-> ReadS [CreateMatchmakingConfiguration]
-> ReadPrec CreateMatchmakingConfiguration
-> ReadPrec [CreateMatchmakingConfiguration]
-> Read CreateMatchmakingConfiguration
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateMatchmakingConfiguration]
$creadListPrec :: ReadPrec [CreateMatchmakingConfiguration]
readPrec :: ReadPrec CreateMatchmakingConfiguration
$creadPrec :: ReadPrec CreateMatchmakingConfiguration
readList :: ReadS [CreateMatchmakingConfiguration]
$creadList :: ReadS [CreateMatchmakingConfiguration]
readsPrec :: Int -> ReadS CreateMatchmakingConfiguration
$creadsPrec :: Int -> ReadS CreateMatchmakingConfiguration
Prelude.Read, Int -> CreateMatchmakingConfiguration -> ShowS
[CreateMatchmakingConfiguration] -> ShowS
CreateMatchmakingConfiguration -> String
(Int -> CreateMatchmakingConfiguration -> ShowS)
-> (CreateMatchmakingConfiguration -> String)
-> ([CreateMatchmakingConfiguration] -> ShowS)
-> Show CreateMatchmakingConfiguration
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateMatchmakingConfiguration] -> ShowS
$cshowList :: [CreateMatchmakingConfiguration] -> ShowS
show :: CreateMatchmakingConfiguration -> String
$cshow :: CreateMatchmakingConfiguration -> String
showsPrec :: Int -> CreateMatchmakingConfiguration -> ShowS
$cshowsPrec :: Int -> CreateMatchmakingConfiguration -> ShowS
Prelude.Show, (forall x.
 CreateMatchmakingConfiguration
 -> Rep CreateMatchmakingConfiguration x)
-> (forall x.
    Rep CreateMatchmakingConfiguration x
    -> CreateMatchmakingConfiguration)
-> Generic CreateMatchmakingConfiguration
forall x.
Rep CreateMatchmakingConfiguration x
-> CreateMatchmakingConfiguration
forall x.
CreateMatchmakingConfiguration
-> Rep CreateMatchmakingConfiguration x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep CreateMatchmakingConfiguration x
-> CreateMatchmakingConfiguration
$cfrom :: forall x.
CreateMatchmakingConfiguration
-> Rep CreateMatchmakingConfiguration x
Prelude.Generic)

-- |
-- Create a value of 'CreateMatchmakingConfiguration' with all optional fields omitted.
--
-- Use <https://hackage.haskell.org/package/generic-lens generic-lens> or <https://hackage.haskell.org/package/optics optics> to modify other optional fields.
--
-- The following record fields are available, with the corresponding lenses provided
-- for backwards compatibility:
--
-- 'backfillMode', 'createMatchmakingConfiguration_backfillMode' - The method used to backfill game sessions that are created with this
-- matchmaking configuration. Specify @MANUAL@ when your game manages
-- backfill requests manually or does not use the match backfill feature.
-- Specify @AUTOMATIC@ to have GameLift create a StartMatchBackfill request
-- whenever a game session has one or more open slots. Learn more about
-- manual and automatic backfill in
-- <https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/match-backfill.html Backfill Existing Games with FlexMatch>.
-- Automatic backfill is not available when @FlexMatchMode@ is set to
-- @STANDALONE@.
--
-- 'gameProperties', 'createMatchmakingConfiguration_gameProperties' - A set of custom properties for a game session, formatted as key:value
-- pairs. These properties are passed to a game server process in the
-- GameSession object with a request to start a new game session (see
-- <https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-sdk-server-api.html#gamelift-sdk-server-startsession Start a Game Session>).
-- This information is added to the new GameSession object that is created
-- for a successful match. This parameter is not used if @FlexMatchMode@ is
-- set to @STANDALONE@.
--
-- 'acceptanceTimeoutSeconds', 'createMatchmakingConfiguration_acceptanceTimeoutSeconds' - The length of time (in seconds) to wait for players to accept a proposed
-- match, if acceptance is required.
--
-- 'notificationTarget', 'createMatchmakingConfiguration_notificationTarget' - An SNS topic ARN that is set up to receive matchmaking notifications.
-- See
-- <https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/match-notification.html Setting up notifications for matchmaking>
-- for more information.
--
-- 'flexMatchMode', 'createMatchmakingConfiguration_flexMatchMode' - Indicates whether this matchmaking configuration is being used with
-- GameLift hosting or as a standalone matchmaking solution.
--
-- -   __STANDALONE__ - FlexMatch forms matches and returns match
--     information, including players and team assignments, in a
--     <https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/match-events.html#match-events-matchmakingsucceeded MatchmakingSucceeded>
--     event.
--
-- -   __WITH_QUEUE__ - FlexMatch forms matches and uses the specified
--     GameLift queue to start a game session for the match.
--
-- 'gameSessionQueueArns', 'createMatchmakingConfiguration_gameSessionQueueArns' - The Amazon Resource Name
-- (<https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html ARN>)
-- that is assigned to a GameLift game session queue resource and uniquely
-- identifies it. ARNs are unique across all Regions. Format is
-- @arn:aws:gamelift:\<region>::gamesessionqueue\/\<queue name>@. Queues
-- can be located in any Region. Queues are used to start new
-- GameLift-hosted game sessions for matches that are created with this
-- matchmaking configuration. If @FlexMatchMode@ is set to @STANDALONE@, do
-- not set this parameter.
--
-- 'customEventData', 'createMatchmakingConfiguration_customEventData' - Information to be added to all events related to this matchmaking
-- configuration.
--
-- 'gameSessionData', 'createMatchmakingConfiguration_gameSessionData' - A set of custom game session properties, formatted as a single string
-- value. This data is passed to a game server process in the GameSession
-- object with a request to start a new game session (see
-- <https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-sdk-server-api.html#gamelift-sdk-server-startsession Start a Game Session>).
-- This information is added to the new GameSession object that is created
-- for a successful match. This parameter is not used if @FlexMatchMode@ is
-- set to @STANDALONE@.
--
-- 'description', 'createMatchmakingConfiguration_description' - A human-readable description of the matchmaking configuration.
--
-- 'tags', 'createMatchmakingConfiguration_tags' - A list of labels to assign to the new matchmaking configuration
-- resource. Tags are developer-defined key-value pairs. Tagging AWS
-- resources are useful for resource management, access management and cost
-- allocation. For more information, see
-- <https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html Tagging AWS Resources>
-- in the /AWS General Reference/. Once the resource is created, you can
-- use TagResource, UntagResource, and ListTagsForResource to add, remove,
-- and view tags. The maximum tag limit may be lower than stated. See the
-- AWS General Reference for actual tagging limits.
--
-- 'additionalPlayerCount', 'createMatchmakingConfiguration_additionalPlayerCount' - The number of player slots in a match to keep open for future players.
-- For example, if the configuration\'s rule set specifies a match for a
-- single 12-person team, and the additional player count is set to 2, only
-- 10 players are selected for the match. This parameter is not used if
-- @FlexMatchMode@ is set to @STANDALONE@.
--
-- 'name', 'createMatchmakingConfiguration_name' - A unique identifier for the matchmaking configuration. This name is used
-- to identify the configuration associated with a matchmaking request or
-- ticket.
--
-- 'requestTimeoutSeconds', 'createMatchmakingConfiguration_requestTimeoutSeconds' - The maximum duration, in seconds, that a matchmaking ticket can remain
-- in process before timing out. Requests that fail due to timing out can
-- be resubmitted as needed.
--
-- 'acceptanceRequired', 'createMatchmakingConfiguration_acceptanceRequired' - A flag that determines whether a match that was created with this
-- configuration must be accepted by the matched players. To require
-- acceptance, set to @TRUE@. With this option enabled, matchmaking tickets
-- use the status @REQUIRES_ACCEPTANCE@ to indicate when a completed
-- potential match is waiting for player acceptance.
--
-- 'ruleSetName', 'createMatchmakingConfiguration_ruleSetName' - A unique identifier for the matchmaking rule set to use with this
-- configuration. You can use either the rule set name or ARN value. A
-- matchmaking configuration can only use rule sets that are defined in the
-- same Region.
newCreateMatchmakingConfiguration ::
  -- | 'name'
  Prelude.Text ->
  -- | 'requestTimeoutSeconds'
  Prelude.Natural ->
  -- | 'acceptanceRequired'
  Prelude.Bool ->
  -- | 'ruleSetName'
  Prelude.Text ->
  CreateMatchmakingConfiguration
newCreateMatchmakingConfiguration :: Text -> Natural -> Bool -> Text -> CreateMatchmakingConfiguration
newCreateMatchmakingConfiguration
  Text
pName_
  Natural
pRequestTimeoutSeconds_
  Bool
pAcceptanceRequired_
  Text
pRuleSetName_ =
    CreateMatchmakingConfiguration' :: Maybe BackfillMode
-> Maybe [GameProperty]
-> Maybe Natural
-> Maybe Text
-> Maybe FlexMatchMode
-> Maybe [Text]
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe [Tag]
-> Maybe Natural
-> Text
-> Natural
-> Bool
-> Text
-> CreateMatchmakingConfiguration
CreateMatchmakingConfiguration'
      { $sel:backfillMode:CreateMatchmakingConfiguration' :: Maybe BackfillMode
backfillMode =
          Maybe BackfillMode
forall a. Maybe a
Prelude.Nothing,
        $sel:gameProperties:CreateMatchmakingConfiguration' :: Maybe [GameProperty]
gameProperties = Maybe [GameProperty]
forall a. Maybe a
Prelude.Nothing,
        $sel:acceptanceTimeoutSeconds:CreateMatchmakingConfiguration' :: Maybe Natural
acceptanceTimeoutSeconds = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
        $sel:notificationTarget:CreateMatchmakingConfiguration' :: Maybe Text
notificationTarget = Maybe Text
forall a. Maybe a
Prelude.Nothing,
        $sel:flexMatchMode:CreateMatchmakingConfiguration' :: Maybe FlexMatchMode
flexMatchMode = Maybe FlexMatchMode
forall a. Maybe a
Prelude.Nothing,
        $sel:gameSessionQueueArns:CreateMatchmakingConfiguration' :: Maybe [Text]
gameSessionQueueArns = Maybe [Text]
forall a. Maybe a
Prelude.Nothing,
        $sel:customEventData:CreateMatchmakingConfiguration' :: Maybe Text
customEventData = Maybe Text
forall a. Maybe a
Prelude.Nothing,
        $sel:gameSessionData:CreateMatchmakingConfiguration' :: Maybe Text
gameSessionData = Maybe Text
forall a. Maybe a
Prelude.Nothing,
        $sel:description:CreateMatchmakingConfiguration' :: Maybe Text
description = Maybe Text
forall a. Maybe a
Prelude.Nothing,
        $sel:tags:CreateMatchmakingConfiguration' :: Maybe [Tag]
tags = Maybe [Tag]
forall a. Maybe a
Prelude.Nothing,
        $sel:additionalPlayerCount:CreateMatchmakingConfiguration' :: Maybe Natural
additionalPlayerCount = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
        $sel:name:CreateMatchmakingConfiguration' :: Text
name = Text
pName_,
        $sel:requestTimeoutSeconds:CreateMatchmakingConfiguration' :: Natural
requestTimeoutSeconds =
          Natural
pRequestTimeoutSeconds_,
        $sel:acceptanceRequired:CreateMatchmakingConfiguration' :: Bool
acceptanceRequired = Bool
pAcceptanceRequired_,
        $sel:ruleSetName:CreateMatchmakingConfiguration' :: Text
ruleSetName = Text
pRuleSetName_
      }

-- | The method used to backfill game sessions that are created with this
-- matchmaking configuration. Specify @MANUAL@ when your game manages
-- backfill requests manually or does not use the match backfill feature.
-- Specify @AUTOMATIC@ to have GameLift create a StartMatchBackfill request
-- whenever a game session has one or more open slots. Learn more about
-- manual and automatic backfill in
-- <https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/match-backfill.html Backfill Existing Games with FlexMatch>.
-- Automatic backfill is not available when @FlexMatchMode@ is set to
-- @STANDALONE@.
createMatchmakingConfiguration_backfillMode :: Lens.Lens' CreateMatchmakingConfiguration (Prelude.Maybe BackfillMode)
createMatchmakingConfiguration_backfillMode :: (Maybe BackfillMode -> f (Maybe BackfillMode))
-> CreateMatchmakingConfiguration
-> f CreateMatchmakingConfiguration
createMatchmakingConfiguration_backfillMode = (CreateMatchmakingConfiguration -> Maybe BackfillMode)
-> (CreateMatchmakingConfiguration
    -> Maybe BackfillMode -> CreateMatchmakingConfiguration)
-> Lens
     CreateMatchmakingConfiguration
     CreateMatchmakingConfiguration
     (Maybe BackfillMode)
     (Maybe BackfillMode)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateMatchmakingConfiguration' {Maybe BackfillMode
backfillMode :: Maybe BackfillMode
$sel:backfillMode:CreateMatchmakingConfiguration' :: CreateMatchmakingConfiguration -> Maybe BackfillMode
backfillMode} -> Maybe BackfillMode
backfillMode) (\s :: CreateMatchmakingConfiguration
s@CreateMatchmakingConfiguration' {} Maybe BackfillMode
a -> CreateMatchmakingConfiguration
s {$sel:backfillMode:CreateMatchmakingConfiguration' :: Maybe BackfillMode
backfillMode = Maybe BackfillMode
a} :: CreateMatchmakingConfiguration)

-- | A set of custom properties for a game session, formatted as key:value
-- pairs. These properties are passed to a game server process in the
-- GameSession object with a request to start a new game session (see
-- <https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-sdk-server-api.html#gamelift-sdk-server-startsession Start a Game Session>).
-- This information is added to the new GameSession object that is created
-- for a successful match. This parameter is not used if @FlexMatchMode@ is
-- set to @STANDALONE@.
createMatchmakingConfiguration_gameProperties :: Lens.Lens' CreateMatchmakingConfiguration (Prelude.Maybe [GameProperty])
createMatchmakingConfiguration_gameProperties :: (Maybe [GameProperty] -> f (Maybe [GameProperty]))
-> CreateMatchmakingConfiguration
-> f CreateMatchmakingConfiguration
createMatchmakingConfiguration_gameProperties = (CreateMatchmakingConfiguration -> Maybe [GameProperty])
-> (CreateMatchmakingConfiguration
    -> Maybe [GameProperty] -> CreateMatchmakingConfiguration)
-> Lens
     CreateMatchmakingConfiguration
     CreateMatchmakingConfiguration
     (Maybe [GameProperty])
     (Maybe [GameProperty])
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateMatchmakingConfiguration' {Maybe [GameProperty]
gameProperties :: Maybe [GameProperty]
$sel:gameProperties:CreateMatchmakingConfiguration' :: CreateMatchmakingConfiguration -> Maybe [GameProperty]
gameProperties} -> Maybe [GameProperty]
gameProperties) (\s :: CreateMatchmakingConfiguration
s@CreateMatchmakingConfiguration' {} Maybe [GameProperty]
a -> CreateMatchmakingConfiguration
s {$sel:gameProperties:CreateMatchmakingConfiguration' :: Maybe [GameProperty]
gameProperties = Maybe [GameProperty]
a} :: CreateMatchmakingConfiguration) ((Maybe [GameProperty] -> f (Maybe [GameProperty]))
 -> CreateMatchmakingConfiguration
 -> f CreateMatchmakingConfiguration)
-> ((Maybe [GameProperty] -> f (Maybe [GameProperty]))
    -> Maybe [GameProperty] -> f (Maybe [GameProperty]))
-> (Maybe [GameProperty] -> f (Maybe [GameProperty]))
-> CreateMatchmakingConfiguration
-> f CreateMatchmakingConfiguration
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso [GameProperty] [GameProperty] [GameProperty] [GameProperty]
-> Iso
     (Maybe [GameProperty])
     (Maybe [GameProperty])
     (Maybe [GameProperty])
     (Maybe [GameProperty])
forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping AnIso [GameProperty] [GameProperty] [GameProperty] [GameProperty]
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The length of time (in seconds) to wait for players to accept a proposed
-- match, if acceptance is required.
createMatchmakingConfiguration_acceptanceTimeoutSeconds :: Lens.Lens' CreateMatchmakingConfiguration (Prelude.Maybe Prelude.Natural)
createMatchmakingConfiguration_acceptanceTimeoutSeconds :: (Maybe Natural -> f (Maybe Natural))
-> CreateMatchmakingConfiguration
-> f CreateMatchmakingConfiguration
createMatchmakingConfiguration_acceptanceTimeoutSeconds = (CreateMatchmakingConfiguration -> Maybe Natural)
-> (CreateMatchmakingConfiguration
    -> Maybe Natural -> CreateMatchmakingConfiguration)
-> Lens
     CreateMatchmakingConfiguration
     CreateMatchmakingConfiguration
     (Maybe Natural)
     (Maybe Natural)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateMatchmakingConfiguration' {Maybe Natural
acceptanceTimeoutSeconds :: Maybe Natural
$sel:acceptanceTimeoutSeconds:CreateMatchmakingConfiguration' :: CreateMatchmakingConfiguration -> Maybe Natural
acceptanceTimeoutSeconds} -> Maybe Natural
acceptanceTimeoutSeconds) (\s :: CreateMatchmakingConfiguration
s@CreateMatchmakingConfiguration' {} Maybe Natural
a -> CreateMatchmakingConfiguration
s {$sel:acceptanceTimeoutSeconds:CreateMatchmakingConfiguration' :: Maybe Natural
acceptanceTimeoutSeconds = Maybe Natural
a} :: CreateMatchmakingConfiguration)

-- | An SNS topic ARN that is set up to receive matchmaking notifications.
-- See
-- <https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/match-notification.html Setting up notifications for matchmaking>
-- for more information.
createMatchmakingConfiguration_notificationTarget :: Lens.Lens' CreateMatchmakingConfiguration (Prelude.Maybe Prelude.Text)
createMatchmakingConfiguration_notificationTarget :: (Maybe Text -> f (Maybe Text))
-> CreateMatchmakingConfiguration
-> f CreateMatchmakingConfiguration
createMatchmakingConfiguration_notificationTarget = (CreateMatchmakingConfiguration -> Maybe Text)
-> (CreateMatchmakingConfiguration
    -> Maybe Text -> CreateMatchmakingConfiguration)
-> Lens
     CreateMatchmakingConfiguration
     CreateMatchmakingConfiguration
     (Maybe Text)
     (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateMatchmakingConfiguration' {Maybe Text
notificationTarget :: Maybe Text
$sel:notificationTarget:CreateMatchmakingConfiguration' :: CreateMatchmakingConfiguration -> Maybe Text
notificationTarget} -> Maybe Text
notificationTarget) (\s :: CreateMatchmakingConfiguration
s@CreateMatchmakingConfiguration' {} Maybe Text
a -> CreateMatchmakingConfiguration
s {$sel:notificationTarget:CreateMatchmakingConfiguration' :: Maybe Text
notificationTarget = Maybe Text
a} :: CreateMatchmakingConfiguration)

-- | Indicates whether this matchmaking configuration is being used with
-- GameLift hosting or as a standalone matchmaking solution.
--
-- -   __STANDALONE__ - FlexMatch forms matches and returns match
--     information, including players and team assignments, in a
--     <https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/match-events.html#match-events-matchmakingsucceeded MatchmakingSucceeded>
--     event.
--
-- -   __WITH_QUEUE__ - FlexMatch forms matches and uses the specified
--     GameLift queue to start a game session for the match.
createMatchmakingConfiguration_flexMatchMode :: Lens.Lens' CreateMatchmakingConfiguration (Prelude.Maybe FlexMatchMode)
createMatchmakingConfiguration_flexMatchMode :: (Maybe FlexMatchMode -> f (Maybe FlexMatchMode))
-> CreateMatchmakingConfiguration
-> f CreateMatchmakingConfiguration
createMatchmakingConfiguration_flexMatchMode = (CreateMatchmakingConfiguration -> Maybe FlexMatchMode)
-> (CreateMatchmakingConfiguration
    -> Maybe FlexMatchMode -> CreateMatchmakingConfiguration)
-> Lens
     CreateMatchmakingConfiguration
     CreateMatchmakingConfiguration
     (Maybe FlexMatchMode)
     (Maybe FlexMatchMode)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateMatchmakingConfiguration' {Maybe FlexMatchMode
flexMatchMode :: Maybe FlexMatchMode
$sel:flexMatchMode:CreateMatchmakingConfiguration' :: CreateMatchmakingConfiguration -> Maybe FlexMatchMode
flexMatchMode} -> Maybe FlexMatchMode
flexMatchMode) (\s :: CreateMatchmakingConfiguration
s@CreateMatchmakingConfiguration' {} Maybe FlexMatchMode
a -> CreateMatchmakingConfiguration
s {$sel:flexMatchMode:CreateMatchmakingConfiguration' :: Maybe FlexMatchMode
flexMatchMode = Maybe FlexMatchMode
a} :: CreateMatchmakingConfiguration)

-- | The Amazon Resource Name
-- (<https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html ARN>)
-- that is assigned to a GameLift game session queue resource and uniquely
-- identifies it. ARNs are unique across all Regions. Format is
-- @arn:aws:gamelift:\<region>::gamesessionqueue\/\<queue name>@. Queues
-- can be located in any Region. Queues are used to start new
-- GameLift-hosted game sessions for matches that are created with this
-- matchmaking configuration. If @FlexMatchMode@ is set to @STANDALONE@, do
-- not set this parameter.
createMatchmakingConfiguration_gameSessionQueueArns :: Lens.Lens' CreateMatchmakingConfiguration (Prelude.Maybe [Prelude.Text])
createMatchmakingConfiguration_gameSessionQueueArns :: (Maybe [Text] -> f (Maybe [Text]))
-> CreateMatchmakingConfiguration
-> f CreateMatchmakingConfiguration
createMatchmakingConfiguration_gameSessionQueueArns = (CreateMatchmakingConfiguration -> Maybe [Text])
-> (CreateMatchmakingConfiguration
    -> Maybe [Text] -> CreateMatchmakingConfiguration)
-> Lens
     CreateMatchmakingConfiguration
     CreateMatchmakingConfiguration
     (Maybe [Text])
     (Maybe [Text])
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateMatchmakingConfiguration' {Maybe [Text]
gameSessionQueueArns :: Maybe [Text]
$sel:gameSessionQueueArns:CreateMatchmakingConfiguration' :: CreateMatchmakingConfiguration -> Maybe [Text]
gameSessionQueueArns} -> Maybe [Text]
gameSessionQueueArns) (\s :: CreateMatchmakingConfiguration
s@CreateMatchmakingConfiguration' {} Maybe [Text]
a -> CreateMatchmakingConfiguration
s {$sel:gameSessionQueueArns:CreateMatchmakingConfiguration' :: Maybe [Text]
gameSessionQueueArns = Maybe [Text]
a} :: CreateMatchmakingConfiguration) ((Maybe [Text] -> f (Maybe [Text]))
 -> CreateMatchmakingConfiguration
 -> f CreateMatchmakingConfiguration)
-> ((Maybe [Text] -> f (Maybe [Text]))
    -> Maybe [Text] -> f (Maybe [Text]))
-> (Maybe [Text] -> f (Maybe [Text]))
-> CreateMatchmakingConfiguration
-> f CreateMatchmakingConfiguration
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso [Text] [Text] [Text] [Text]
-> Iso (Maybe [Text]) (Maybe [Text]) (Maybe [Text]) (Maybe [Text])
forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping AnIso [Text] [Text] [Text] [Text]
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | Information to be added to all events related to this matchmaking
-- configuration.
createMatchmakingConfiguration_customEventData :: Lens.Lens' CreateMatchmakingConfiguration (Prelude.Maybe Prelude.Text)
createMatchmakingConfiguration_customEventData :: (Maybe Text -> f (Maybe Text))
-> CreateMatchmakingConfiguration
-> f CreateMatchmakingConfiguration
createMatchmakingConfiguration_customEventData = (CreateMatchmakingConfiguration -> Maybe Text)
-> (CreateMatchmakingConfiguration
    -> Maybe Text -> CreateMatchmakingConfiguration)
-> Lens
     CreateMatchmakingConfiguration
     CreateMatchmakingConfiguration
     (Maybe Text)
     (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateMatchmakingConfiguration' {Maybe Text
customEventData :: Maybe Text
$sel:customEventData:CreateMatchmakingConfiguration' :: CreateMatchmakingConfiguration -> Maybe Text
customEventData} -> Maybe Text
customEventData) (\s :: CreateMatchmakingConfiguration
s@CreateMatchmakingConfiguration' {} Maybe Text
a -> CreateMatchmakingConfiguration
s {$sel:customEventData:CreateMatchmakingConfiguration' :: Maybe Text
customEventData = Maybe Text
a} :: CreateMatchmakingConfiguration)

-- | A set of custom game session properties, formatted as a single string
-- value. This data is passed to a game server process in the GameSession
-- object with a request to start a new game session (see
-- <https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-sdk-server-api.html#gamelift-sdk-server-startsession Start a Game Session>).
-- This information is added to the new GameSession object that is created
-- for a successful match. This parameter is not used if @FlexMatchMode@ is
-- set to @STANDALONE@.
createMatchmakingConfiguration_gameSessionData :: Lens.Lens' CreateMatchmakingConfiguration (Prelude.Maybe Prelude.Text)
createMatchmakingConfiguration_gameSessionData :: (Maybe Text -> f (Maybe Text))
-> CreateMatchmakingConfiguration
-> f CreateMatchmakingConfiguration
createMatchmakingConfiguration_gameSessionData = (CreateMatchmakingConfiguration -> Maybe Text)
-> (CreateMatchmakingConfiguration
    -> Maybe Text -> CreateMatchmakingConfiguration)
-> Lens
     CreateMatchmakingConfiguration
     CreateMatchmakingConfiguration
     (Maybe Text)
     (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateMatchmakingConfiguration' {Maybe Text
gameSessionData :: Maybe Text
$sel:gameSessionData:CreateMatchmakingConfiguration' :: CreateMatchmakingConfiguration -> Maybe Text
gameSessionData} -> Maybe Text
gameSessionData) (\s :: CreateMatchmakingConfiguration
s@CreateMatchmakingConfiguration' {} Maybe Text
a -> CreateMatchmakingConfiguration
s {$sel:gameSessionData:CreateMatchmakingConfiguration' :: Maybe Text
gameSessionData = Maybe Text
a} :: CreateMatchmakingConfiguration)

-- | A human-readable description of the matchmaking configuration.
createMatchmakingConfiguration_description :: Lens.Lens' CreateMatchmakingConfiguration (Prelude.Maybe Prelude.Text)
createMatchmakingConfiguration_description :: (Maybe Text -> f (Maybe Text))
-> CreateMatchmakingConfiguration
-> f CreateMatchmakingConfiguration
createMatchmakingConfiguration_description = (CreateMatchmakingConfiguration -> Maybe Text)
-> (CreateMatchmakingConfiguration
    -> Maybe Text -> CreateMatchmakingConfiguration)
-> Lens
     CreateMatchmakingConfiguration
     CreateMatchmakingConfiguration
     (Maybe Text)
     (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateMatchmakingConfiguration' {Maybe Text
description :: Maybe Text
$sel:description:CreateMatchmakingConfiguration' :: CreateMatchmakingConfiguration -> Maybe Text
description} -> Maybe Text
description) (\s :: CreateMatchmakingConfiguration
s@CreateMatchmakingConfiguration' {} Maybe Text
a -> CreateMatchmakingConfiguration
s {$sel:description:CreateMatchmakingConfiguration' :: Maybe Text
description = Maybe Text
a} :: CreateMatchmakingConfiguration)

-- | A list of labels to assign to the new matchmaking configuration
-- resource. Tags are developer-defined key-value pairs. Tagging AWS
-- resources are useful for resource management, access management and cost
-- allocation. For more information, see
-- <https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html Tagging AWS Resources>
-- in the /AWS General Reference/. Once the resource is created, you can
-- use TagResource, UntagResource, and ListTagsForResource to add, remove,
-- and view tags. The maximum tag limit may be lower than stated. See the
-- AWS General Reference for actual tagging limits.
createMatchmakingConfiguration_tags :: Lens.Lens' CreateMatchmakingConfiguration (Prelude.Maybe [Tag])
createMatchmakingConfiguration_tags :: (Maybe [Tag] -> f (Maybe [Tag]))
-> CreateMatchmakingConfiguration
-> f CreateMatchmakingConfiguration
createMatchmakingConfiguration_tags = (CreateMatchmakingConfiguration -> Maybe [Tag])
-> (CreateMatchmakingConfiguration
    -> Maybe [Tag] -> CreateMatchmakingConfiguration)
-> Lens
     CreateMatchmakingConfiguration
     CreateMatchmakingConfiguration
     (Maybe [Tag])
     (Maybe [Tag])
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateMatchmakingConfiguration' {Maybe [Tag]
tags :: Maybe [Tag]
$sel:tags:CreateMatchmakingConfiguration' :: CreateMatchmakingConfiguration -> Maybe [Tag]
tags} -> Maybe [Tag]
tags) (\s :: CreateMatchmakingConfiguration
s@CreateMatchmakingConfiguration' {} Maybe [Tag]
a -> CreateMatchmakingConfiguration
s {$sel:tags:CreateMatchmakingConfiguration' :: Maybe [Tag]
tags = Maybe [Tag]
a} :: CreateMatchmakingConfiguration) ((Maybe [Tag] -> f (Maybe [Tag]))
 -> CreateMatchmakingConfiguration
 -> f CreateMatchmakingConfiguration)
-> ((Maybe [Tag] -> f (Maybe [Tag]))
    -> Maybe [Tag] -> f (Maybe [Tag]))
-> (Maybe [Tag] -> f (Maybe [Tag]))
-> CreateMatchmakingConfiguration
-> f CreateMatchmakingConfiguration
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso [Tag] [Tag] [Tag] [Tag]
-> Iso (Maybe [Tag]) (Maybe [Tag]) (Maybe [Tag]) (Maybe [Tag])
forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping AnIso [Tag] [Tag] [Tag] [Tag]
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The number of player slots in a match to keep open for future players.
-- For example, if the configuration\'s rule set specifies a match for a
-- single 12-person team, and the additional player count is set to 2, only
-- 10 players are selected for the match. This parameter is not used if
-- @FlexMatchMode@ is set to @STANDALONE@.
createMatchmakingConfiguration_additionalPlayerCount :: Lens.Lens' CreateMatchmakingConfiguration (Prelude.Maybe Prelude.Natural)
createMatchmakingConfiguration_additionalPlayerCount :: (Maybe Natural -> f (Maybe Natural))
-> CreateMatchmakingConfiguration
-> f CreateMatchmakingConfiguration
createMatchmakingConfiguration_additionalPlayerCount = (CreateMatchmakingConfiguration -> Maybe Natural)
-> (CreateMatchmakingConfiguration
    -> Maybe Natural -> CreateMatchmakingConfiguration)
-> Lens
     CreateMatchmakingConfiguration
     CreateMatchmakingConfiguration
     (Maybe Natural)
     (Maybe Natural)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateMatchmakingConfiguration' {Maybe Natural
additionalPlayerCount :: Maybe Natural
$sel:additionalPlayerCount:CreateMatchmakingConfiguration' :: CreateMatchmakingConfiguration -> Maybe Natural
additionalPlayerCount} -> Maybe Natural
additionalPlayerCount) (\s :: CreateMatchmakingConfiguration
s@CreateMatchmakingConfiguration' {} Maybe Natural
a -> CreateMatchmakingConfiguration
s {$sel:additionalPlayerCount:CreateMatchmakingConfiguration' :: Maybe Natural
additionalPlayerCount = Maybe Natural
a} :: CreateMatchmakingConfiguration)

-- | A unique identifier for the matchmaking configuration. This name is used
-- to identify the configuration associated with a matchmaking request or
-- ticket.
createMatchmakingConfiguration_name :: Lens.Lens' CreateMatchmakingConfiguration Prelude.Text
createMatchmakingConfiguration_name :: (Text -> f Text)
-> CreateMatchmakingConfiguration
-> f CreateMatchmakingConfiguration
createMatchmakingConfiguration_name = (CreateMatchmakingConfiguration -> Text)
-> (CreateMatchmakingConfiguration
    -> Text -> CreateMatchmakingConfiguration)
-> Lens
     CreateMatchmakingConfiguration
     CreateMatchmakingConfiguration
     Text
     Text
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateMatchmakingConfiguration' {Text
name :: Text
$sel:name:CreateMatchmakingConfiguration' :: CreateMatchmakingConfiguration -> Text
name} -> Text
name) (\s :: CreateMatchmakingConfiguration
s@CreateMatchmakingConfiguration' {} Text
a -> CreateMatchmakingConfiguration
s {$sel:name:CreateMatchmakingConfiguration' :: Text
name = Text
a} :: CreateMatchmakingConfiguration)

-- | The maximum duration, in seconds, that a matchmaking ticket can remain
-- in process before timing out. Requests that fail due to timing out can
-- be resubmitted as needed.
createMatchmakingConfiguration_requestTimeoutSeconds :: Lens.Lens' CreateMatchmakingConfiguration Prelude.Natural
createMatchmakingConfiguration_requestTimeoutSeconds :: (Natural -> f Natural)
-> CreateMatchmakingConfiguration
-> f CreateMatchmakingConfiguration
createMatchmakingConfiguration_requestTimeoutSeconds = (CreateMatchmakingConfiguration -> Natural)
-> (CreateMatchmakingConfiguration
    -> Natural -> CreateMatchmakingConfiguration)
-> Lens
     CreateMatchmakingConfiguration
     CreateMatchmakingConfiguration
     Natural
     Natural
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateMatchmakingConfiguration' {Natural
requestTimeoutSeconds :: Natural
$sel:requestTimeoutSeconds:CreateMatchmakingConfiguration' :: CreateMatchmakingConfiguration -> Natural
requestTimeoutSeconds} -> Natural
requestTimeoutSeconds) (\s :: CreateMatchmakingConfiguration
s@CreateMatchmakingConfiguration' {} Natural
a -> CreateMatchmakingConfiguration
s {$sel:requestTimeoutSeconds:CreateMatchmakingConfiguration' :: Natural
requestTimeoutSeconds = Natural
a} :: CreateMatchmakingConfiguration)

-- | A flag that determines whether a match that was created with this
-- configuration must be accepted by the matched players. To require
-- acceptance, set to @TRUE@. With this option enabled, matchmaking tickets
-- use the status @REQUIRES_ACCEPTANCE@ to indicate when a completed
-- potential match is waiting for player acceptance.
createMatchmakingConfiguration_acceptanceRequired :: Lens.Lens' CreateMatchmakingConfiguration Prelude.Bool
createMatchmakingConfiguration_acceptanceRequired :: (Bool -> f Bool)
-> CreateMatchmakingConfiguration
-> f CreateMatchmakingConfiguration
createMatchmakingConfiguration_acceptanceRequired = (CreateMatchmakingConfiguration -> Bool)
-> (CreateMatchmakingConfiguration
    -> Bool -> CreateMatchmakingConfiguration)
-> Lens
     CreateMatchmakingConfiguration
     CreateMatchmakingConfiguration
     Bool
     Bool
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateMatchmakingConfiguration' {Bool
acceptanceRequired :: Bool
$sel:acceptanceRequired:CreateMatchmakingConfiguration' :: CreateMatchmakingConfiguration -> Bool
acceptanceRequired} -> Bool
acceptanceRequired) (\s :: CreateMatchmakingConfiguration
s@CreateMatchmakingConfiguration' {} Bool
a -> CreateMatchmakingConfiguration
s {$sel:acceptanceRequired:CreateMatchmakingConfiguration' :: Bool
acceptanceRequired = Bool
a} :: CreateMatchmakingConfiguration)

-- | A unique identifier for the matchmaking rule set to use with this
-- configuration. You can use either the rule set name or ARN value. A
-- matchmaking configuration can only use rule sets that are defined in the
-- same Region.
createMatchmakingConfiguration_ruleSetName :: Lens.Lens' CreateMatchmakingConfiguration Prelude.Text
createMatchmakingConfiguration_ruleSetName :: (Text -> f Text)
-> CreateMatchmakingConfiguration
-> f CreateMatchmakingConfiguration
createMatchmakingConfiguration_ruleSetName = (CreateMatchmakingConfiguration -> Text)
-> (CreateMatchmakingConfiguration
    -> Text -> CreateMatchmakingConfiguration)
-> Lens
     CreateMatchmakingConfiguration
     CreateMatchmakingConfiguration
     Text
     Text
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateMatchmakingConfiguration' {Text
ruleSetName :: Text
$sel:ruleSetName:CreateMatchmakingConfiguration' :: CreateMatchmakingConfiguration -> Text
ruleSetName} -> Text
ruleSetName) (\s :: CreateMatchmakingConfiguration
s@CreateMatchmakingConfiguration' {} Text
a -> CreateMatchmakingConfiguration
s {$sel:ruleSetName:CreateMatchmakingConfiguration' :: Text
ruleSetName = Text
a} :: CreateMatchmakingConfiguration)

instance
  Core.AWSRequest
    CreateMatchmakingConfiguration
  where
  type
    AWSResponse CreateMatchmakingConfiguration =
      CreateMatchmakingConfigurationResponse
  request :: CreateMatchmakingConfiguration
-> Request CreateMatchmakingConfiguration
request = Service
-> CreateMatchmakingConfiguration
-> Request CreateMatchmakingConfiguration
forall a. (ToRequest a, ToJSON a) => Service -> a -> Request a
Request.postJSON Service
defaultService
  response :: Logger
-> Service
-> Proxy CreateMatchmakingConfiguration
-> ClientResponse ClientBody
-> m (Either
        Error
        (ClientResponse (AWSResponse CreateMatchmakingConfiguration)))
response =
    (Int
 -> ResponseHeaders
 -> Object
 -> Either String (AWSResponse CreateMatchmakingConfiguration))
-> Logger
-> Service
-> Proxy CreateMatchmakingConfiguration
-> ClientResponse ClientBody
-> m (Either
        Error
        (ClientResponse (AWSResponse CreateMatchmakingConfiguration)))
forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> Object -> Either String (AWSResponse a))
-> Logger
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveJSON
      ( \Int
s ResponseHeaders
h Object
x ->
          Maybe MatchmakingConfiguration
-> Int -> CreateMatchmakingConfigurationResponse
CreateMatchmakingConfigurationResponse'
            (Maybe MatchmakingConfiguration
 -> Int -> CreateMatchmakingConfigurationResponse)
-> Either String (Maybe MatchmakingConfiguration)
-> Either String (Int -> CreateMatchmakingConfigurationResponse)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x Object -> Text -> Either String (Maybe MatchmakingConfiguration)
forall a. FromJSON a => Object -> Text -> Either String (Maybe a)
Core..?> Text
"Configuration")
            Either String (Int -> CreateMatchmakingConfigurationResponse)
-> Either String Int
-> Either String CreateMatchmakingConfigurationResponse
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Int -> Either String Int
forall (f :: * -> *) a. Applicative f => a -> f a
Prelude.pure (Int -> Int
forall a. Enum a => a -> Int
Prelude.fromEnum Int
s))
      )

instance
  Prelude.Hashable
    CreateMatchmakingConfiguration

instance
  Prelude.NFData
    CreateMatchmakingConfiguration

instance
  Core.ToHeaders
    CreateMatchmakingConfiguration
  where
  toHeaders :: CreateMatchmakingConfiguration -> ResponseHeaders
toHeaders =
    ResponseHeaders
-> CreateMatchmakingConfiguration -> ResponseHeaders
forall a b. a -> b -> a
Prelude.const
      ( [ResponseHeaders] -> ResponseHeaders
forall a. Monoid a => [a] -> a
Prelude.mconcat
          [ HeaderName
"X-Amz-Target"
              HeaderName -> ByteString -> ResponseHeaders
forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Core.=# ( ByteString
"GameLift.CreateMatchmakingConfiguration" ::
                          Prelude.ByteString
                      ),
            HeaderName
"Content-Type"
              HeaderName -> ByteString -> ResponseHeaders
forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Core.=# ( ByteString
"application/x-amz-json-1.1" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Core.ToJSON CreateMatchmakingConfiguration where
  toJSON :: CreateMatchmakingConfiguration -> Value
toJSON CreateMatchmakingConfiguration' {Bool
Natural
Maybe Natural
Maybe [Text]
Maybe [GameProperty]
Maybe [Tag]
Maybe Text
Maybe BackfillMode
Maybe FlexMatchMode
Text
ruleSetName :: Text
acceptanceRequired :: Bool
requestTimeoutSeconds :: Natural
name :: Text
additionalPlayerCount :: Maybe Natural
tags :: Maybe [Tag]
description :: Maybe Text
gameSessionData :: Maybe Text
customEventData :: Maybe Text
gameSessionQueueArns :: Maybe [Text]
flexMatchMode :: Maybe FlexMatchMode
notificationTarget :: Maybe Text
acceptanceTimeoutSeconds :: Maybe Natural
gameProperties :: Maybe [GameProperty]
backfillMode :: Maybe BackfillMode
$sel:ruleSetName:CreateMatchmakingConfiguration' :: CreateMatchmakingConfiguration -> Text
$sel:acceptanceRequired:CreateMatchmakingConfiguration' :: CreateMatchmakingConfiguration -> Bool
$sel:requestTimeoutSeconds:CreateMatchmakingConfiguration' :: CreateMatchmakingConfiguration -> Natural
$sel:name:CreateMatchmakingConfiguration' :: CreateMatchmakingConfiguration -> Text
$sel:additionalPlayerCount:CreateMatchmakingConfiguration' :: CreateMatchmakingConfiguration -> Maybe Natural
$sel:tags:CreateMatchmakingConfiguration' :: CreateMatchmakingConfiguration -> Maybe [Tag]
$sel:description:CreateMatchmakingConfiguration' :: CreateMatchmakingConfiguration -> Maybe Text
$sel:gameSessionData:CreateMatchmakingConfiguration' :: CreateMatchmakingConfiguration -> Maybe Text
$sel:customEventData:CreateMatchmakingConfiguration' :: CreateMatchmakingConfiguration -> Maybe Text
$sel:gameSessionQueueArns:CreateMatchmakingConfiguration' :: CreateMatchmakingConfiguration -> Maybe [Text]
$sel:flexMatchMode:CreateMatchmakingConfiguration' :: CreateMatchmakingConfiguration -> Maybe FlexMatchMode
$sel:notificationTarget:CreateMatchmakingConfiguration' :: CreateMatchmakingConfiguration -> Maybe Text
$sel:acceptanceTimeoutSeconds:CreateMatchmakingConfiguration' :: CreateMatchmakingConfiguration -> Maybe Natural
$sel:gameProperties:CreateMatchmakingConfiguration' :: CreateMatchmakingConfiguration -> Maybe [GameProperty]
$sel:backfillMode:CreateMatchmakingConfiguration' :: CreateMatchmakingConfiguration -> Maybe BackfillMode
..} =
    [Pair] -> Value
Core.object
      ( [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Text
"BackfillMode" Text -> BackfillMode -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (BackfillMode -> Pair) -> Maybe BackfillMode -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe BackfillMode
backfillMode,
            (Text
"GameProperties" Text -> [GameProperty] -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              ([GameProperty] -> Pair) -> Maybe [GameProperty] -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe [GameProperty]
gameProperties,
            (Text
"AcceptanceTimeoutSeconds" Text -> Natural -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Natural -> Pair) -> Maybe Natural -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Natural
acceptanceTimeoutSeconds,
            (Text
"NotificationTarget" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
notificationTarget,
            (Text
"FlexMatchMode" Text -> FlexMatchMode -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (FlexMatchMode -> Pair) -> Maybe FlexMatchMode -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe FlexMatchMode
flexMatchMode,
            (Text
"GameSessionQueueArns" Text -> [Text] -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              ([Text] -> Pair) -> Maybe [Text] -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe [Text]
gameSessionQueueArns,
            (Text
"CustomEventData" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
customEventData,
            (Text
"GameSessionData" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
gameSessionData,
            (Text
"Description" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
description,
            (Text
"Tags" Text -> [Tag] -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) ([Tag] -> Pair) -> Maybe [Tag] -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe [Tag]
tags,
            (Text
"AdditionalPlayerCount" Text -> Natural -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Natural -> Pair) -> Maybe Natural -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Natural
additionalPlayerCount,
            Pair -> Maybe Pair
forall a. a -> Maybe a
Prelude.Just (Text
"Name" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..= Text
name),
            Pair -> Maybe Pair
forall a. a -> Maybe a
Prelude.Just
              ( Text
"RequestTimeoutSeconds"
                  Text -> Natural -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..= Natural
requestTimeoutSeconds
              ),
            Pair -> Maybe Pair
forall a. a -> Maybe a
Prelude.Just
              (Text
"AcceptanceRequired" Text -> Bool -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..= Bool
acceptanceRequired),
            Pair -> Maybe Pair
forall a. a -> Maybe a
Prelude.Just (Text
"RuleSetName" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..= Text
ruleSetName)
          ]
      )

instance Core.ToPath CreateMatchmakingConfiguration where
  toPath :: CreateMatchmakingConfiguration -> ByteString
toPath = ByteString -> CreateMatchmakingConfiguration -> ByteString
forall a b. a -> b -> a
Prelude.const ByteString
"/"

instance Core.ToQuery CreateMatchmakingConfiguration where
  toQuery :: CreateMatchmakingConfiguration -> QueryString
toQuery = QueryString -> CreateMatchmakingConfiguration -> QueryString
forall a b. a -> b -> a
Prelude.const QueryString
forall a. Monoid a => a
Prelude.mempty

-- | Represents the returned data in response to a request operation.
--
-- /See:/ 'newCreateMatchmakingConfigurationResponse' smart constructor.
data CreateMatchmakingConfigurationResponse = CreateMatchmakingConfigurationResponse'
  { -- | Object that describes the newly created matchmaking configuration.
    CreateMatchmakingConfigurationResponse
-> Maybe MatchmakingConfiguration
configuration :: Prelude.Maybe MatchmakingConfiguration,
    -- | The response's http status code.
    CreateMatchmakingConfigurationResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (CreateMatchmakingConfigurationResponse
-> CreateMatchmakingConfigurationResponse -> Bool
(CreateMatchmakingConfigurationResponse
 -> CreateMatchmakingConfigurationResponse -> Bool)
-> (CreateMatchmakingConfigurationResponse
    -> CreateMatchmakingConfigurationResponse -> Bool)
-> Eq CreateMatchmakingConfigurationResponse
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateMatchmakingConfigurationResponse
-> CreateMatchmakingConfigurationResponse -> Bool
$c/= :: CreateMatchmakingConfigurationResponse
-> CreateMatchmakingConfigurationResponse -> Bool
== :: CreateMatchmakingConfigurationResponse
-> CreateMatchmakingConfigurationResponse -> Bool
$c== :: CreateMatchmakingConfigurationResponse
-> CreateMatchmakingConfigurationResponse -> Bool
Prelude.Eq, ReadPrec [CreateMatchmakingConfigurationResponse]
ReadPrec CreateMatchmakingConfigurationResponse
Int -> ReadS CreateMatchmakingConfigurationResponse
ReadS [CreateMatchmakingConfigurationResponse]
(Int -> ReadS CreateMatchmakingConfigurationResponse)
-> ReadS [CreateMatchmakingConfigurationResponse]
-> ReadPrec CreateMatchmakingConfigurationResponse
-> ReadPrec [CreateMatchmakingConfigurationResponse]
-> Read CreateMatchmakingConfigurationResponse
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateMatchmakingConfigurationResponse]
$creadListPrec :: ReadPrec [CreateMatchmakingConfigurationResponse]
readPrec :: ReadPrec CreateMatchmakingConfigurationResponse
$creadPrec :: ReadPrec CreateMatchmakingConfigurationResponse
readList :: ReadS [CreateMatchmakingConfigurationResponse]
$creadList :: ReadS [CreateMatchmakingConfigurationResponse]
readsPrec :: Int -> ReadS CreateMatchmakingConfigurationResponse
$creadsPrec :: Int -> ReadS CreateMatchmakingConfigurationResponse
Prelude.Read, Int -> CreateMatchmakingConfigurationResponse -> ShowS
[CreateMatchmakingConfigurationResponse] -> ShowS
CreateMatchmakingConfigurationResponse -> String
(Int -> CreateMatchmakingConfigurationResponse -> ShowS)
-> (CreateMatchmakingConfigurationResponse -> String)
-> ([CreateMatchmakingConfigurationResponse] -> ShowS)
-> Show CreateMatchmakingConfigurationResponse
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateMatchmakingConfigurationResponse] -> ShowS
$cshowList :: [CreateMatchmakingConfigurationResponse] -> ShowS
show :: CreateMatchmakingConfigurationResponse -> String
$cshow :: CreateMatchmakingConfigurationResponse -> String
showsPrec :: Int -> CreateMatchmakingConfigurationResponse -> ShowS
$cshowsPrec :: Int -> CreateMatchmakingConfigurationResponse -> ShowS
Prelude.Show, (forall x.
 CreateMatchmakingConfigurationResponse
 -> Rep CreateMatchmakingConfigurationResponse x)
-> (forall x.
    Rep CreateMatchmakingConfigurationResponse x
    -> CreateMatchmakingConfigurationResponse)
-> Generic CreateMatchmakingConfigurationResponse
forall x.
Rep CreateMatchmakingConfigurationResponse x
-> CreateMatchmakingConfigurationResponse
forall x.
CreateMatchmakingConfigurationResponse
-> Rep CreateMatchmakingConfigurationResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep CreateMatchmakingConfigurationResponse x
-> CreateMatchmakingConfigurationResponse
$cfrom :: forall x.
CreateMatchmakingConfigurationResponse
-> Rep CreateMatchmakingConfigurationResponse x
Prelude.Generic)

-- |
-- Create a value of 'CreateMatchmakingConfigurationResponse' with all optional fields omitted.
--
-- Use <https://hackage.haskell.org/package/generic-lens generic-lens> or <https://hackage.haskell.org/package/optics optics> to modify other optional fields.
--
-- The following record fields are available, with the corresponding lenses provided
-- for backwards compatibility:
--
-- 'configuration', 'createMatchmakingConfigurationResponse_configuration' - Object that describes the newly created matchmaking configuration.
--
-- 'httpStatus', 'createMatchmakingConfigurationResponse_httpStatus' - The response's http status code.
newCreateMatchmakingConfigurationResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  CreateMatchmakingConfigurationResponse
newCreateMatchmakingConfigurationResponse :: Int -> CreateMatchmakingConfigurationResponse
newCreateMatchmakingConfigurationResponse
  Int
pHttpStatus_ =
    CreateMatchmakingConfigurationResponse' :: Maybe MatchmakingConfiguration
-> Int -> CreateMatchmakingConfigurationResponse
CreateMatchmakingConfigurationResponse'
      { $sel:configuration:CreateMatchmakingConfigurationResponse' :: Maybe MatchmakingConfiguration
configuration =
          Maybe MatchmakingConfiguration
forall a. Maybe a
Prelude.Nothing,
        $sel:httpStatus:CreateMatchmakingConfigurationResponse' :: Int
httpStatus = Int
pHttpStatus_
      }

-- | Object that describes the newly created matchmaking configuration.
createMatchmakingConfigurationResponse_configuration :: Lens.Lens' CreateMatchmakingConfigurationResponse (Prelude.Maybe MatchmakingConfiguration)
createMatchmakingConfigurationResponse_configuration :: (Maybe MatchmakingConfiguration
 -> f (Maybe MatchmakingConfiguration))
-> CreateMatchmakingConfigurationResponse
-> f CreateMatchmakingConfigurationResponse
createMatchmakingConfigurationResponse_configuration = (CreateMatchmakingConfigurationResponse
 -> Maybe MatchmakingConfiguration)
-> (CreateMatchmakingConfigurationResponse
    -> Maybe MatchmakingConfiguration
    -> CreateMatchmakingConfigurationResponse)
-> Lens
     CreateMatchmakingConfigurationResponse
     CreateMatchmakingConfigurationResponse
     (Maybe MatchmakingConfiguration)
     (Maybe MatchmakingConfiguration)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateMatchmakingConfigurationResponse' {Maybe MatchmakingConfiguration
configuration :: Maybe MatchmakingConfiguration
$sel:configuration:CreateMatchmakingConfigurationResponse' :: CreateMatchmakingConfigurationResponse
-> Maybe MatchmakingConfiguration
configuration} -> Maybe MatchmakingConfiguration
configuration) (\s :: CreateMatchmakingConfigurationResponse
s@CreateMatchmakingConfigurationResponse' {} Maybe MatchmakingConfiguration
a -> CreateMatchmakingConfigurationResponse
s {$sel:configuration:CreateMatchmakingConfigurationResponse' :: Maybe MatchmakingConfiguration
configuration = Maybe MatchmakingConfiguration
a} :: CreateMatchmakingConfigurationResponse)

-- | The response's http status code.
createMatchmakingConfigurationResponse_httpStatus :: Lens.Lens' CreateMatchmakingConfigurationResponse Prelude.Int
createMatchmakingConfigurationResponse_httpStatus :: (Int -> f Int)
-> CreateMatchmakingConfigurationResponse
-> f CreateMatchmakingConfigurationResponse
createMatchmakingConfigurationResponse_httpStatus = (CreateMatchmakingConfigurationResponse -> Int)
-> (CreateMatchmakingConfigurationResponse
    -> Int -> CreateMatchmakingConfigurationResponse)
-> Lens
     CreateMatchmakingConfigurationResponse
     CreateMatchmakingConfigurationResponse
     Int
     Int
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateMatchmakingConfigurationResponse' {Int
httpStatus :: Int
$sel:httpStatus:CreateMatchmakingConfigurationResponse' :: CreateMatchmakingConfigurationResponse -> Int
httpStatus} -> Int
httpStatus) (\s :: CreateMatchmakingConfigurationResponse
s@CreateMatchmakingConfigurationResponse' {} Int
a -> CreateMatchmakingConfigurationResponse
s {$sel:httpStatus:CreateMatchmakingConfigurationResponse' :: Int
httpStatus = Int
a} :: CreateMatchmakingConfigurationResponse)

instance
  Prelude.NFData
    CreateMatchmakingConfigurationResponse