{-# 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.AlexaBusiness.RegisterAVSDevice
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Registers an Alexa-enabled device built by an Original Equipment
-- Manufacturer (OEM) using Alexa Voice Service (AVS).
module Amazonka.AlexaBusiness.RegisterAVSDevice
  ( -- * Creating a Request
    RegisterAVSDevice (..),
    newRegisterAVSDevice,

    -- * Request Lenses
    registerAVSDevice_deviceSerialNumber,
    registerAVSDevice_roomArn,
    registerAVSDevice_tags,
    registerAVSDevice_clientId,
    registerAVSDevice_userCode,
    registerAVSDevice_productId,
    registerAVSDevice_amazonId,

    -- * Destructuring the Response
    RegisterAVSDeviceResponse (..),
    newRegisterAVSDeviceResponse,

    -- * Response Lenses
    registerAVSDeviceResponse_deviceArn,
    registerAVSDeviceResponse_httpStatus,
  )
where

import Amazonka.AlexaBusiness.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:/ 'newRegisterAVSDevice' smart constructor.
data RegisterAVSDevice = RegisterAVSDevice'
  { -- | The key generated by the OEM that uniquely identifies a specified
    -- instance of your AVS device.
    RegisterAVSDevice -> Maybe Text
deviceSerialNumber :: Prelude.Maybe Prelude.Text,
    -- | The Amazon Resource Name (ARN) of the room with which to associate your
    -- AVS device.
    RegisterAVSDevice -> Maybe Text
roomArn :: Prelude.Maybe Prelude.Text,
    -- | The tags to be added to the specified resource. Do not provide system
    -- tags.
    RegisterAVSDevice -> Maybe [Tag]
tags :: Prelude.Maybe [Tag],
    -- | The client ID of the OEM used for code-based linking authorization on an
    -- AVS device.
    RegisterAVSDevice -> Text
clientId :: Prelude.Text,
    -- | The code that is obtained after your AVS device has made a POST request
    -- to LWA as a part of the Device Authorization Request component of the
    -- OAuth code-based linking specification.
    RegisterAVSDevice -> Text
userCode :: Prelude.Text,
    -- | The product ID used to identify your AVS device during authorization.
    RegisterAVSDevice -> Text
productId :: Prelude.Text,
    -- | The device type ID for your AVS device generated by Amazon when the OEM
    -- creates a new product on Amazon\'s Developer Console.
    RegisterAVSDevice -> Text
amazonId :: Prelude.Text
  }
  deriving (RegisterAVSDevice -> RegisterAVSDevice -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RegisterAVSDevice -> RegisterAVSDevice -> Bool
$c/= :: RegisterAVSDevice -> RegisterAVSDevice -> Bool
== :: RegisterAVSDevice -> RegisterAVSDevice -> Bool
$c== :: RegisterAVSDevice -> RegisterAVSDevice -> Bool
Prelude.Eq, ReadPrec [RegisterAVSDevice]
ReadPrec RegisterAVSDevice
Int -> ReadS RegisterAVSDevice
ReadS [RegisterAVSDevice]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [RegisterAVSDevice]
$creadListPrec :: ReadPrec [RegisterAVSDevice]
readPrec :: ReadPrec RegisterAVSDevice
$creadPrec :: ReadPrec RegisterAVSDevice
readList :: ReadS [RegisterAVSDevice]
$creadList :: ReadS [RegisterAVSDevice]
readsPrec :: Int -> ReadS RegisterAVSDevice
$creadsPrec :: Int -> ReadS RegisterAVSDevice
Prelude.Read, Int -> RegisterAVSDevice -> ShowS
[RegisterAVSDevice] -> ShowS
RegisterAVSDevice -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RegisterAVSDevice] -> ShowS
$cshowList :: [RegisterAVSDevice] -> ShowS
show :: RegisterAVSDevice -> String
$cshow :: RegisterAVSDevice -> String
showsPrec :: Int -> RegisterAVSDevice -> ShowS
$cshowsPrec :: Int -> RegisterAVSDevice -> ShowS
Prelude.Show, forall x. Rep RegisterAVSDevice x -> RegisterAVSDevice
forall x. RegisterAVSDevice -> Rep RegisterAVSDevice x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep RegisterAVSDevice x -> RegisterAVSDevice
$cfrom :: forall x. RegisterAVSDevice -> Rep RegisterAVSDevice x
Prelude.Generic)

-- |
-- Create a value of 'RegisterAVSDevice' 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:
--
-- 'deviceSerialNumber', 'registerAVSDevice_deviceSerialNumber' - The key generated by the OEM that uniquely identifies a specified
-- instance of your AVS device.
--
-- 'roomArn', 'registerAVSDevice_roomArn' - The Amazon Resource Name (ARN) of the room with which to associate your
-- AVS device.
--
-- 'tags', 'registerAVSDevice_tags' - The tags to be added to the specified resource. Do not provide system
-- tags.
--
-- 'clientId', 'registerAVSDevice_clientId' - The client ID of the OEM used for code-based linking authorization on an
-- AVS device.
--
-- 'userCode', 'registerAVSDevice_userCode' - The code that is obtained after your AVS device has made a POST request
-- to LWA as a part of the Device Authorization Request component of the
-- OAuth code-based linking specification.
--
-- 'productId', 'registerAVSDevice_productId' - The product ID used to identify your AVS device during authorization.
--
-- 'amazonId', 'registerAVSDevice_amazonId' - The device type ID for your AVS device generated by Amazon when the OEM
-- creates a new product on Amazon\'s Developer Console.
newRegisterAVSDevice ::
  -- | 'clientId'
  Prelude.Text ->
  -- | 'userCode'
  Prelude.Text ->
  -- | 'productId'
  Prelude.Text ->
  -- | 'amazonId'
  Prelude.Text ->
  RegisterAVSDevice
newRegisterAVSDevice :: Text -> Text -> Text -> Text -> RegisterAVSDevice
newRegisterAVSDevice
  Text
pClientId_
  Text
pUserCode_
  Text
pProductId_
  Text
pAmazonId_ =
    RegisterAVSDevice'
      { $sel:deviceSerialNumber:RegisterAVSDevice' :: Maybe Text
deviceSerialNumber =
          forall a. Maybe a
Prelude.Nothing,
        $sel:roomArn:RegisterAVSDevice' :: Maybe Text
roomArn = forall a. Maybe a
Prelude.Nothing,
        $sel:tags:RegisterAVSDevice' :: Maybe [Tag]
tags = forall a. Maybe a
Prelude.Nothing,
        $sel:clientId:RegisterAVSDevice' :: Text
clientId = Text
pClientId_,
        $sel:userCode:RegisterAVSDevice' :: Text
userCode = Text
pUserCode_,
        $sel:productId:RegisterAVSDevice' :: Text
productId = Text
pProductId_,
        $sel:amazonId:RegisterAVSDevice' :: Text
amazonId = Text
pAmazonId_
      }

-- | The key generated by the OEM that uniquely identifies a specified
-- instance of your AVS device.
registerAVSDevice_deviceSerialNumber :: Lens.Lens' RegisterAVSDevice (Prelude.Maybe Prelude.Text)
registerAVSDevice_deviceSerialNumber :: Lens' RegisterAVSDevice (Maybe Text)
registerAVSDevice_deviceSerialNumber = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RegisterAVSDevice' {Maybe Text
deviceSerialNumber :: Maybe Text
$sel:deviceSerialNumber:RegisterAVSDevice' :: RegisterAVSDevice -> Maybe Text
deviceSerialNumber} -> Maybe Text
deviceSerialNumber) (\s :: RegisterAVSDevice
s@RegisterAVSDevice' {} Maybe Text
a -> RegisterAVSDevice
s {$sel:deviceSerialNumber:RegisterAVSDevice' :: Maybe Text
deviceSerialNumber = Maybe Text
a} :: RegisterAVSDevice)

-- | The Amazon Resource Name (ARN) of the room with which to associate your
-- AVS device.
registerAVSDevice_roomArn :: Lens.Lens' RegisterAVSDevice (Prelude.Maybe Prelude.Text)
registerAVSDevice_roomArn :: Lens' RegisterAVSDevice (Maybe Text)
registerAVSDevice_roomArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RegisterAVSDevice' {Maybe Text
roomArn :: Maybe Text
$sel:roomArn:RegisterAVSDevice' :: RegisterAVSDevice -> Maybe Text
roomArn} -> Maybe Text
roomArn) (\s :: RegisterAVSDevice
s@RegisterAVSDevice' {} Maybe Text
a -> RegisterAVSDevice
s {$sel:roomArn:RegisterAVSDevice' :: Maybe Text
roomArn = Maybe Text
a} :: RegisterAVSDevice)

-- | The tags to be added to the specified resource. Do not provide system
-- tags.
registerAVSDevice_tags :: Lens.Lens' RegisterAVSDevice (Prelude.Maybe [Tag])
registerAVSDevice_tags :: Lens' RegisterAVSDevice (Maybe [Tag])
registerAVSDevice_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RegisterAVSDevice' {Maybe [Tag]
tags :: Maybe [Tag]
$sel:tags:RegisterAVSDevice' :: RegisterAVSDevice -> Maybe [Tag]
tags} -> Maybe [Tag]
tags) (\s :: RegisterAVSDevice
s@RegisterAVSDevice' {} Maybe [Tag]
a -> RegisterAVSDevice
s {$sel:tags:RegisterAVSDevice' :: Maybe [Tag]
tags = Maybe [Tag]
a} :: RegisterAVSDevice) 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

-- | The client ID of the OEM used for code-based linking authorization on an
-- AVS device.
registerAVSDevice_clientId :: Lens.Lens' RegisterAVSDevice Prelude.Text
registerAVSDevice_clientId :: Lens' RegisterAVSDevice Text
registerAVSDevice_clientId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RegisterAVSDevice' {Text
clientId :: Text
$sel:clientId:RegisterAVSDevice' :: RegisterAVSDevice -> Text
clientId} -> Text
clientId) (\s :: RegisterAVSDevice
s@RegisterAVSDevice' {} Text
a -> RegisterAVSDevice
s {$sel:clientId:RegisterAVSDevice' :: Text
clientId = Text
a} :: RegisterAVSDevice)

-- | The code that is obtained after your AVS device has made a POST request
-- to LWA as a part of the Device Authorization Request component of the
-- OAuth code-based linking specification.
registerAVSDevice_userCode :: Lens.Lens' RegisterAVSDevice Prelude.Text
registerAVSDevice_userCode :: Lens' RegisterAVSDevice Text
registerAVSDevice_userCode = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RegisterAVSDevice' {Text
userCode :: Text
$sel:userCode:RegisterAVSDevice' :: RegisterAVSDevice -> Text
userCode} -> Text
userCode) (\s :: RegisterAVSDevice
s@RegisterAVSDevice' {} Text
a -> RegisterAVSDevice
s {$sel:userCode:RegisterAVSDevice' :: Text
userCode = Text
a} :: RegisterAVSDevice)

-- | The product ID used to identify your AVS device during authorization.
registerAVSDevice_productId :: Lens.Lens' RegisterAVSDevice Prelude.Text
registerAVSDevice_productId :: Lens' RegisterAVSDevice Text
registerAVSDevice_productId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RegisterAVSDevice' {Text
productId :: Text
$sel:productId:RegisterAVSDevice' :: RegisterAVSDevice -> Text
productId} -> Text
productId) (\s :: RegisterAVSDevice
s@RegisterAVSDevice' {} Text
a -> RegisterAVSDevice
s {$sel:productId:RegisterAVSDevice' :: Text
productId = Text
a} :: RegisterAVSDevice)

-- | The device type ID for your AVS device generated by Amazon when the OEM
-- creates a new product on Amazon\'s Developer Console.
registerAVSDevice_amazonId :: Lens.Lens' RegisterAVSDevice Prelude.Text
registerAVSDevice_amazonId :: Lens' RegisterAVSDevice Text
registerAVSDevice_amazonId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RegisterAVSDevice' {Text
amazonId :: Text
$sel:amazonId:RegisterAVSDevice' :: RegisterAVSDevice -> Text
amazonId} -> Text
amazonId) (\s :: RegisterAVSDevice
s@RegisterAVSDevice' {} Text
a -> RegisterAVSDevice
s {$sel:amazonId:RegisterAVSDevice' :: Text
amazonId = Text
a} :: RegisterAVSDevice)

instance Core.AWSRequest RegisterAVSDevice where
  type
    AWSResponse RegisterAVSDevice =
      RegisterAVSDeviceResponse
  request :: (Service -> Service)
-> RegisterAVSDevice -> Request RegisterAVSDevice
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 RegisterAVSDevice
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse RegisterAVSDevice)))
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 -> RegisterAVSDeviceResponse
RegisterAVSDeviceResponse'
            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
"DeviceArn")
            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 RegisterAVSDevice where
  hashWithSalt :: Int -> RegisterAVSDevice -> Int
hashWithSalt Int
_salt RegisterAVSDevice' {Maybe [Tag]
Maybe Text
Text
amazonId :: Text
productId :: Text
userCode :: Text
clientId :: Text
tags :: Maybe [Tag]
roomArn :: Maybe Text
deviceSerialNumber :: Maybe Text
$sel:amazonId:RegisterAVSDevice' :: RegisterAVSDevice -> Text
$sel:productId:RegisterAVSDevice' :: RegisterAVSDevice -> Text
$sel:userCode:RegisterAVSDevice' :: RegisterAVSDevice -> Text
$sel:clientId:RegisterAVSDevice' :: RegisterAVSDevice -> Text
$sel:tags:RegisterAVSDevice' :: RegisterAVSDevice -> Maybe [Tag]
$sel:roomArn:RegisterAVSDevice' :: RegisterAVSDevice -> Maybe Text
$sel:deviceSerialNumber:RegisterAVSDevice' :: RegisterAVSDevice -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
deviceSerialNumber
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
roomArn
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Tag]
tags
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
clientId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
userCode
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
productId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
amazonId

instance Prelude.NFData RegisterAVSDevice where
  rnf :: RegisterAVSDevice -> ()
rnf RegisterAVSDevice' {Maybe [Tag]
Maybe Text
Text
amazonId :: Text
productId :: Text
userCode :: Text
clientId :: Text
tags :: Maybe [Tag]
roomArn :: Maybe Text
deviceSerialNumber :: Maybe Text
$sel:amazonId:RegisterAVSDevice' :: RegisterAVSDevice -> Text
$sel:productId:RegisterAVSDevice' :: RegisterAVSDevice -> Text
$sel:userCode:RegisterAVSDevice' :: RegisterAVSDevice -> Text
$sel:clientId:RegisterAVSDevice' :: RegisterAVSDevice -> Text
$sel:tags:RegisterAVSDevice' :: RegisterAVSDevice -> Maybe [Tag]
$sel:roomArn:RegisterAVSDevice' :: RegisterAVSDevice -> Maybe Text
$sel:deviceSerialNumber:RegisterAVSDevice' :: RegisterAVSDevice -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
deviceSerialNumber
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
roomArn
      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
clientId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
userCode
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
productId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
amazonId

instance Data.ToHeaders RegisterAVSDevice where
  toHeaders :: RegisterAVSDevice -> ResponseHeaders
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 -> ResponseHeaders
Data.=# ( ByteString
"AlexaForBusiness.RegisterAVSDevice" ::
                          Prelude.ByteString
                      ),
            HeaderName
"Content-Type"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"application/x-amz-json-1.1" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Data.ToJSON RegisterAVSDevice where
  toJSON :: RegisterAVSDevice -> Value
toJSON RegisterAVSDevice' {Maybe [Tag]
Maybe Text
Text
amazonId :: Text
productId :: Text
userCode :: Text
clientId :: Text
tags :: Maybe [Tag]
roomArn :: Maybe Text
deviceSerialNumber :: Maybe Text
$sel:amazonId:RegisterAVSDevice' :: RegisterAVSDevice -> Text
$sel:productId:RegisterAVSDevice' :: RegisterAVSDevice -> Text
$sel:userCode:RegisterAVSDevice' :: RegisterAVSDevice -> Text
$sel:clientId:RegisterAVSDevice' :: RegisterAVSDevice -> Text
$sel:tags:RegisterAVSDevice' :: RegisterAVSDevice -> Maybe [Tag]
$sel:roomArn:RegisterAVSDevice' :: RegisterAVSDevice -> Maybe Text
$sel:deviceSerialNumber:RegisterAVSDevice' :: RegisterAVSDevice -> Maybe Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"DeviceSerialNumber" 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 Text
deviceSerialNumber,
            (Key
"RoomArn" 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 Text
roomArn,
            (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
"ClientId" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
clientId),
            forall a. a -> Maybe a
Prelude.Just (Key
"UserCode" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
userCode),
            forall a. a -> Maybe a
Prelude.Just (Key
"ProductId" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
productId),
            forall a. a -> Maybe a
Prelude.Just (Key
"AmazonId" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
amazonId)
          ]
      )

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

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

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

-- |
-- Create a value of 'RegisterAVSDeviceResponse' 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:
--
-- 'deviceArn', 'registerAVSDeviceResponse_deviceArn' - The ARN of the device.
--
-- 'httpStatus', 'registerAVSDeviceResponse_httpStatus' - The response's http status code.
newRegisterAVSDeviceResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  RegisterAVSDeviceResponse
newRegisterAVSDeviceResponse :: Int -> RegisterAVSDeviceResponse
newRegisterAVSDeviceResponse Int
pHttpStatus_ =
  RegisterAVSDeviceResponse'
    { $sel:deviceArn:RegisterAVSDeviceResponse' :: Maybe Text
deviceArn =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:RegisterAVSDeviceResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The ARN of the device.
registerAVSDeviceResponse_deviceArn :: Lens.Lens' RegisterAVSDeviceResponse (Prelude.Maybe Prelude.Text)
registerAVSDeviceResponse_deviceArn :: Lens' RegisterAVSDeviceResponse (Maybe Text)
registerAVSDeviceResponse_deviceArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RegisterAVSDeviceResponse' {Maybe Text
deviceArn :: Maybe Text
$sel:deviceArn:RegisterAVSDeviceResponse' :: RegisterAVSDeviceResponse -> Maybe Text
deviceArn} -> Maybe Text
deviceArn) (\s :: RegisterAVSDeviceResponse
s@RegisterAVSDeviceResponse' {} Maybe Text
a -> RegisterAVSDeviceResponse
s {$sel:deviceArn:RegisterAVSDeviceResponse' :: Maybe Text
deviceArn = Maybe Text
a} :: RegisterAVSDeviceResponse)

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

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