{-# 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.IoTEventsData.ListDetectors
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Lists detectors (the instances of a detector model).
module Amazonka.IoTEventsData.ListDetectors
  ( -- * Creating a Request
    ListDetectors (..),
    newListDetectors,

    -- * Request Lenses
    listDetectors_maxResults,
    listDetectors_nextToken,
    listDetectors_stateName,
    listDetectors_detectorModelName,

    -- * Destructuring the Response
    ListDetectorsResponse (..),
    newListDetectorsResponse,

    -- * Response Lenses
    listDetectorsResponse_detectorSummaries,
    listDetectorsResponse_nextToken,
    listDetectorsResponse_httpStatus,
  )
where

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

-- | /See:/ 'newListDetectors' smart constructor.
data ListDetectors = ListDetectors'
  { -- | The maximum number of results to be returned per request.
    ListDetectors -> Maybe Natural
maxResults :: Prelude.Maybe Prelude.Natural,
    -- | The token that you can use to return the next set of results.
    ListDetectors -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | A filter that limits results to those detectors (instances) in the given
    -- state.
    ListDetectors -> Maybe Text
stateName :: Prelude.Maybe Prelude.Text,
    -- | The name of the detector model whose detectors (instances) are listed.
    ListDetectors -> Text
detectorModelName :: Prelude.Text
  }
  deriving (ListDetectors -> ListDetectors -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListDetectors -> ListDetectors -> Bool
$c/= :: ListDetectors -> ListDetectors -> Bool
== :: ListDetectors -> ListDetectors -> Bool
$c== :: ListDetectors -> ListDetectors -> Bool
Prelude.Eq, ReadPrec [ListDetectors]
ReadPrec ListDetectors
Int -> ReadS ListDetectors
ReadS [ListDetectors]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListDetectors]
$creadListPrec :: ReadPrec [ListDetectors]
readPrec :: ReadPrec ListDetectors
$creadPrec :: ReadPrec ListDetectors
readList :: ReadS [ListDetectors]
$creadList :: ReadS [ListDetectors]
readsPrec :: Int -> ReadS ListDetectors
$creadsPrec :: Int -> ReadS ListDetectors
Prelude.Read, Int -> ListDetectors -> ShowS
[ListDetectors] -> ShowS
ListDetectors -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListDetectors] -> ShowS
$cshowList :: [ListDetectors] -> ShowS
show :: ListDetectors -> String
$cshow :: ListDetectors -> String
showsPrec :: Int -> ListDetectors -> ShowS
$cshowsPrec :: Int -> ListDetectors -> ShowS
Prelude.Show, forall x. Rep ListDetectors x -> ListDetectors
forall x. ListDetectors -> Rep ListDetectors x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ListDetectors x -> ListDetectors
$cfrom :: forall x. ListDetectors -> Rep ListDetectors x
Prelude.Generic)

-- |
-- Create a value of 'ListDetectors' 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:
--
-- 'maxResults', 'listDetectors_maxResults' - The maximum number of results to be returned per request.
--
-- 'nextToken', 'listDetectors_nextToken' - The token that you can use to return the next set of results.
--
-- 'stateName', 'listDetectors_stateName' - A filter that limits results to those detectors (instances) in the given
-- state.
--
-- 'detectorModelName', 'listDetectors_detectorModelName' - The name of the detector model whose detectors (instances) are listed.
newListDetectors ::
  -- | 'detectorModelName'
  Prelude.Text ->
  ListDetectors
newListDetectors :: Text -> ListDetectors
newListDetectors Text
pDetectorModelName_ =
  ListDetectors'
    { $sel:maxResults:ListDetectors' :: Maybe Natural
maxResults = forall a. Maybe a
Prelude.Nothing,
      $sel:nextToken:ListDetectors' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing,
      $sel:stateName:ListDetectors' :: Maybe Text
stateName = forall a. Maybe a
Prelude.Nothing,
      $sel:detectorModelName:ListDetectors' :: Text
detectorModelName = Text
pDetectorModelName_
    }

-- | The maximum number of results to be returned per request.
listDetectors_maxResults :: Lens.Lens' ListDetectors (Prelude.Maybe Prelude.Natural)
listDetectors_maxResults :: Lens' ListDetectors (Maybe Natural)
listDetectors_maxResults = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListDetectors' {Maybe Natural
maxResults :: Maybe Natural
$sel:maxResults:ListDetectors' :: ListDetectors -> Maybe Natural
maxResults} -> Maybe Natural
maxResults) (\s :: ListDetectors
s@ListDetectors' {} Maybe Natural
a -> ListDetectors
s {$sel:maxResults:ListDetectors' :: Maybe Natural
maxResults = Maybe Natural
a} :: ListDetectors)

-- | The token that you can use to return the next set of results.
listDetectors_nextToken :: Lens.Lens' ListDetectors (Prelude.Maybe Prelude.Text)
listDetectors_nextToken :: Lens' ListDetectors (Maybe Text)
listDetectors_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListDetectors' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:ListDetectors' :: ListDetectors -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: ListDetectors
s@ListDetectors' {} Maybe Text
a -> ListDetectors
s {$sel:nextToken:ListDetectors' :: Maybe Text
nextToken = Maybe Text
a} :: ListDetectors)

-- | A filter that limits results to those detectors (instances) in the given
-- state.
listDetectors_stateName :: Lens.Lens' ListDetectors (Prelude.Maybe Prelude.Text)
listDetectors_stateName :: Lens' ListDetectors (Maybe Text)
listDetectors_stateName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListDetectors' {Maybe Text
stateName :: Maybe Text
$sel:stateName:ListDetectors' :: ListDetectors -> Maybe Text
stateName} -> Maybe Text
stateName) (\s :: ListDetectors
s@ListDetectors' {} Maybe Text
a -> ListDetectors
s {$sel:stateName:ListDetectors' :: Maybe Text
stateName = Maybe Text
a} :: ListDetectors)

-- | The name of the detector model whose detectors (instances) are listed.
listDetectors_detectorModelName :: Lens.Lens' ListDetectors Prelude.Text
listDetectors_detectorModelName :: Lens' ListDetectors Text
listDetectors_detectorModelName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListDetectors' {Text
detectorModelName :: Text
$sel:detectorModelName:ListDetectors' :: ListDetectors -> Text
detectorModelName} -> Text
detectorModelName) (\s :: ListDetectors
s@ListDetectors' {} Text
a -> ListDetectors
s {$sel:detectorModelName:ListDetectors' :: Text
detectorModelName = Text
a} :: ListDetectors)

instance Core.AWSRequest ListDetectors where
  type
    AWSResponse ListDetectors =
      ListDetectorsResponse
  request :: (Service -> Service) -> ListDetectors -> Request ListDetectors
request Service -> Service
overrides =
    forall a. ToRequest a => Service -> a -> Request a
Request.get (Service -> Service
overrides Service
defaultService)
  response :: forall (m :: * -> *).
MonadResource m =>
(ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy ListDetectors
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse ListDetectors)))
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 [DetectorSummary]
-> Maybe Text -> Int -> ListDetectorsResponse
ListDetectorsResponse'
            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
"detectorSummaries"
                            forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ 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 -> Either String (Maybe a)
Data..?> Key
"nextToken")
            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 ListDetectors where
  hashWithSalt :: Int -> ListDetectors -> Int
hashWithSalt Int
_salt ListDetectors' {Maybe Natural
Maybe Text
Text
detectorModelName :: Text
stateName :: Maybe Text
nextToken :: Maybe Text
maxResults :: Maybe Natural
$sel:detectorModelName:ListDetectors' :: ListDetectors -> Text
$sel:stateName:ListDetectors' :: ListDetectors -> Maybe Text
$sel:nextToken:ListDetectors' :: ListDetectors -> Maybe Text
$sel:maxResults:ListDetectors' :: ListDetectors -> Maybe Natural
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Natural
maxResults
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
nextToken
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
stateName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
detectorModelName

instance Prelude.NFData ListDetectors where
  rnf :: ListDetectors -> ()
rnf ListDetectors' {Maybe Natural
Maybe Text
Text
detectorModelName :: Text
stateName :: Maybe Text
nextToken :: Maybe Text
maxResults :: Maybe Natural
$sel:detectorModelName:ListDetectors' :: ListDetectors -> Text
$sel:stateName:ListDetectors' :: ListDetectors -> Maybe Text
$sel:nextToken:ListDetectors' :: ListDetectors -> Maybe Text
$sel:maxResults:ListDetectors' :: ListDetectors -> Maybe Natural
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Natural
maxResults
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
nextToken
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
stateName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
detectorModelName

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

instance Data.ToPath ListDetectors where
  toPath :: ListDetectors -> ByteString
toPath ListDetectors' {Maybe Natural
Maybe Text
Text
detectorModelName :: Text
stateName :: Maybe Text
nextToken :: Maybe Text
maxResults :: Maybe Natural
$sel:detectorModelName:ListDetectors' :: ListDetectors -> Text
$sel:stateName:ListDetectors' :: ListDetectors -> Maybe Text
$sel:nextToken:ListDetectors' :: ListDetectors -> Maybe Text
$sel:maxResults:ListDetectors' :: ListDetectors -> Maybe Natural
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ByteString
"/detectors/", forall a. ToByteString a => a -> ByteString
Data.toBS Text
detectorModelName]

instance Data.ToQuery ListDetectors where
  toQuery :: ListDetectors -> QueryString
toQuery ListDetectors' {Maybe Natural
Maybe Text
Text
detectorModelName :: Text
stateName :: Maybe Text
nextToken :: Maybe Text
maxResults :: Maybe Natural
$sel:detectorModelName:ListDetectors' :: ListDetectors -> Text
$sel:stateName:ListDetectors' :: ListDetectors -> Maybe Text
$sel:nextToken:ListDetectors' :: ListDetectors -> Maybe Text
$sel:maxResults:ListDetectors' :: ListDetectors -> Maybe Natural
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"maxResults" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Natural
maxResults,
        ByteString
"nextToken" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Text
nextToken,
        ByteString
"stateName" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Text
stateName
      ]

-- | /See:/ 'newListDetectorsResponse' smart constructor.
data ListDetectorsResponse = ListDetectorsResponse'
  { -- | A list of summary information about the detectors (instances).
    ListDetectorsResponse -> Maybe [DetectorSummary]
detectorSummaries :: Prelude.Maybe [DetectorSummary],
    -- | The token that you can use to return the next set of results, or @null@
    -- if there are no more results.
    ListDetectorsResponse -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | The response's http status code.
    ListDetectorsResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (ListDetectorsResponse -> ListDetectorsResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListDetectorsResponse -> ListDetectorsResponse -> Bool
$c/= :: ListDetectorsResponse -> ListDetectorsResponse -> Bool
== :: ListDetectorsResponse -> ListDetectorsResponse -> Bool
$c== :: ListDetectorsResponse -> ListDetectorsResponse -> Bool
Prelude.Eq, ReadPrec [ListDetectorsResponse]
ReadPrec ListDetectorsResponse
Int -> ReadS ListDetectorsResponse
ReadS [ListDetectorsResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListDetectorsResponse]
$creadListPrec :: ReadPrec [ListDetectorsResponse]
readPrec :: ReadPrec ListDetectorsResponse
$creadPrec :: ReadPrec ListDetectorsResponse
readList :: ReadS [ListDetectorsResponse]
$creadList :: ReadS [ListDetectorsResponse]
readsPrec :: Int -> ReadS ListDetectorsResponse
$creadsPrec :: Int -> ReadS ListDetectorsResponse
Prelude.Read, Int -> ListDetectorsResponse -> ShowS
[ListDetectorsResponse] -> ShowS
ListDetectorsResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListDetectorsResponse] -> ShowS
$cshowList :: [ListDetectorsResponse] -> ShowS
show :: ListDetectorsResponse -> String
$cshow :: ListDetectorsResponse -> String
showsPrec :: Int -> ListDetectorsResponse -> ShowS
$cshowsPrec :: Int -> ListDetectorsResponse -> ShowS
Prelude.Show, forall x. Rep ListDetectorsResponse x -> ListDetectorsResponse
forall x. ListDetectorsResponse -> Rep ListDetectorsResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ListDetectorsResponse x -> ListDetectorsResponse
$cfrom :: forall x. ListDetectorsResponse -> Rep ListDetectorsResponse x
Prelude.Generic)

-- |
-- Create a value of 'ListDetectorsResponse' 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:
--
-- 'detectorSummaries', 'listDetectorsResponse_detectorSummaries' - A list of summary information about the detectors (instances).
--
-- 'nextToken', 'listDetectorsResponse_nextToken' - The token that you can use to return the next set of results, or @null@
-- if there are no more results.
--
-- 'httpStatus', 'listDetectorsResponse_httpStatus' - The response's http status code.
newListDetectorsResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  ListDetectorsResponse
newListDetectorsResponse :: Int -> ListDetectorsResponse
newListDetectorsResponse Int
pHttpStatus_ =
  ListDetectorsResponse'
    { $sel:detectorSummaries:ListDetectorsResponse' :: Maybe [DetectorSummary]
detectorSummaries =
        forall a. Maybe a
Prelude.Nothing,
      $sel:nextToken:ListDetectorsResponse' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:ListDetectorsResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | A list of summary information about the detectors (instances).
listDetectorsResponse_detectorSummaries :: Lens.Lens' ListDetectorsResponse (Prelude.Maybe [DetectorSummary])
listDetectorsResponse_detectorSummaries :: Lens' ListDetectorsResponse (Maybe [DetectorSummary])
listDetectorsResponse_detectorSummaries = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListDetectorsResponse' {Maybe [DetectorSummary]
detectorSummaries :: Maybe [DetectorSummary]
$sel:detectorSummaries:ListDetectorsResponse' :: ListDetectorsResponse -> Maybe [DetectorSummary]
detectorSummaries} -> Maybe [DetectorSummary]
detectorSummaries) (\s :: ListDetectorsResponse
s@ListDetectorsResponse' {} Maybe [DetectorSummary]
a -> ListDetectorsResponse
s {$sel:detectorSummaries:ListDetectorsResponse' :: Maybe [DetectorSummary]
detectorSummaries = Maybe [DetectorSummary]
a} :: ListDetectorsResponse) 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 token that you can use to return the next set of results, or @null@
-- if there are no more results.
listDetectorsResponse_nextToken :: Lens.Lens' ListDetectorsResponse (Prelude.Maybe Prelude.Text)
listDetectorsResponse_nextToken :: Lens' ListDetectorsResponse (Maybe Text)
listDetectorsResponse_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListDetectorsResponse' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:ListDetectorsResponse' :: ListDetectorsResponse -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: ListDetectorsResponse
s@ListDetectorsResponse' {} Maybe Text
a -> ListDetectorsResponse
s {$sel:nextToken:ListDetectorsResponse' :: Maybe Text
nextToken = Maybe Text
a} :: ListDetectorsResponse)

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

instance Prelude.NFData ListDetectorsResponse where
  rnf :: ListDetectorsResponse -> ()
rnf ListDetectorsResponse' {Int
Maybe [DetectorSummary]
Maybe Text
httpStatus :: Int
nextToken :: Maybe Text
detectorSummaries :: Maybe [DetectorSummary]
$sel:httpStatus:ListDetectorsResponse' :: ListDetectorsResponse -> Int
$sel:nextToken:ListDetectorsResponse' :: ListDetectorsResponse -> Maybe Text
$sel:detectorSummaries:ListDetectorsResponse' :: ListDetectorsResponse -> Maybe [DetectorSummary]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [DetectorSummary]
detectorSummaries
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
nextToken
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus