{-# 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.IoTRoboRunner.ListWorkers
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Grants permission to list workers
--
-- This operation returns paginated results.
module Amazonka.IoTRoboRunner.ListWorkers
  ( -- * Creating a Request
    ListWorkers (..),
    newListWorkers,

    -- * Request Lenses
    listWorkers_fleet,
    listWorkers_maxResults,
    listWorkers_nextToken,
    listWorkers_site,

    -- * Destructuring the Response
    ListWorkersResponse (..),
    newListWorkersResponse,

    -- * Response Lenses
    listWorkersResponse_nextToken,
    listWorkersResponse_workers,
    listWorkersResponse_httpStatus,
  )
where

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

-- | /See:/ 'newListWorkers' smart constructor.
data ListWorkers = ListWorkers'
  { ListWorkers -> Maybe Text
fleet :: Prelude.Maybe Prelude.Text,
    ListWorkers -> Maybe Natural
maxResults :: Prelude.Maybe Prelude.Natural,
    ListWorkers -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    ListWorkers -> Text
site :: Prelude.Text
  }
  deriving (ListWorkers -> ListWorkers -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListWorkers -> ListWorkers -> Bool
$c/= :: ListWorkers -> ListWorkers -> Bool
== :: ListWorkers -> ListWorkers -> Bool
$c== :: ListWorkers -> ListWorkers -> Bool
Prelude.Eq, ReadPrec [ListWorkers]
ReadPrec ListWorkers
Int -> ReadS ListWorkers
ReadS [ListWorkers]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListWorkers]
$creadListPrec :: ReadPrec [ListWorkers]
readPrec :: ReadPrec ListWorkers
$creadPrec :: ReadPrec ListWorkers
readList :: ReadS [ListWorkers]
$creadList :: ReadS [ListWorkers]
readsPrec :: Int -> ReadS ListWorkers
$creadsPrec :: Int -> ReadS ListWorkers
Prelude.Read, Int -> ListWorkers -> ShowS
[ListWorkers] -> ShowS
ListWorkers -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListWorkers] -> ShowS
$cshowList :: [ListWorkers] -> ShowS
show :: ListWorkers -> String
$cshow :: ListWorkers -> String
showsPrec :: Int -> ListWorkers -> ShowS
$cshowsPrec :: Int -> ListWorkers -> ShowS
Prelude.Show, forall x. Rep ListWorkers x -> ListWorkers
forall x. ListWorkers -> Rep ListWorkers x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ListWorkers x -> ListWorkers
$cfrom :: forall x. ListWorkers -> Rep ListWorkers x
Prelude.Generic)

-- |
-- Create a value of 'ListWorkers' 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:
--
-- 'fleet', 'listWorkers_fleet' - Undocumented member.
--
-- 'maxResults', 'listWorkers_maxResults' - Undocumented member.
--
-- 'nextToken', 'listWorkers_nextToken' - Undocumented member.
--
-- 'site', 'listWorkers_site' - Undocumented member.
newListWorkers ::
  -- | 'site'
  Prelude.Text ->
  ListWorkers
newListWorkers :: Text -> ListWorkers
newListWorkers Text
pSite_ =
  ListWorkers'
    { $sel:fleet:ListWorkers' :: Maybe Text
fleet = forall a. Maybe a
Prelude.Nothing,
      $sel:maxResults:ListWorkers' :: Maybe Natural
maxResults = forall a. Maybe a
Prelude.Nothing,
      $sel:nextToken:ListWorkers' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing,
      $sel:site:ListWorkers' :: Text
site = Text
pSite_
    }

-- | Undocumented member.
listWorkers_fleet :: Lens.Lens' ListWorkers (Prelude.Maybe Prelude.Text)
listWorkers_fleet :: Lens' ListWorkers (Maybe Text)
listWorkers_fleet = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListWorkers' {Maybe Text
fleet :: Maybe Text
$sel:fleet:ListWorkers' :: ListWorkers -> Maybe Text
fleet} -> Maybe Text
fleet) (\s :: ListWorkers
s@ListWorkers' {} Maybe Text
a -> ListWorkers
s {$sel:fleet:ListWorkers' :: Maybe Text
fleet = Maybe Text
a} :: ListWorkers)

-- | Undocumented member.
listWorkers_maxResults :: Lens.Lens' ListWorkers (Prelude.Maybe Prelude.Natural)
listWorkers_maxResults :: Lens' ListWorkers (Maybe Natural)
listWorkers_maxResults = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListWorkers' {Maybe Natural
maxResults :: Maybe Natural
$sel:maxResults:ListWorkers' :: ListWorkers -> Maybe Natural
maxResults} -> Maybe Natural
maxResults) (\s :: ListWorkers
s@ListWorkers' {} Maybe Natural
a -> ListWorkers
s {$sel:maxResults:ListWorkers' :: Maybe Natural
maxResults = Maybe Natural
a} :: ListWorkers)

-- | Undocumented member.
listWorkers_nextToken :: Lens.Lens' ListWorkers (Prelude.Maybe Prelude.Text)
listWorkers_nextToken :: Lens' ListWorkers (Maybe Text)
listWorkers_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListWorkers' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:ListWorkers' :: ListWorkers -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: ListWorkers
s@ListWorkers' {} Maybe Text
a -> ListWorkers
s {$sel:nextToken:ListWorkers' :: Maybe Text
nextToken = Maybe Text
a} :: ListWorkers)

-- | Undocumented member.
listWorkers_site :: Lens.Lens' ListWorkers Prelude.Text
listWorkers_site :: Lens' ListWorkers Text
listWorkers_site = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListWorkers' {Text
site :: Text
$sel:site:ListWorkers' :: ListWorkers -> Text
site} -> Text
site) (\s :: ListWorkers
s@ListWorkers' {} Text
a -> ListWorkers
s {$sel:site:ListWorkers' :: Text
site = Text
a} :: ListWorkers)

instance Core.AWSPager ListWorkers where
  page :: ListWorkers -> AWSResponse ListWorkers -> Maybe ListWorkers
page ListWorkers
rq AWSResponse ListWorkers
rs
    | forall a. AWSTruncated a => a -> Bool
Core.stop
        ( AWSResponse ListWorkers
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' ListWorkersResponse (Maybe Text)
listWorkersResponse_nextToken
            forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall a b. Prism (Maybe a) (Maybe b) a b
Lens._Just
        ) =
        forall a. Maybe a
Prelude.Nothing
    | forall a. AWSTruncated a => a -> Bool
Core.stop
        ( AWSResponse ListWorkers
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' ListWorkersResponse (Maybe [Worker])
listWorkersResponse_workers
            forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall a b. Prism (Maybe a) (Maybe b) a b
Lens._Just
        ) =
        forall a. Maybe a
Prelude.Nothing
    | Bool
Prelude.otherwise =
        forall a. a -> Maybe a
Prelude.Just
          forall a b. (a -> b) -> a -> b
Prelude.$ ListWorkers
rq
          forall a b. a -> (a -> b) -> b
Prelude.& Lens' ListWorkers (Maybe Text)
listWorkers_nextToken
          forall s t a b. ASetter s t a b -> b -> s -> t
Lens..~ AWSResponse ListWorkers
rs
          forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' ListWorkersResponse (Maybe Text)
listWorkersResponse_nextToken
          forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall a b. Prism (Maybe a) (Maybe b) a b
Lens._Just

instance Core.AWSRequest ListWorkers where
  type AWSResponse ListWorkers = ListWorkersResponse
  request :: (Service -> Service) -> ListWorkers -> Request ListWorkers
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 ListWorkers
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse ListWorkers)))
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 -> Maybe [Worker] -> Int -> ListWorkersResponse
ListWorkersResponse'
            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
"nextToken")
            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
"workers" 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.<*> (forall (f :: * -> *) a. Applicative f => a -> f a
Prelude.pure (forall a. Enum a => a -> Int
Prelude.fromEnum Int
s))
      )

instance Prelude.Hashable ListWorkers where
  hashWithSalt :: Int -> ListWorkers -> Int
hashWithSalt Int
_salt ListWorkers' {Maybe Natural
Maybe Text
Text
site :: Text
nextToken :: Maybe Text
maxResults :: Maybe Natural
fleet :: Maybe Text
$sel:site:ListWorkers' :: ListWorkers -> Text
$sel:nextToken:ListWorkers' :: ListWorkers -> Maybe Text
$sel:maxResults:ListWorkers' :: ListWorkers -> Maybe Natural
$sel:fleet:ListWorkers' :: ListWorkers -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
fleet
      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` Text
site

instance Prelude.NFData ListWorkers where
  rnf :: ListWorkers -> ()
rnf ListWorkers' {Maybe Natural
Maybe Text
Text
site :: Text
nextToken :: Maybe Text
maxResults :: Maybe Natural
fleet :: Maybe Text
$sel:site:ListWorkers' :: ListWorkers -> Text
$sel:nextToken:ListWorkers' :: ListWorkers -> Maybe Text
$sel:maxResults:ListWorkers' :: ListWorkers -> Maybe Natural
$sel:fleet:ListWorkers' :: ListWorkers -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
fleet
      seq :: forall a b. a -> b -> b
`Prelude.seq` 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 Text
site

instance Data.ToHeaders ListWorkers where
  toHeaders :: ListWorkers -> ResponseHeaders
toHeaders =
    forall a b. a -> b -> a
Prelude.const
      ( forall a. Monoid a => [a] -> a
Prelude.mconcat
          [ HeaderName
"Content-Type"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"application/x-amz-json-1.1" ::
                          Prelude.ByteString
                      )
          ]
      )

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

instance Data.ToQuery ListWorkers where
  toQuery :: ListWorkers -> QueryString
toQuery ListWorkers' {Maybe Natural
Maybe Text
Text
site :: Text
nextToken :: Maybe Text
maxResults :: Maybe Natural
fleet :: Maybe Text
$sel:site:ListWorkers' :: ListWorkers -> Text
$sel:nextToken:ListWorkers' :: ListWorkers -> Maybe Text
$sel:maxResults:ListWorkers' :: ListWorkers -> Maybe Natural
$sel:fleet:ListWorkers' :: ListWorkers -> Maybe Text
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"fleet" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Text
fleet,
        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
"site" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Text
site
      ]

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

-- |
-- Create a value of 'ListWorkersResponse' 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:
--
-- 'nextToken', 'listWorkersResponse_nextToken' - Undocumented member.
--
-- 'workers', 'listWorkersResponse_workers' - Undocumented member.
--
-- 'httpStatus', 'listWorkersResponse_httpStatus' - The response's http status code.
newListWorkersResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  ListWorkersResponse
newListWorkersResponse :: Int -> ListWorkersResponse
newListWorkersResponse Int
pHttpStatus_ =
  ListWorkersResponse'
    { $sel:nextToken:ListWorkersResponse' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing,
      $sel:workers:ListWorkersResponse' :: Maybe [Worker]
workers = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:ListWorkersResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | Undocumented member.
listWorkersResponse_nextToken :: Lens.Lens' ListWorkersResponse (Prelude.Maybe Prelude.Text)
listWorkersResponse_nextToken :: Lens' ListWorkersResponse (Maybe Text)
listWorkersResponse_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListWorkersResponse' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:ListWorkersResponse' :: ListWorkersResponse -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: ListWorkersResponse
s@ListWorkersResponse' {} Maybe Text
a -> ListWorkersResponse
s {$sel:nextToken:ListWorkersResponse' :: Maybe Text
nextToken = Maybe Text
a} :: ListWorkersResponse)

-- | Undocumented member.
listWorkersResponse_workers :: Lens.Lens' ListWorkersResponse (Prelude.Maybe [Worker])
listWorkersResponse_workers :: Lens' ListWorkersResponse (Maybe [Worker])
listWorkersResponse_workers = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListWorkersResponse' {Maybe [Worker]
workers :: Maybe [Worker]
$sel:workers:ListWorkersResponse' :: ListWorkersResponse -> Maybe [Worker]
workers} -> Maybe [Worker]
workers) (\s :: ListWorkersResponse
s@ListWorkersResponse' {} Maybe [Worker]
a -> ListWorkersResponse
s {$sel:workers:ListWorkersResponse' :: Maybe [Worker]
workers = Maybe [Worker]
a} :: ListWorkersResponse) 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 response's http status code.
listWorkersResponse_httpStatus :: Lens.Lens' ListWorkersResponse Prelude.Int
listWorkersResponse_httpStatus :: Lens' ListWorkersResponse Int
listWorkersResponse_httpStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListWorkersResponse' {Int
httpStatus :: Int
$sel:httpStatus:ListWorkersResponse' :: ListWorkersResponse -> Int
httpStatus} -> Int
httpStatus) (\s :: ListWorkersResponse
s@ListWorkersResponse' {} Int
a -> ListWorkersResponse
s {$sel:httpStatus:ListWorkersResponse' :: Int
httpStatus = Int
a} :: ListWorkersResponse)

instance Prelude.NFData ListWorkersResponse where
  rnf :: ListWorkersResponse -> ()
rnf ListWorkersResponse' {Int
Maybe [Worker]
Maybe Text
httpStatus :: Int
workers :: Maybe [Worker]
nextToken :: Maybe Text
$sel:httpStatus:ListWorkersResponse' :: ListWorkersResponse -> Int
$sel:workers:ListWorkersResponse' :: ListWorkersResponse -> Maybe [Worker]
$sel:nextToken:ListWorkersResponse' :: ListWorkersResponse -> Maybe Text
..} =
    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 [Worker]
workers
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus