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

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

-- |
-- Module      : Amazonka.Panorama.Types.Device
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
module Amazonka.Panorama.Types.Device where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import Amazonka.Panorama.Types.DeviceAggregatedStatus
import Amazonka.Panorama.Types.DeviceBrand
import Amazonka.Panorama.Types.DeviceStatus
import Amazonka.Panorama.Types.DeviceType
import Amazonka.Panorama.Types.LatestDeviceJob
import qualified Amazonka.Prelude as Prelude

-- | A device.
--
-- /See:/ 'newDevice' smart constructor.
data Device = Device'
  { -- | The device\'s maker.
    Device -> Maybe DeviceBrand
brand :: Prelude.Maybe DeviceBrand,
    -- | When the device was created.
    Device -> Maybe POSIX
createdTime :: Prelude.Maybe Data.POSIX,
    -- | A device\'s current software.
    Device -> Maybe Text
currentSoftware :: Prelude.Maybe Prelude.Text,
    -- | A description for the device.
    Device -> Maybe Text
description :: Prelude.Maybe Prelude.Text,
    -- | A device\'s aggregated status. Including the device\'s connection
    -- status, provisioning status, and lease status.
    Device -> Maybe DeviceAggregatedStatus
deviceAggregatedStatus :: Prelude.Maybe DeviceAggregatedStatus,
    -- | The device\'s ID.
    Device -> Maybe Text
deviceId :: Prelude.Maybe Prelude.Text,
    -- | When the device was updated.
    Device -> Maybe POSIX
lastUpdatedTime :: Prelude.Maybe Data.POSIX,
    -- | A device\'s latest job. Includes the target image version, and the
    -- update job status.
    Device -> Maybe LatestDeviceJob
latestDeviceJob :: Prelude.Maybe LatestDeviceJob,
    -- | The device\'s lease expiration time.
    Device -> Maybe POSIX
leaseExpirationTime :: Prelude.Maybe Data.POSIX,
    -- | The device\'s name.
    Device -> Maybe Text
name :: Prelude.Maybe Prelude.Text,
    -- | The device\'s provisioning status.
    Device -> Maybe DeviceStatus
provisioningStatus :: Prelude.Maybe DeviceStatus,
    -- | The device\'s tags.
    Device -> Maybe (HashMap Text Text)
tags :: Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text),
    -- | The device\'s type.
    Device -> Maybe DeviceType
type' :: Prelude.Maybe DeviceType
  }
  deriving (Device -> Device -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Device -> Device -> Bool
$c/= :: Device -> Device -> Bool
== :: Device -> Device -> Bool
$c== :: Device -> Device -> Bool
Prelude.Eq, ReadPrec [Device]
ReadPrec Device
Int -> ReadS Device
ReadS [Device]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Device]
$creadListPrec :: ReadPrec [Device]
readPrec :: ReadPrec Device
$creadPrec :: ReadPrec Device
readList :: ReadS [Device]
$creadList :: ReadS [Device]
readsPrec :: Int -> ReadS Device
$creadsPrec :: Int -> ReadS Device
Prelude.Read, Int -> Device -> ShowS
[Device] -> ShowS
Device -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Device] -> ShowS
$cshowList :: [Device] -> ShowS
show :: Device -> String
$cshow :: Device -> String
showsPrec :: Int -> Device -> ShowS
$cshowsPrec :: Int -> Device -> ShowS
Prelude.Show, forall x. Rep Device x -> Device
forall x. Device -> Rep Device x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Device x -> Device
$cfrom :: forall x. Device -> Rep Device x
Prelude.Generic)

-- |
-- Create a value of 'Device' 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:
--
-- 'brand', 'device_brand' - The device\'s maker.
--
-- 'createdTime', 'device_createdTime' - When the device was created.
--
-- 'currentSoftware', 'device_currentSoftware' - A device\'s current software.
--
-- 'description', 'device_description' - A description for the device.
--
-- 'deviceAggregatedStatus', 'device_deviceAggregatedStatus' - A device\'s aggregated status. Including the device\'s connection
-- status, provisioning status, and lease status.
--
-- 'deviceId', 'device_deviceId' - The device\'s ID.
--
-- 'lastUpdatedTime', 'device_lastUpdatedTime' - When the device was updated.
--
-- 'latestDeviceJob', 'device_latestDeviceJob' - A device\'s latest job. Includes the target image version, and the
-- update job status.
--
-- 'leaseExpirationTime', 'device_leaseExpirationTime' - The device\'s lease expiration time.
--
-- 'name', 'device_name' - The device\'s name.
--
-- 'provisioningStatus', 'device_provisioningStatus' - The device\'s provisioning status.
--
-- 'tags', 'device_tags' - The device\'s tags.
--
-- 'type'', 'device_type' - The device\'s type.
newDevice ::
  Device
newDevice :: Device
newDevice =
  Device'
    { $sel:brand:Device' :: Maybe DeviceBrand
brand = forall a. Maybe a
Prelude.Nothing,
      $sel:createdTime:Device' :: Maybe POSIX
createdTime = forall a. Maybe a
Prelude.Nothing,
      $sel:currentSoftware:Device' :: Maybe Text
currentSoftware = forall a. Maybe a
Prelude.Nothing,
      $sel:description:Device' :: Maybe Text
description = forall a. Maybe a
Prelude.Nothing,
      $sel:deviceAggregatedStatus:Device' :: Maybe DeviceAggregatedStatus
deviceAggregatedStatus = forall a. Maybe a
Prelude.Nothing,
      $sel:deviceId:Device' :: Maybe Text
deviceId = forall a. Maybe a
Prelude.Nothing,
      $sel:lastUpdatedTime:Device' :: Maybe POSIX
lastUpdatedTime = forall a. Maybe a
Prelude.Nothing,
      $sel:latestDeviceJob:Device' :: Maybe LatestDeviceJob
latestDeviceJob = forall a. Maybe a
Prelude.Nothing,
      $sel:leaseExpirationTime:Device' :: Maybe POSIX
leaseExpirationTime = forall a. Maybe a
Prelude.Nothing,
      $sel:name:Device' :: Maybe Text
name = forall a. Maybe a
Prelude.Nothing,
      $sel:provisioningStatus:Device' :: Maybe DeviceStatus
provisioningStatus = forall a. Maybe a
Prelude.Nothing,
      $sel:tags:Device' :: Maybe (HashMap Text Text)
tags = forall a. Maybe a
Prelude.Nothing,
      $sel:type':Device' :: Maybe DeviceType
type' = forall a. Maybe a
Prelude.Nothing
    }

-- | The device\'s maker.
device_brand :: Lens.Lens' Device (Prelude.Maybe DeviceBrand)
device_brand :: Lens' Device (Maybe DeviceBrand)
device_brand = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Device' {Maybe DeviceBrand
brand :: Maybe DeviceBrand
$sel:brand:Device' :: Device -> Maybe DeviceBrand
brand} -> Maybe DeviceBrand
brand) (\s :: Device
s@Device' {} Maybe DeviceBrand
a -> Device
s {$sel:brand:Device' :: Maybe DeviceBrand
brand = Maybe DeviceBrand
a} :: Device)

-- | When the device was created.
device_createdTime :: Lens.Lens' Device (Prelude.Maybe Prelude.UTCTime)
device_createdTime :: Lens' Device (Maybe UTCTime)
device_createdTime = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Device' {Maybe POSIX
createdTime :: Maybe POSIX
$sel:createdTime:Device' :: Device -> Maybe POSIX
createdTime} -> Maybe POSIX
createdTime) (\s :: Device
s@Device' {} Maybe POSIX
a -> Device
s {$sel:createdTime:Device' :: Maybe POSIX
createdTime = Maybe POSIX
a} :: Device) 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 :: Format). Iso' (Time a) UTCTime
Data._Time

-- | A device\'s current software.
device_currentSoftware :: Lens.Lens' Device (Prelude.Maybe Prelude.Text)
device_currentSoftware :: Lens' Device (Maybe Text)
device_currentSoftware = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Device' {Maybe Text
currentSoftware :: Maybe Text
$sel:currentSoftware:Device' :: Device -> Maybe Text
currentSoftware} -> Maybe Text
currentSoftware) (\s :: Device
s@Device' {} Maybe Text
a -> Device
s {$sel:currentSoftware:Device' :: Maybe Text
currentSoftware = Maybe Text
a} :: Device)

-- | A description for the device.
device_description :: Lens.Lens' Device (Prelude.Maybe Prelude.Text)
device_description :: Lens' Device (Maybe Text)
device_description = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Device' {Maybe Text
description :: Maybe Text
$sel:description:Device' :: Device -> Maybe Text
description} -> Maybe Text
description) (\s :: Device
s@Device' {} Maybe Text
a -> Device
s {$sel:description:Device' :: Maybe Text
description = Maybe Text
a} :: Device)

-- | A device\'s aggregated status. Including the device\'s connection
-- status, provisioning status, and lease status.
device_deviceAggregatedStatus :: Lens.Lens' Device (Prelude.Maybe DeviceAggregatedStatus)
device_deviceAggregatedStatus :: Lens' Device (Maybe DeviceAggregatedStatus)
device_deviceAggregatedStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Device' {Maybe DeviceAggregatedStatus
deviceAggregatedStatus :: Maybe DeviceAggregatedStatus
$sel:deviceAggregatedStatus:Device' :: Device -> Maybe DeviceAggregatedStatus
deviceAggregatedStatus} -> Maybe DeviceAggregatedStatus
deviceAggregatedStatus) (\s :: Device
s@Device' {} Maybe DeviceAggregatedStatus
a -> Device
s {$sel:deviceAggregatedStatus:Device' :: Maybe DeviceAggregatedStatus
deviceAggregatedStatus = Maybe DeviceAggregatedStatus
a} :: Device)

-- | The device\'s ID.
device_deviceId :: Lens.Lens' Device (Prelude.Maybe Prelude.Text)
device_deviceId :: Lens' Device (Maybe Text)
device_deviceId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Device' {Maybe Text
deviceId :: Maybe Text
$sel:deviceId:Device' :: Device -> Maybe Text
deviceId} -> Maybe Text
deviceId) (\s :: Device
s@Device' {} Maybe Text
a -> Device
s {$sel:deviceId:Device' :: Maybe Text
deviceId = Maybe Text
a} :: Device)

-- | When the device was updated.
device_lastUpdatedTime :: Lens.Lens' Device (Prelude.Maybe Prelude.UTCTime)
device_lastUpdatedTime :: Lens' Device (Maybe UTCTime)
device_lastUpdatedTime = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Device' {Maybe POSIX
lastUpdatedTime :: Maybe POSIX
$sel:lastUpdatedTime:Device' :: Device -> Maybe POSIX
lastUpdatedTime} -> Maybe POSIX
lastUpdatedTime) (\s :: Device
s@Device' {} Maybe POSIX
a -> Device
s {$sel:lastUpdatedTime:Device' :: Maybe POSIX
lastUpdatedTime = Maybe POSIX
a} :: Device) 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 :: Format). Iso' (Time a) UTCTime
Data._Time

-- | A device\'s latest job. Includes the target image version, and the
-- update job status.
device_latestDeviceJob :: Lens.Lens' Device (Prelude.Maybe LatestDeviceJob)
device_latestDeviceJob :: Lens' Device (Maybe LatestDeviceJob)
device_latestDeviceJob = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Device' {Maybe LatestDeviceJob
latestDeviceJob :: Maybe LatestDeviceJob
$sel:latestDeviceJob:Device' :: Device -> Maybe LatestDeviceJob
latestDeviceJob} -> Maybe LatestDeviceJob
latestDeviceJob) (\s :: Device
s@Device' {} Maybe LatestDeviceJob
a -> Device
s {$sel:latestDeviceJob:Device' :: Maybe LatestDeviceJob
latestDeviceJob = Maybe LatestDeviceJob
a} :: Device)

-- | The device\'s lease expiration time.
device_leaseExpirationTime :: Lens.Lens' Device (Prelude.Maybe Prelude.UTCTime)
device_leaseExpirationTime :: Lens' Device (Maybe UTCTime)
device_leaseExpirationTime = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Device' {Maybe POSIX
leaseExpirationTime :: Maybe POSIX
$sel:leaseExpirationTime:Device' :: Device -> Maybe POSIX
leaseExpirationTime} -> Maybe POSIX
leaseExpirationTime) (\s :: Device
s@Device' {} Maybe POSIX
a -> Device
s {$sel:leaseExpirationTime:Device' :: Maybe POSIX
leaseExpirationTime = Maybe POSIX
a} :: Device) 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 :: Format). Iso' (Time a) UTCTime
Data._Time

-- | The device\'s name.
device_name :: Lens.Lens' Device (Prelude.Maybe Prelude.Text)
device_name :: Lens' Device (Maybe Text)
device_name = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Device' {Maybe Text
name :: Maybe Text
$sel:name:Device' :: Device -> Maybe Text
name} -> Maybe Text
name) (\s :: Device
s@Device' {} Maybe Text
a -> Device
s {$sel:name:Device' :: Maybe Text
name = Maybe Text
a} :: Device)

-- | The device\'s provisioning status.
device_provisioningStatus :: Lens.Lens' Device (Prelude.Maybe DeviceStatus)
device_provisioningStatus :: Lens' Device (Maybe DeviceStatus)
device_provisioningStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Device' {Maybe DeviceStatus
provisioningStatus :: Maybe DeviceStatus
$sel:provisioningStatus:Device' :: Device -> Maybe DeviceStatus
provisioningStatus} -> Maybe DeviceStatus
provisioningStatus) (\s :: Device
s@Device' {} Maybe DeviceStatus
a -> Device
s {$sel:provisioningStatus:Device' :: Maybe DeviceStatus
provisioningStatus = Maybe DeviceStatus
a} :: Device)

-- | The device\'s tags.
device_tags :: Lens.Lens' Device (Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text))
device_tags :: Lens' Device (Maybe (HashMap Text Text))
device_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Device' {Maybe (HashMap Text Text)
tags :: Maybe (HashMap Text Text)
$sel:tags:Device' :: Device -> Maybe (HashMap Text Text)
tags} -> Maybe (HashMap Text Text)
tags) (\s :: Device
s@Device' {} Maybe (HashMap Text Text)
a -> Device
s {$sel:tags:Device' :: Maybe (HashMap Text Text)
tags = Maybe (HashMap Text Text)
a} :: Device) 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 device\'s type.
device_type :: Lens.Lens' Device (Prelude.Maybe DeviceType)
device_type :: Lens' Device (Maybe DeviceType)
device_type = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Device' {Maybe DeviceType
type' :: Maybe DeviceType
$sel:type':Device' :: Device -> Maybe DeviceType
type'} -> Maybe DeviceType
type') (\s :: Device
s@Device' {} Maybe DeviceType
a -> Device
s {$sel:type':Device' :: Maybe DeviceType
type' = Maybe DeviceType
a} :: Device)

instance Data.FromJSON Device where
  parseJSON :: Value -> Parser Device
parseJSON =
    forall a. String -> (Object -> Parser a) -> Value -> Parser a
Data.withObject
      String
"Device"
      ( \Object
x ->
          Maybe DeviceBrand
-> Maybe POSIX
-> Maybe Text
-> Maybe Text
-> Maybe DeviceAggregatedStatus
-> Maybe Text
-> Maybe POSIX
-> Maybe LatestDeviceJob
-> Maybe POSIX
-> Maybe Text
-> Maybe DeviceStatus
-> Maybe (HashMap Text Text)
-> Maybe DeviceType
-> Device
Device'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"Brand")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"CreatedTime")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"CurrentSoftware")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"Description")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"DeviceAggregatedStatus")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"DeviceId")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"LastUpdatedTime")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"LatestDeviceJob")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"LeaseExpirationTime")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"Name")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"ProvisioningStatus")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"Tags" forall a. Parser (Maybe a) -> a -> Parser a
Data..!= forall a. Monoid a => a
Prelude.mempty)
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"Type")
      )

instance Prelude.Hashable Device where
  hashWithSalt :: Int -> Device -> Int
hashWithSalt Int
_salt Device' {Maybe Text
Maybe (HashMap Text Text)
Maybe POSIX
Maybe DeviceAggregatedStatus
Maybe DeviceBrand
Maybe DeviceStatus
Maybe DeviceType
Maybe LatestDeviceJob
type' :: Maybe DeviceType
tags :: Maybe (HashMap Text Text)
provisioningStatus :: Maybe DeviceStatus
name :: Maybe Text
leaseExpirationTime :: Maybe POSIX
latestDeviceJob :: Maybe LatestDeviceJob
lastUpdatedTime :: Maybe POSIX
deviceId :: Maybe Text
deviceAggregatedStatus :: Maybe DeviceAggregatedStatus
description :: Maybe Text
currentSoftware :: Maybe Text
createdTime :: Maybe POSIX
brand :: Maybe DeviceBrand
$sel:type':Device' :: Device -> Maybe DeviceType
$sel:tags:Device' :: Device -> Maybe (HashMap Text Text)
$sel:provisioningStatus:Device' :: Device -> Maybe DeviceStatus
$sel:name:Device' :: Device -> Maybe Text
$sel:leaseExpirationTime:Device' :: Device -> Maybe POSIX
$sel:latestDeviceJob:Device' :: Device -> Maybe LatestDeviceJob
$sel:lastUpdatedTime:Device' :: Device -> Maybe POSIX
$sel:deviceId:Device' :: Device -> Maybe Text
$sel:deviceAggregatedStatus:Device' :: Device -> Maybe DeviceAggregatedStatus
$sel:description:Device' :: Device -> Maybe Text
$sel:currentSoftware:Device' :: Device -> Maybe Text
$sel:createdTime:Device' :: Device -> Maybe POSIX
$sel:brand:Device' :: Device -> Maybe DeviceBrand
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe DeviceBrand
brand
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe POSIX
createdTime
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
currentSoftware
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
description
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe DeviceAggregatedStatus
deviceAggregatedStatus
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
deviceId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe POSIX
lastUpdatedTime
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe LatestDeviceJob
latestDeviceJob
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe POSIX
leaseExpirationTime
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
name
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe DeviceStatus
provisioningStatus
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (HashMap Text Text)
tags
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe DeviceType
type'

instance Prelude.NFData Device where
  rnf :: Device -> ()
rnf Device' {Maybe Text
Maybe (HashMap Text Text)
Maybe POSIX
Maybe DeviceAggregatedStatus
Maybe DeviceBrand
Maybe DeviceStatus
Maybe DeviceType
Maybe LatestDeviceJob
type' :: Maybe DeviceType
tags :: Maybe (HashMap Text Text)
provisioningStatus :: Maybe DeviceStatus
name :: Maybe Text
leaseExpirationTime :: Maybe POSIX
latestDeviceJob :: Maybe LatestDeviceJob
lastUpdatedTime :: Maybe POSIX
deviceId :: Maybe Text
deviceAggregatedStatus :: Maybe DeviceAggregatedStatus
description :: Maybe Text
currentSoftware :: Maybe Text
createdTime :: Maybe POSIX
brand :: Maybe DeviceBrand
$sel:type':Device' :: Device -> Maybe DeviceType
$sel:tags:Device' :: Device -> Maybe (HashMap Text Text)
$sel:provisioningStatus:Device' :: Device -> Maybe DeviceStatus
$sel:name:Device' :: Device -> Maybe Text
$sel:leaseExpirationTime:Device' :: Device -> Maybe POSIX
$sel:latestDeviceJob:Device' :: Device -> Maybe LatestDeviceJob
$sel:lastUpdatedTime:Device' :: Device -> Maybe POSIX
$sel:deviceId:Device' :: Device -> Maybe Text
$sel:deviceAggregatedStatus:Device' :: Device -> Maybe DeviceAggregatedStatus
$sel:description:Device' :: Device -> Maybe Text
$sel:currentSoftware:Device' :: Device -> Maybe Text
$sel:createdTime:Device' :: Device -> Maybe POSIX
$sel:brand:Device' :: Device -> Maybe DeviceBrand
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe DeviceBrand
brand
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe POSIX
createdTime
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
currentSoftware
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
description
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe DeviceAggregatedStatus
deviceAggregatedStatus
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
deviceId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe POSIX
lastUpdatedTime
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe LatestDeviceJob
latestDeviceJob
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe POSIX
leaseExpirationTime
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
name
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe DeviceStatus
provisioningStatus
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe (HashMap Text Text)
tags
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe DeviceType
type'