{-# 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.Chime.CreateRoom
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Creates a chat room for the specified Amazon Chime Enterprise account.
module Amazonka.Chime.CreateRoom
  ( -- * Creating a Request
    CreateRoom (..),
    newCreateRoom,

    -- * Request Lenses
    createRoom_clientRequestToken,
    createRoom_accountId,
    createRoom_name,

    -- * Destructuring the Response
    CreateRoomResponse (..),
    newCreateRoomResponse,

    -- * Response Lenses
    createRoomResponse_room,
    createRoomResponse_httpStatus,
  )
where

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

-- | /See:/ 'newCreateRoom' smart constructor.
data CreateRoom = CreateRoom'
  { -- | The idempotency token for the request.
    CreateRoom -> Maybe (Sensitive Text)
clientRequestToken :: Prelude.Maybe (Data.Sensitive Prelude.Text),
    -- | The Amazon Chime account ID.
    CreateRoom -> Text
accountId :: Prelude.Text,
    -- | The room name.
    CreateRoom -> Sensitive Text
name :: Data.Sensitive Prelude.Text
  }
  deriving (CreateRoom -> CreateRoom -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateRoom -> CreateRoom -> Bool
$c/= :: CreateRoom -> CreateRoom -> Bool
== :: CreateRoom -> CreateRoom -> Bool
$c== :: CreateRoom -> CreateRoom -> Bool
Prelude.Eq, Int -> CreateRoom -> ShowS
[CreateRoom] -> ShowS
CreateRoom -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateRoom] -> ShowS
$cshowList :: [CreateRoom] -> ShowS
show :: CreateRoom -> String
$cshow :: CreateRoom -> String
showsPrec :: Int -> CreateRoom -> ShowS
$cshowsPrec :: Int -> CreateRoom -> ShowS
Prelude.Show, forall x. Rep CreateRoom x -> CreateRoom
forall x. CreateRoom -> Rep CreateRoom x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateRoom x -> CreateRoom
$cfrom :: forall x. CreateRoom -> Rep CreateRoom x
Prelude.Generic)

-- |
-- Create a value of 'CreateRoom' 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:
--
-- 'clientRequestToken', 'createRoom_clientRequestToken' - The idempotency token for the request.
--
-- 'accountId', 'createRoom_accountId' - The Amazon Chime account ID.
--
-- 'name', 'createRoom_name' - The room name.
newCreateRoom ::
  -- | 'accountId'
  Prelude.Text ->
  -- | 'name'
  Prelude.Text ->
  CreateRoom
newCreateRoom :: Text -> Text -> CreateRoom
newCreateRoom Text
pAccountId_ Text
pName_ =
  CreateRoom'
    { $sel:clientRequestToken:CreateRoom' :: Maybe (Sensitive Text)
clientRequestToken = forall a. Maybe a
Prelude.Nothing,
      $sel:accountId:CreateRoom' :: Text
accountId = Text
pAccountId_,
      $sel:name:CreateRoom' :: Sensitive Text
name = forall a. Iso' (Sensitive a) a
Data._Sensitive forall t b. AReview t b -> b -> t
Lens.# Text
pName_
    }

-- | The idempotency token for the request.
createRoom_clientRequestToken :: Lens.Lens' CreateRoom (Prelude.Maybe Prelude.Text)
createRoom_clientRequestToken :: Lens' CreateRoom (Maybe Text)
createRoom_clientRequestToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateRoom' {Maybe (Sensitive Text)
clientRequestToken :: Maybe (Sensitive Text)
$sel:clientRequestToken:CreateRoom' :: CreateRoom -> Maybe (Sensitive Text)
clientRequestToken} -> Maybe (Sensitive Text)
clientRequestToken) (\s :: CreateRoom
s@CreateRoom' {} Maybe (Sensitive Text)
a -> CreateRoom
s {$sel:clientRequestToken:CreateRoom' :: Maybe (Sensitive Text)
clientRequestToken = Maybe (Sensitive Text)
a} :: CreateRoom) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. 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 forall a. Iso' (Sensitive a) a
Data._Sensitive

-- | The Amazon Chime account ID.
createRoom_accountId :: Lens.Lens' CreateRoom Prelude.Text
createRoom_accountId :: Lens' CreateRoom Text
createRoom_accountId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateRoom' {Text
accountId :: Text
$sel:accountId:CreateRoom' :: CreateRoom -> Text
accountId} -> Text
accountId) (\s :: CreateRoom
s@CreateRoom' {} Text
a -> CreateRoom
s {$sel:accountId:CreateRoom' :: Text
accountId = Text
a} :: CreateRoom)

-- | The room name.
createRoom_name :: Lens.Lens' CreateRoom Prelude.Text
createRoom_name :: Lens' CreateRoom Text
createRoom_name = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateRoom' {Sensitive Text
name :: Sensitive Text
$sel:name:CreateRoom' :: CreateRoom -> Sensitive Text
name} -> Sensitive Text
name) (\s :: CreateRoom
s@CreateRoom' {} Sensitive Text
a -> CreateRoom
s {$sel:name:CreateRoom' :: Sensitive Text
name = Sensitive Text
a} :: CreateRoom) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall a. Iso' (Sensitive a) a
Data._Sensitive

instance Core.AWSRequest CreateRoom where
  type AWSResponse CreateRoom = CreateRoomResponse
  request :: (Service -> Service) -> CreateRoom -> Request CreateRoom
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 CreateRoom
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse CreateRoom)))
response =
    forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> Object -> Either String (AWSResponse a))
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveJSON
      ( \Int
s ResponseHeaders
h Object
x ->
          Maybe Room -> Int -> CreateRoomResponse
CreateRoomResponse'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"Room")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (forall (f :: * -> *) a. Applicative f => a -> f a
Prelude.pure (forall a. Enum a => a -> Int
Prelude.fromEnum Int
s))
      )

instance Prelude.Hashable CreateRoom where
  hashWithSalt :: Int -> CreateRoom -> Int
hashWithSalt Int
_salt CreateRoom' {Maybe (Sensitive Text)
Text
Sensitive Text
name :: Sensitive Text
accountId :: Text
clientRequestToken :: Maybe (Sensitive Text)
$sel:name:CreateRoom' :: CreateRoom -> Sensitive Text
$sel:accountId:CreateRoom' :: CreateRoom -> Text
$sel:clientRequestToken:CreateRoom' :: CreateRoom -> Maybe (Sensitive Text)
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (Sensitive Text)
clientRequestToken
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
accountId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Sensitive Text
name

instance Prelude.NFData CreateRoom where
  rnf :: CreateRoom -> ()
rnf CreateRoom' {Maybe (Sensitive Text)
Text
Sensitive Text
name :: Sensitive Text
accountId :: Text
clientRequestToken :: Maybe (Sensitive Text)
$sel:name:CreateRoom' :: CreateRoom -> Sensitive Text
$sel:accountId:CreateRoom' :: CreateRoom -> Text
$sel:clientRequestToken:CreateRoom' :: CreateRoom -> Maybe (Sensitive Text)
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe (Sensitive Text)
clientRequestToken
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
accountId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Sensitive Text
name

instance Data.ToHeaders CreateRoom where
  toHeaders :: CreateRoom -> ResponseHeaders
toHeaders = forall a b. a -> b -> a
Prelude.const forall a. Monoid a => a
Prelude.mempty

instance Data.ToJSON CreateRoom where
  toJSON :: CreateRoom -> Value
toJSON CreateRoom' {Maybe (Sensitive Text)
Text
Sensitive Text
name :: Sensitive Text
accountId :: Text
clientRequestToken :: Maybe (Sensitive Text)
$sel:name:CreateRoom' :: CreateRoom -> Sensitive Text
$sel:accountId:CreateRoom' :: CreateRoom -> Text
$sel:clientRequestToken:CreateRoom' :: CreateRoom -> Maybe (Sensitive Text)
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"ClientRequestToken" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=)
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe (Sensitive Text)
clientRequestToken,
            forall a. a -> Maybe a
Prelude.Just (Key
"Name" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Sensitive Text
name)
          ]
      )

instance Data.ToPath CreateRoom where
  toPath :: CreateRoom -> ByteString
toPath CreateRoom' {Maybe (Sensitive Text)
Text
Sensitive Text
name :: Sensitive Text
accountId :: Text
clientRequestToken :: Maybe (Sensitive Text)
$sel:name:CreateRoom' :: CreateRoom -> Sensitive Text
$sel:accountId:CreateRoom' :: CreateRoom -> Text
$sel:clientRequestToken:CreateRoom' :: CreateRoom -> Maybe (Sensitive Text)
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ByteString
"/accounts/", forall a. ToByteString a => a -> ByteString
Data.toBS Text
accountId, ByteString
"/rooms"]

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

-- | /See:/ 'newCreateRoomResponse' smart constructor.
data CreateRoomResponse = CreateRoomResponse'
  { -- | The room details.
    CreateRoomResponse -> Maybe Room
room :: Prelude.Maybe Room,
    -- | The response's http status code.
    CreateRoomResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (CreateRoomResponse -> CreateRoomResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateRoomResponse -> CreateRoomResponse -> Bool
$c/= :: CreateRoomResponse -> CreateRoomResponse -> Bool
== :: CreateRoomResponse -> CreateRoomResponse -> Bool
$c== :: CreateRoomResponse -> CreateRoomResponse -> Bool
Prelude.Eq, Int -> CreateRoomResponse -> ShowS
[CreateRoomResponse] -> ShowS
CreateRoomResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateRoomResponse] -> ShowS
$cshowList :: [CreateRoomResponse] -> ShowS
show :: CreateRoomResponse -> String
$cshow :: CreateRoomResponse -> String
showsPrec :: Int -> CreateRoomResponse -> ShowS
$cshowsPrec :: Int -> CreateRoomResponse -> ShowS
Prelude.Show, forall x. Rep CreateRoomResponse x -> CreateRoomResponse
forall x. CreateRoomResponse -> Rep CreateRoomResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateRoomResponse x -> CreateRoomResponse
$cfrom :: forall x. CreateRoomResponse -> Rep CreateRoomResponse x
Prelude.Generic)

-- |
-- Create a value of 'CreateRoomResponse' 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:
--
-- 'room', 'createRoomResponse_room' - The room details.
--
-- 'httpStatus', 'createRoomResponse_httpStatus' - The response's http status code.
newCreateRoomResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  CreateRoomResponse
newCreateRoomResponse :: Int -> CreateRoomResponse
newCreateRoomResponse Int
pHttpStatus_ =
  CreateRoomResponse'
    { $sel:room:CreateRoomResponse' :: Maybe Room
room = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:CreateRoomResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The room details.
createRoomResponse_room :: Lens.Lens' CreateRoomResponse (Prelude.Maybe Room)
createRoomResponse_room :: Lens' CreateRoomResponse (Maybe Room)
createRoomResponse_room = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateRoomResponse' {Maybe Room
room :: Maybe Room
$sel:room:CreateRoomResponse' :: CreateRoomResponse -> Maybe Room
room} -> Maybe Room
room) (\s :: CreateRoomResponse
s@CreateRoomResponse' {} Maybe Room
a -> CreateRoomResponse
s {$sel:room:CreateRoomResponse' :: Maybe Room
room = Maybe Room
a} :: CreateRoomResponse)

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

instance Prelude.NFData CreateRoomResponse where
  rnf :: CreateRoomResponse -> ()
rnf CreateRoomResponse' {Int
Maybe Room
httpStatus :: Int
room :: Maybe Room
$sel:httpStatus:CreateRoomResponse' :: CreateRoomResponse -> Int
$sel:room:CreateRoomResponse' :: CreateRoomResponse -> Maybe Room
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Room
room
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus