{-# 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.DeregisterGameServer
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- __This operation is used with the GameLift FleetIQ solution and game
-- server groups.__
--
-- Removes the game server from a game server group. As a result of this
-- operation, the deregistered game server can no longer be claimed and
-- will not be returned in a list of active game servers.
--
-- To deregister a game server, specify the game server group and game
-- server ID. If successful, this operation emits a CloudWatch event with
-- termination timestamp and reason.
--
-- __Learn more__
--
-- <https://docs.aws.amazon.com/gamelift/latest/fleetiqguide/gsg-intro.html GameLift FleetIQ Guide>
module Amazonka.GameLift.DeregisterGameServer
  ( -- * Creating a Request
    DeregisterGameServer (..),
    newDeregisterGameServer,

    -- * Request Lenses
    deregisterGameServer_gameServerGroupName,
    deregisterGameServer_gameServerId,

    -- * Destructuring the Response
    DeregisterGameServerResponse (..),
    newDeregisterGameServerResponse,
  )
where

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

-- | /See:/ 'newDeregisterGameServer' smart constructor.
data DeregisterGameServer = DeregisterGameServer'
  { -- | A unique identifier for the game server group where the game server is
    -- running.
    DeregisterGameServer -> Text
gameServerGroupName :: Prelude.Text,
    -- | A custom string that uniquely identifies the game server to deregister.
    DeregisterGameServer -> Text
gameServerId :: Prelude.Text
  }
  deriving (DeregisterGameServer -> DeregisterGameServer -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DeregisterGameServer -> DeregisterGameServer -> Bool
$c/= :: DeregisterGameServer -> DeregisterGameServer -> Bool
== :: DeregisterGameServer -> DeregisterGameServer -> Bool
$c== :: DeregisterGameServer -> DeregisterGameServer -> Bool
Prelude.Eq, ReadPrec [DeregisterGameServer]
ReadPrec DeregisterGameServer
Int -> ReadS DeregisterGameServer
ReadS [DeregisterGameServer]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DeregisterGameServer]
$creadListPrec :: ReadPrec [DeregisterGameServer]
readPrec :: ReadPrec DeregisterGameServer
$creadPrec :: ReadPrec DeregisterGameServer
readList :: ReadS [DeregisterGameServer]
$creadList :: ReadS [DeregisterGameServer]
readsPrec :: Int -> ReadS DeregisterGameServer
$creadsPrec :: Int -> ReadS DeregisterGameServer
Prelude.Read, Int -> DeregisterGameServer -> ShowS
[DeregisterGameServer] -> ShowS
DeregisterGameServer -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DeregisterGameServer] -> ShowS
$cshowList :: [DeregisterGameServer] -> ShowS
show :: DeregisterGameServer -> String
$cshow :: DeregisterGameServer -> String
showsPrec :: Int -> DeregisterGameServer -> ShowS
$cshowsPrec :: Int -> DeregisterGameServer -> ShowS
Prelude.Show, forall x. Rep DeregisterGameServer x -> DeregisterGameServer
forall x. DeregisterGameServer -> Rep DeregisterGameServer x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DeregisterGameServer x -> DeregisterGameServer
$cfrom :: forall x. DeregisterGameServer -> Rep DeregisterGameServer x
Prelude.Generic)

-- |
-- Create a value of 'DeregisterGameServer' 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:
--
-- 'gameServerGroupName', 'deregisterGameServer_gameServerGroupName' - A unique identifier for the game server group where the game server is
-- running.
--
-- 'gameServerId', 'deregisterGameServer_gameServerId' - A custom string that uniquely identifies the game server to deregister.
newDeregisterGameServer ::
  -- | 'gameServerGroupName'
  Prelude.Text ->
  -- | 'gameServerId'
  Prelude.Text ->
  DeregisterGameServer
newDeregisterGameServer :: Text -> Text -> DeregisterGameServer
newDeregisterGameServer
  Text
pGameServerGroupName_
  Text
pGameServerId_ =
    DeregisterGameServer'
      { $sel:gameServerGroupName:DeregisterGameServer' :: Text
gameServerGroupName =
          Text
pGameServerGroupName_,
        $sel:gameServerId:DeregisterGameServer' :: Text
gameServerId = Text
pGameServerId_
      }

-- | A unique identifier for the game server group where the game server is
-- running.
deregisterGameServer_gameServerGroupName :: Lens.Lens' DeregisterGameServer Prelude.Text
deregisterGameServer_gameServerGroupName :: Lens' DeregisterGameServer Text
deregisterGameServer_gameServerGroupName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DeregisterGameServer' {Text
gameServerGroupName :: Text
$sel:gameServerGroupName:DeregisterGameServer' :: DeregisterGameServer -> Text
gameServerGroupName} -> Text
gameServerGroupName) (\s :: DeregisterGameServer
s@DeregisterGameServer' {} Text
a -> DeregisterGameServer
s {$sel:gameServerGroupName:DeregisterGameServer' :: Text
gameServerGroupName = Text
a} :: DeregisterGameServer)

-- | A custom string that uniquely identifies the game server to deregister.
deregisterGameServer_gameServerId :: Lens.Lens' DeregisterGameServer Prelude.Text
deregisterGameServer_gameServerId :: Lens' DeregisterGameServer Text
deregisterGameServer_gameServerId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DeregisterGameServer' {Text
gameServerId :: Text
$sel:gameServerId:DeregisterGameServer' :: DeregisterGameServer -> Text
gameServerId} -> Text
gameServerId) (\s :: DeregisterGameServer
s@DeregisterGameServer' {} Text
a -> DeregisterGameServer
s {$sel:gameServerId:DeregisterGameServer' :: Text
gameServerId = Text
a} :: DeregisterGameServer)

instance Core.AWSRequest DeregisterGameServer where
  type
    AWSResponse DeregisterGameServer =
      DeregisterGameServerResponse
  request :: (Service -> Service)
-> DeregisterGameServer -> Request DeregisterGameServer
request Service -> Service
overrides =
    forall a. (ToRequest a, ToJSON a) => Service -> a -> Request a
Request.postJSON (Service -> Service
overrides Service
defaultService)
  response :: forall (m :: * -> *).
MonadResource m =>
(ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy DeregisterGameServer
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse DeregisterGameServer)))
response =
    forall (m :: * -> *) a.
MonadResource m =>
AWSResponse a
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveNull DeregisterGameServerResponse
DeregisterGameServerResponse'

instance Prelude.Hashable DeregisterGameServer where
  hashWithSalt :: Int -> DeregisterGameServer -> Int
hashWithSalt Int
_salt DeregisterGameServer' {Text
gameServerId :: Text
gameServerGroupName :: Text
$sel:gameServerId:DeregisterGameServer' :: DeregisterGameServer -> Text
$sel:gameServerGroupName:DeregisterGameServer' :: DeregisterGameServer -> Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
gameServerGroupName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
gameServerId

instance Prelude.NFData DeregisterGameServer where
  rnf :: DeregisterGameServer -> ()
rnf DeregisterGameServer' {Text
gameServerId :: Text
gameServerGroupName :: Text
$sel:gameServerId:DeregisterGameServer' :: DeregisterGameServer -> Text
$sel:gameServerGroupName:DeregisterGameServer' :: DeregisterGameServer -> Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Text
gameServerGroupName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
gameServerId

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

instance Data.ToJSON DeregisterGameServer where
  toJSON :: DeregisterGameServer -> Value
toJSON DeregisterGameServer' {Text
gameServerId :: Text
gameServerGroupName :: Text
$sel:gameServerId:DeregisterGameServer' :: DeregisterGameServer -> Text
$sel:gameServerGroupName:DeregisterGameServer' :: DeregisterGameServer -> Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ forall a. a -> Maybe a
Prelude.Just
              (Key
"GameServerGroupName" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
gameServerGroupName),
            forall a. a -> Maybe a
Prelude.Just (Key
"GameServerId" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
gameServerId)
          ]
      )

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

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

-- | /See:/ 'newDeregisterGameServerResponse' smart constructor.
data DeregisterGameServerResponse = DeregisterGameServerResponse'
  {
  }
  deriving (DeregisterGameServerResponse
-> DeregisterGameServerResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DeregisterGameServerResponse
-> DeregisterGameServerResponse -> Bool
$c/= :: DeregisterGameServerResponse
-> DeregisterGameServerResponse -> Bool
== :: DeregisterGameServerResponse
-> DeregisterGameServerResponse -> Bool
$c== :: DeregisterGameServerResponse
-> DeregisterGameServerResponse -> Bool
Prelude.Eq, ReadPrec [DeregisterGameServerResponse]
ReadPrec DeregisterGameServerResponse
Int -> ReadS DeregisterGameServerResponse
ReadS [DeregisterGameServerResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DeregisterGameServerResponse]
$creadListPrec :: ReadPrec [DeregisterGameServerResponse]
readPrec :: ReadPrec DeregisterGameServerResponse
$creadPrec :: ReadPrec DeregisterGameServerResponse
readList :: ReadS [DeregisterGameServerResponse]
$creadList :: ReadS [DeregisterGameServerResponse]
readsPrec :: Int -> ReadS DeregisterGameServerResponse
$creadsPrec :: Int -> ReadS DeregisterGameServerResponse
Prelude.Read, Int -> DeregisterGameServerResponse -> ShowS
[DeregisterGameServerResponse] -> ShowS
DeregisterGameServerResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DeregisterGameServerResponse] -> ShowS
$cshowList :: [DeregisterGameServerResponse] -> ShowS
show :: DeregisterGameServerResponse -> String
$cshow :: DeregisterGameServerResponse -> String
showsPrec :: Int -> DeregisterGameServerResponse -> ShowS
$cshowsPrec :: Int -> DeregisterGameServerResponse -> ShowS
Prelude.Show, forall x.
Rep DeregisterGameServerResponse x -> DeregisterGameServerResponse
forall x.
DeregisterGameServerResponse -> Rep DeregisterGameServerResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep DeregisterGameServerResponse x -> DeregisterGameServerResponse
$cfrom :: forall x.
DeregisterGameServerResponse -> Rep DeregisterGameServerResponse x
Prelude.Generic)

-- |
-- Create a value of 'DeregisterGameServerResponse' 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.
newDeregisterGameServerResponse ::
  DeregisterGameServerResponse
newDeregisterGameServerResponse :: DeregisterGameServerResponse
newDeregisterGameServerResponse =
  DeregisterGameServerResponse
DeregisterGameServerResponse'

instance Prelude.NFData DeregisterGameServerResponse where
  rnf :: DeregisterGameServerResponse -> ()
rnf DeregisterGameServerResponse
_ = ()