{-# 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.KinesisVideo.CreateSignalingChannel
-- 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 signaling channel.
--
-- @CreateSignalingChannel@ is an asynchronous operation.
module Amazonka.KinesisVideo.CreateSignalingChannel
  ( -- * Creating a Request
    CreateSignalingChannel (..),
    newCreateSignalingChannel,

    -- * Request Lenses
    createSignalingChannel_channelType,
    createSignalingChannel_singleMasterConfiguration,
    createSignalingChannel_tags,
    createSignalingChannel_channelName,

    -- * Destructuring the Response
    CreateSignalingChannelResponse (..),
    newCreateSignalingChannelResponse,

    -- * Response Lenses
    createSignalingChannelResponse_channelARN,
    createSignalingChannelResponse_httpStatus,
  )
where

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

-- | /See:/ 'newCreateSignalingChannel' smart constructor.
data CreateSignalingChannel = CreateSignalingChannel'
  { -- | A type of the signaling channel that you are creating. Currently,
    -- @SINGLE_MASTER@ is the only supported channel type.
    CreateSignalingChannel -> Maybe ChannelType
channelType :: Prelude.Maybe ChannelType,
    -- | A structure containing the configuration for the @SINGLE_MASTER@ channel
    -- type.
    CreateSignalingChannel -> Maybe SingleMasterConfiguration
singleMasterConfiguration :: Prelude.Maybe SingleMasterConfiguration,
    -- | A set of tags (key-value pairs) that you want to associate with this
    -- channel.
    CreateSignalingChannel -> Maybe [Tag]
tags :: Prelude.Maybe [Tag],
    -- | A name for the signaling channel that you are creating. It must be
    -- unique for each Amazon Web Services account and Amazon Web Services
    -- Region.
    CreateSignalingChannel -> Text
channelName :: Prelude.Text
  }
  deriving (CreateSignalingChannel -> CreateSignalingChannel -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateSignalingChannel -> CreateSignalingChannel -> Bool
$c/= :: CreateSignalingChannel -> CreateSignalingChannel -> Bool
== :: CreateSignalingChannel -> CreateSignalingChannel -> Bool
$c== :: CreateSignalingChannel -> CreateSignalingChannel -> Bool
Prelude.Eq, ReadPrec [CreateSignalingChannel]
ReadPrec CreateSignalingChannel
Int -> ReadS CreateSignalingChannel
ReadS [CreateSignalingChannel]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateSignalingChannel]
$creadListPrec :: ReadPrec [CreateSignalingChannel]
readPrec :: ReadPrec CreateSignalingChannel
$creadPrec :: ReadPrec CreateSignalingChannel
readList :: ReadS [CreateSignalingChannel]
$creadList :: ReadS [CreateSignalingChannel]
readsPrec :: Int -> ReadS CreateSignalingChannel
$creadsPrec :: Int -> ReadS CreateSignalingChannel
Prelude.Read, Int -> CreateSignalingChannel -> ShowS
[CreateSignalingChannel] -> ShowS
CreateSignalingChannel -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateSignalingChannel] -> ShowS
$cshowList :: [CreateSignalingChannel] -> ShowS
show :: CreateSignalingChannel -> String
$cshow :: CreateSignalingChannel -> String
showsPrec :: Int -> CreateSignalingChannel -> ShowS
$cshowsPrec :: Int -> CreateSignalingChannel -> ShowS
Prelude.Show, forall x. Rep CreateSignalingChannel x -> CreateSignalingChannel
forall x. CreateSignalingChannel -> Rep CreateSignalingChannel x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateSignalingChannel x -> CreateSignalingChannel
$cfrom :: forall x. CreateSignalingChannel -> Rep CreateSignalingChannel x
Prelude.Generic)

-- |
-- Create a value of 'CreateSignalingChannel' 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:
--
-- 'channelType', 'createSignalingChannel_channelType' - A type of the signaling channel that you are creating. Currently,
-- @SINGLE_MASTER@ is the only supported channel type.
--
-- 'singleMasterConfiguration', 'createSignalingChannel_singleMasterConfiguration' - A structure containing the configuration for the @SINGLE_MASTER@ channel
-- type.
--
-- 'tags', 'createSignalingChannel_tags' - A set of tags (key-value pairs) that you want to associate with this
-- channel.
--
-- 'channelName', 'createSignalingChannel_channelName' - A name for the signaling channel that you are creating. It must be
-- unique for each Amazon Web Services account and Amazon Web Services
-- Region.
newCreateSignalingChannel ::
  -- | 'channelName'
  Prelude.Text ->
  CreateSignalingChannel
newCreateSignalingChannel :: Text -> CreateSignalingChannel
newCreateSignalingChannel Text
pChannelName_ =
  CreateSignalingChannel'
    { $sel:channelType:CreateSignalingChannel' :: Maybe ChannelType
channelType =
        forall a. Maybe a
Prelude.Nothing,
      $sel:singleMasterConfiguration:CreateSignalingChannel' :: Maybe SingleMasterConfiguration
singleMasterConfiguration = forall a. Maybe a
Prelude.Nothing,
      $sel:tags:CreateSignalingChannel' :: Maybe [Tag]
tags = forall a. Maybe a
Prelude.Nothing,
      $sel:channelName:CreateSignalingChannel' :: Text
channelName = Text
pChannelName_
    }

-- | A type of the signaling channel that you are creating. Currently,
-- @SINGLE_MASTER@ is the only supported channel type.
createSignalingChannel_channelType :: Lens.Lens' CreateSignalingChannel (Prelude.Maybe ChannelType)
createSignalingChannel_channelType :: Lens' CreateSignalingChannel (Maybe ChannelType)
createSignalingChannel_channelType = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateSignalingChannel' {Maybe ChannelType
channelType :: Maybe ChannelType
$sel:channelType:CreateSignalingChannel' :: CreateSignalingChannel -> Maybe ChannelType
channelType} -> Maybe ChannelType
channelType) (\s :: CreateSignalingChannel
s@CreateSignalingChannel' {} Maybe ChannelType
a -> CreateSignalingChannel
s {$sel:channelType:CreateSignalingChannel' :: Maybe ChannelType
channelType = Maybe ChannelType
a} :: CreateSignalingChannel)

-- | A structure containing the configuration for the @SINGLE_MASTER@ channel
-- type.
createSignalingChannel_singleMasterConfiguration :: Lens.Lens' CreateSignalingChannel (Prelude.Maybe SingleMasterConfiguration)
createSignalingChannel_singleMasterConfiguration :: Lens' CreateSignalingChannel (Maybe SingleMasterConfiguration)
createSignalingChannel_singleMasterConfiguration = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateSignalingChannel' {Maybe SingleMasterConfiguration
singleMasterConfiguration :: Maybe SingleMasterConfiguration
$sel:singleMasterConfiguration:CreateSignalingChannel' :: CreateSignalingChannel -> Maybe SingleMasterConfiguration
singleMasterConfiguration} -> Maybe SingleMasterConfiguration
singleMasterConfiguration) (\s :: CreateSignalingChannel
s@CreateSignalingChannel' {} Maybe SingleMasterConfiguration
a -> CreateSignalingChannel
s {$sel:singleMasterConfiguration:CreateSignalingChannel' :: Maybe SingleMasterConfiguration
singleMasterConfiguration = Maybe SingleMasterConfiguration
a} :: CreateSignalingChannel)

-- | A set of tags (key-value pairs) that you want to associate with this
-- channel.
createSignalingChannel_tags :: Lens.Lens' CreateSignalingChannel (Prelude.Maybe [Tag])
createSignalingChannel_tags :: Lens' CreateSignalingChannel (Maybe [Tag])
createSignalingChannel_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateSignalingChannel' {Maybe [Tag]
tags :: Maybe [Tag]
$sel:tags:CreateSignalingChannel' :: CreateSignalingChannel -> Maybe [Tag]
tags} -> Maybe [Tag]
tags) (\s :: CreateSignalingChannel
s@CreateSignalingChannel' {} Maybe [Tag]
a -> CreateSignalingChannel
s {$sel:tags:CreateSignalingChannel' :: Maybe [Tag]
tags = Maybe [Tag]
a} :: CreateSignalingChannel) 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 s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | A name for the signaling channel that you are creating. It must be
-- unique for each Amazon Web Services account and Amazon Web Services
-- Region.
createSignalingChannel_channelName :: Lens.Lens' CreateSignalingChannel Prelude.Text
createSignalingChannel_channelName :: Lens' CreateSignalingChannel Text
createSignalingChannel_channelName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateSignalingChannel' {Text
channelName :: Text
$sel:channelName:CreateSignalingChannel' :: CreateSignalingChannel -> Text
channelName} -> Text
channelName) (\s :: CreateSignalingChannel
s@CreateSignalingChannel' {} Text
a -> CreateSignalingChannel
s {$sel:channelName:CreateSignalingChannel' :: Text
channelName = Text
a} :: CreateSignalingChannel)

instance Core.AWSRequest CreateSignalingChannel where
  type
    AWSResponse CreateSignalingChannel =
      CreateSignalingChannelResponse
  request :: (Service -> Service)
-> CreateSignalingChannel -> Request CreateSignalingChannel
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 CreateSignalingChannel
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse CreateSignalingChannel)))
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 Text -> Int -> CreateSignalingChannelResponse
CreateSignalingChannelResponse'
            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
"ChannelARN")
            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 CreateSignalingChannel where
  hashWithSalt :: Int -> CreateSignalingChannel -> Int
hashWithSalt Int
_salt CreateSignalingChannel' {Maybe [Tag]
Maybe ChannelType
Maybe SingleMasterConfiguration
Text
channelName :: Text
tags :: Maybe [Tag]
singleMasterConfiguration :: Maybe SingleMasterConfiguration
channelType :: Maybe ChannelType
$sel:channelName:CreateSignalingChannel' :: CreateSignalingChannel -> Text
$sel:tags:CreateSignalingChannel' :: CreateSignalingChannel -> Maybe [Tag]
$sel:singleMasterConfiguration:CreateSignalingChannel' :: CreateSignalingChannel -> Maybe SingleMasterConfiguration
$sel:channelType:CreateSignalingChannel' :: CreateSignalingChannel -> Maybe ChannelType
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe ChannelType
channelType
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe SingleMasterConfiguration
singleMasterConfiguration
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Tag]
tags
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
channelName

instance Prelude.NFData CreateSignalingChannel where
  rnf :: CreateSignalingChannel -> ()
rnf CreateSignalingChannel' {Maybe [Tag]
Maybe ChannelType
Maybe SingleMasterConfiguration
Text
channelName :: Text
tags :: Maybe [Tag]
singleMasterConfiguration :: Maybe SingleMasterConfiguration
channelType :: Maybe ChannelType
$sel:channelName:CreateSignalingChannel' :: CreateSignalingChannel -> Text
$sel:tags:CreateSignalingChannel' :: CreateSignalingChannel -> Maybe [Tag]
$sel:singleMasterConfiguration:CreateSignalingChannel' :: CreateSignalingChannel -> Maybe SingleMasterConfiguration
$sel:channelType:CreateSignalingChannel' :: CreateSignalingChannel -> Maybe ChannelType
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe ChannelType
channelType
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe SingleMasterConfiguration
singleMasterConfiguration
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Tag]
tags
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
channelName

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

instance Data.ToJSON CreateSignalingChannel where
  toJSON :: CreateSignalingChannel -> Value
toJSON CreateSignalingChannel' {Maybe [Tag]
Maybe ChannelType
Maybe SingleMasterConfiguration
Text
channelName :: Text
tags :: Maybe [Tag]
singleMasterConfiguration :: Maybe SingleMasterConfiguration
channelType :: Maybe ChannelType
$sel:channelName:CreateSignalingChannel' :: CreateSignalingChannel -> Text
$sel:tags:CreateSignalingChannel' :: CreateSignalingChannel -> Maybe [Tag]
$sel:singleMasterConfiguration:CreateSignalingChannel' :: CreateSignalingChannel -> Maybe SingleMasterConfiguration
$sel:channelType:CreateSignalingChannel' :: CreateSignalingChannel -> Maybe ChannelType
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"ChannelType" 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 ChannelType
channelType,
            (Key
"SingleMasterConfiguration" 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 SingleMasterConfiguration
singleMasterConfiguration,
            (Key
"Tags" 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 [Tag]
tags,
            forall a. a -> Maybe a
Prelude.Just (Key
"ChannelName" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
channelName)
          ]
      )

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

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

-- | /See:/ 'newCreateSignalingChannelResponse' smart constructor.
data CreateSignalingChannelResponse = CreateSignalingChannelResponse'
  { -- | The Amazon Resource Name (ARN) of the created channel.
    CreateSignalingChannelResponse -> Maybe Text
channelARN :: Prelude.Maybe Prelude.Text,
    -- | The response's http status code.
    CreateSignalingChannelResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (CreateSignalingChannelResponse
-> CreateSignalingChannelResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateSignalingChannelResponse
-> CreateSignalingChannelResponse -> Bool
$c/= :: CreateSignalingChannelResponse
-> CreateSignalingChannelResponse -> Bool
== :: CreateSignalingChannelResponse
-> CreateSignalingChannelResponse -> Bool
$c== :: CreateSignalingChannelResponse
-> CreateSignalingChannelResponse -> Bool
Prelude.Eq, ReadPrec [CreateSignalingChannelResponse]
ReadPrec CreateSignalingChannelResponse
Int -> ReadS CreateSignalingChannelResponse
ReadS [CreateSignalingChannelResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateSignalingChannelResponse]
$creadListPrec :: ReadPrec [CreateSignalingChannelResponse]
readPrec :: ReadPrec CreateSignalingChannelResponse
$creadPrec :: ReadPrec CreateSignalingChannelResponse
readList :: ReadS [CreateSignalingChannelResponse]
$creadList :: ReadS [CreateSignalingChannelResponse]
readsPrec :: Int -> ReadS CreateSignalingChannelResponse
$creadsPrec :: Int -> ReadS CreateSignalingChannelResponse
Prelude.Read, Int -> CreateSignalingChannelResponse -> ShowS
[CreateSignalingChannelResponse] -> ShowS
CreateSignalingChannelResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateSignalingChannelResponse] -> ShowS
$cshowList :: [CreateSignalingChannelResponse] -> ShowS
show :: CreateSignalingChannelResponse -> String
$cshow :: CreateSignalingChannelResponse -> String
showsPrec :: Int -> CreateSignalingChannelResponse -> ShowS
$cshowsPrec :: Int -> CreateSignalingChannelResponse -> ShowS
Prelude.Show, forall x.
Rep CreateSignalingChannelResponse x
-> CreateSignalingChannelResponse
forall x.
CreateSignalingChannelResponse
-> Rep CreateSignalingChannelResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep CreateSignalingChannelResponse x
-> CreateSignalingChannelResponse
$cfrom :: forall x.
CreateSignalingChannelResponse
-> Rep CreateSignalingChannelResponse x
Prelude.Generic)

-- |
-- Create a value of 'CreateSignalingChannelResponse' 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:
--
-- 'channelARN', 'createSignalingChannelResponse_channelARN' - The Amazon Resource Name (ARN) of the created channel.
--
-- 'httpStatus', 'createSignalingChannelResponse_httpStatus' - The response's http status code.
newCreateSignalingChannelResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  CreateSignalingChannelResponse
newCreateSignalingChannelResponse :: Int -> CreateSignalingChannelResponse
newCreateSignalingChannelResponse Int
pHttpStatus_ =
  CreateSignalingChannelResponse'
    { $sel:channelARN:CreateSignalingChannelResponse' :: Maybe Text
channelARN =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:CreateSignalingChannelResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The Amazon Resource Name (ARN) of the created channel.
createSignalingChannelResponse_channelARN :: Lens.Lens' CreateSignalingChannelResponse (Prelude.Maybe Prelude.Text)
createSignalingChannelResponse_channelARN :: Lens' CreateSignalingChannelResponse (Maybe Text)
createSignalingChannelResponse_channelARN = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateSignalingChannelResponse' {Maybe Text
channelARN :: Maybe Text
$sel:channelARN:CreateSignalingChannelResponse' :: CreateSignalingChannelResponse -> Maybe Text
channelARN} -> Maybe Text
channelARN) (\s :: CreateSignalingChannelResponse
s@CreateSignalingChannelResponse' {} Maybe Text
a -> CreateSignalingChannelResponse
s {$sel:channelARN:CreateSignalingChannelResponse' :: Maybe Text
channelARN = Maybe Text
a} :: CreateSignalingChannelResponse)

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

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