{-# 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.CloudSearch.DescribeSuggesters
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Gets the suggesters configured for a domain. A suggester enables you to
-- display possible matches before users finish typing their queries. Can
-- be limited to specific suggesters by name. By default, shows all
-- suggesters and includes any pending changes to the configuration. Set
-- the @Deployed@ option to @true@ to show the active configuration and
-- exclude pending changes. For more information, see
-- <http://docs.aws.amazon.com/cloudsearch/latest/developerguide/getting-suggestions.html Getting Search Suggestions>
-- in the /Amazon CloudSearch Developer Guide/.
module Amazonka.CloudSearch.DescribeSuggesters
  ( -- * Creating a Request
    DescribeSuggesters (..),
    newDescribeSuggesters,

    -- * Request Lenses
    describeSuggesters_deployed,
    describeSuggesters_suggesterNames,
    describeSuggesters_domainName,

    -- * Destructuring the Response
    DescribeSuggestersResponse (..),
    newDescribeSuggestersResponse,

    -- * Response Lenses
    describeSuggestersResponse_httpStatus,
    describeSuggestersResponse_suggesters,
  )
where

import Amazonka.CloudSearch.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

-- | Container for the parameters to the @DescribeSuggester@ operation.
-- Specifies the name of the domain you want to describe. To restrict the
-- response to particular suggesters, specify the names of the suggesters
-- you want to describe. To show the active configuration and exclude any
-- pending changes, set the @Deployed@ option to @true@.
--
-- /See:/ 'newDescribeSuggesters' smart constructor.
data DescribeSuggesters = DescribeSuggesters'
  { -- | Whether to display the deployed configuration (@true@) or include any
    -- pending changes (@false@). Defaults to @false@.
    DescribeSuggesters -> Maybe Bool
deployed :: Prelude.Maybe Prelude.Bool,
    -- | The suggesters you want to describe.
    DescribeSuggesters -> Maybe [Text]
suggesterNames :: Prelude.Maybe [Prelude.Text],
    -- | The name of the domain you want to describe.
    DescribeSuggesters -> Text
domainName :: Prelude.Text
  }
  deriving (DescribeSuggesters -> DescribeSuggesters -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DescribeSuggesters -> DescribeSuggesters -> Bool
$c/= :: DescribeSuggesters -> DescribeSuggesters -> Bool
== :: DescribeSuggesters -> DescribeSuggesters -> Bool
$c== :: DescribeSuggesters -> DescribeSuggesters -> Bool
Prelude.Eq, ReadPrec [DescribeSuggesters]
ReadPrec DescribeSuggesters
Int -> ReadS DescribeSuggesters
ReadS [DescribeSuggesters]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DescribeSuggesters]
$creadListPrec :: ReadPrec [DescribeSuggesters]
readPrec :: ReadPrec DescribeSuggesters
$creadPrec :: ReadPrec DescribeSuggesters
readList :: ReadS [DescribeSuggesters]
$creadList :: ReadS [DescribeSuggesters]
readsPrec :: Int -> ReadS DescribeSuggesters
$creadsPrec :: Int -> ReadS DescribeSuggesters
Prelude.Read, Int -> DescribeSuggesters -> ShowS
[DescribeSuggesters] -> ShowS
DescribeSuggesters -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DescribeSuggesters] -> ShowS
$cshowList :: [DescribeSuggesters] -> ShowS
show :: DescribeSuggesters -> String
$cshow :: DescribeSuggesters -> String
showsPrec :: Int -> DescribeSuggesters -> ShowS
$cshowsPrec :: Int -> DescribeSuggesters -> ShowS
Prelude.Show, forall x. Rep DescribeSuggesters x -> DescribeSuggesters
forall x. DescribeSuggesters -> Rep DescribeSuggesters x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DescribeSuggesters x -> DescribeSuggesters
$cfrom :: forall x. DescribeSuggesters -> Rep DescribeSuggesters x
Prelude.Generic)

-- |
-- Create a value of 'DescribeSuggesters' 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:
--
-- 'deployed', 'describeSuggesters_deployed' - Whether to display the deployed configuration (@true@) or include any
-- pending changes (@false@). Defaults to @false@.
--
-- 'suggesterNames', 'describeSuggesters_suggesterNames' - The suggesters you want to describe.
--
-- 'domainName', 'describeSuggesters_domainName' - The name of the domain you want to describe.
newDescribeSuggesters ::
  -- | 'domainName'
  Prelude.Text ->
  DescribeSuggesters
newDescribeSuggesters :: Text -> DescribeSuggesters
newDescribeSuggesters Text
pDomainName_ =
  DescribeSuggesters'
    { $sel:deployed:DescribeSuggesters' :: Maybe Bool
deployed = forall a. Maybe a
Prelude.Nothing,
      $sel:suggesterNames:DescribeSuggesters' :: Maybe [Text]
suggesterNames = forall a. Maybe a
Prelude.Nothing,
      $sel:domainName:DescribeSuggesters' :: Text
domainName = Text
pDomainName_
    }

-- | Whether to display the deployed configuration (@true@) or include any
-- pending changes (@false@). Defaults to @false@.
describeSuggesters_deployed :: Lens.Lens' DescribeSuggesters (Prelude.Maybe Prelude.Bool)
describeSuggesters_deployed :: Lens' DescribeSuggesters (Maybe Bool)
describeSuggesters_deployed = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeSuggesters' {Maybe Bool
deployed :: Maybe Bool
$sel:deployed:DescribeSuggesters' :: DescribeSuggesters -> Maybe Bool
deployed} -> Maybe Bool
deployed) (\s :: DescribeSuggesters
s@DescribeSuggesters' {} Maybe Bool
a -> DescribeSuggesters
s {$sel:deployed:DescribeSuggesters' :: Maybe Bool
deployed = Maybe Bool
a} :: DescribeSuggesters)

-- | The suggesters you want to describe.
describeSuggesters_suggesterNames :: Lens.Lens' DescribeSuggesters (Prelude.Maybe [Prelude.Text])
describeSuggesters_suggesterNames :: Lens' DescribeSuggesters (Maybe [Text])
describeSuggesters_suggesterNames = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeSuggesters' {Maybe [Text]
suggesterNames :: Maybe [Text]
$sel:suggesterNames:DescribeSuggesters' :: DescribeSuggesters -> Maybe [Text]
suggesterNames} -> Maybe [Text]
suggesterNames) (\s :: DescribeSuggesters
s@DescribeSuggesters' {} Maybe [Text]
a -> DescribeSuggesters
s {$sel:suggesterNames:DescribeSuggesters' :: Maybe [Text]
suggesterNames = Maybe [Text]
a} :: DescribeSuggesters) 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 name of the domain you want to describe.
describeSuggesters_domainName :: Lens.Lens' DescribeSuggesters Prelude.Text
describeSuggesters_domainName :: Lens' DescribeSuggesters Text
describeSuggesters_domainName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeSuggesters' {Text
domainName :: Text
$sel:domainName:DescribeSuggesters' :: DescribeSuggesters -> Text
domainName} -> Text
domainName) (\s :: DescribeSuggesters
s@DescribeSuggesters' {} Text
a -> DescribeSuggesters
s {$sel:domainName:DescribeSuggesters' :: Text
domainName = Text
a} :: DescribeSuggesters)

instance Core.AWSRequest DescribeSuggesters where
  type
    AWSResponse DescribeSuggesters =
      DescribeSuggestersResponse
  request :: (Service -> Service)
-> DescribeSuggesters -> Request DescribeSuggesters
request Service -> Service
overrides =
    forall a. ToRequest a => Service -> a -> Request a
Request.postQuery (Service -> Service
overrides Service
defaultService)
  response :: forall (m :: * -> *).
MonadResource m =>
(ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy DescribeSuggesters
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse DescribeSuggesters)))
response =
    forall (m :: * -> *) a.
MonadResource m =>
Text
-> (Int
    -> ResponseHeaders -> [Node] -> Either String (AWSResponse a))
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveXMLWrapper
      Text
"DescribeSuggestersResult"
      ( \Int
s ResponseHeaders
h [Node]
x ->
          Int -> [SuggesterStatus] -> DescribeSuggestersResponse
DescribeSuggestersResponse'
            forall (f :: * -> *) a b. Functor 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))
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ( [Node]
x
                            forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"Suggesters"
                            forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty
                            forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
Prelude.>>= forall a. FromXML a => Text -> [Node] -> Either String [a]
Data.parseXMLList Text
"member"
                        )
      )

instance Prelude.Hashable DescribeSuggesters where
  hashWithSalt :: Int -> DescribeSuggesters -> Int
hashWithSalt Int
_salt DescribeSuggesters' {Maybe Bool
Maybe [Text]
Text
domainName :: Text
suggesterNames :: Maybe [Text]
deployed :: Maybe Bool
$sel:domainName:DescribeSuggesters' :: DescribeSuggesters -> Text
$sel:suggesterNames:DescribeSuggesters' :: DescribeSuggesters -> Maybe [Text]
$sel:deployed:DescribeSuggesters' :: DescribeSuggesters -> Maybe Bool
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
deployed
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Text]
suggesterNames
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
domainName

instance Prelude.NFData DescribeSuggesters where
  rnf :: DescribeSuggesters -> ()
rnf DescribeSuggesters' {Maybe Bool
Maybe [Text]
Text
domainName :: Text
suggesterNames :: Maybe [Text]
deployed :: Maybe Bool
$sel:domainName:DescribeSuggesters' :: DescribeSuggesters -> Text
$sel:suggesterNames:DescribeSuggesters' :: DescribeSuggesters -> Maybe [Text]
$sel:deployed:DescribeSuggesters' :: DescribeSuggesters -> Maybe Bool
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Bool
deployed
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Text]
suggesterNames
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
domainName

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

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

instance Data.ToQuery DescribeSuggesters where
  toQuery :: DescribeSuggesters -> QueryString
toQuery DescribeSuggesters' {Maybe Bool
Maybe [Text]
Text
domainName :: Text
suggesterNames :: Maybe [Text]
deployed :: Maybe Bool
$sel:domainName:DescribeSuggesters' :: DescribeSuggesters -> Text
$sel:suggesterNames:DescribeSuggesters' :: DescribeSuggesters -> Maybe [Text]
$sel:deployed:DescribeSuggesters' :: DescribeSuggesters -> Maybe Bool
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"Action"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: (ByteString
"DescribeSuggesters" :: Prelude.ByteString),
        ByteString
"Version"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: (ByteString
"2013-01-01" :: Prelude.ByteString),
        ByteString
"Deployed" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Bool
deployed,
        ByteString
"SuggesterNames"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: forall a. ToQuery a => a -> QueryString
Data.toQuery
            ( forall a.
(IsList a, ToQuery (Item a)) =>
ByteString -> a -> QueryString
Data.toQueryList ByteString
"member"
                forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe [Text]
suggesterNames
            ),
        ByteString
"DomainName" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Text
domainName
      ]

-- | The result of a @DescribeSuggesters@ request.
--
-- /See:/ 'newDescribeSuggestersResponse' smart constructor.
data DescribeSuggestersResponse = DescribeSuggestersResponse'
  { -- | The response's http status code.
    DescribeSuggestersResponse -> Int
httpStatus :: Prelude.Int,
    -- | The suggesters configured for the domain specified in the request.
    DescribeSuggestersResponse -> [SuggesterStatus]
suggesters :: [SuggesterStatus]
  }
  deriving (DescribeSuggestersResponse -> DescribeSuggestersResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DescribeSuggestersResponse -> DescribeSuggestersResponse -> Bool
$c/= :: DescribeSuggestersResponse -> DescribeSuggestersResponse -> Bool
== :: DescribeSuggestersResponse -> DescribeSuggestersResponse -> Bool
$c== :: DescribeSuggestersResponse -> DescribeSuggestersResponse -> Bool
Prelude.Eq, ReadPrec [DescribeSuggestersResponse]
ReadPrec DescribeSuggestersResponse
Int -> ReadS DescribeSuggestersResponse
ReadS [DescribeSuggestersResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DescribeSuggestersResponse]
$creadListPrec :: ReadPrec [DescribeSuggestersResponse]
readPrec :: ReadPrec DescribeSuggestersResponse
$creadPrec :: ReadPrec DescribeSuggestersResponse
readList :: ReadS [DescribeSuggestersResponse]
$creadList :: ReadS [DescribeSuggestersResponse]
readsPrec :: Int -> ReadS DescribeSuggestersResponse
$creadsPrec :: Int -> ReadS DescribeSuggestersResponse
Prelude.Read, Int -> DescribeSuggestersResponse -> ShowS
[DescribeSuggestersResponse] -> ShowS
DescribeSuggestersResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DescribeSuggestersResponse] -> ShowS
$cshowList :: [DescribeSuggestersResponse] -> ShowS
show :: DescribeSuggestersResponse -> String
$cshow :: DescribeSuggestersResponse -> String
showsPrec :: Int -> DescribeSuggestersResponse -> ShowS
$cshowsPrec :: Int -> DescribeSuggestersResponse -> ShowS
Prelude.Show, forall x.
Rep DescribeSuggestersResponse x -> DescribeSuggestersResponse
forall x.
DescribeSuggestersResponse -> Rep DescribeSuggestersResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep DescribeSuggestersResponse x -> DescribeSuggestersResponse
$cfrom :: forall x.
DescribeSuggestersResponse -> Rep DescribeSuggestersResponse x
Prelude.Generic)

-- |
-- Create a value of 'DescribeSuggestersResponse' 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:
--
-- 'httpStatus', 'describeSuggestersResponse_httpStatus' - The response's http status code.
--
-- 'suggesters', 'describeSuggestersResponse_suggesters' - The suggesters configured for the domain specified in the request.
newDescribeSuggestersResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  DescribeSuggestersResponse
newDescribeSuggestersResponse :: Int -> DescribeSuggestersResponse
newDescribeSuggestersResponse Int
pHttpStatus_ =
  DescribeSuggestersResponse'
    { $sel:httpStatus:DescribeSuggestersResponse' :: Int
httpStatus =
        Int
pHttpStatus_,
      $sel:suggesters:DescribeSuggestersResponse' :: [SuggesterStatus]
suggesters = forall a. Monoid a => a
Prelude.mempty
    }

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

-- | The suggesters configured for the domain specified in the request.
describeSuggestersResponse_suggesters :: Lens.Lens' DescribeSuggestersResponse [SuggesterStatus]
describeSuggestersResponse_suggesters :: Lens' DescribeSuggestersResponse [SuggesterStatus]
describeSuggestersResponse_suggesters = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeSuggestersResponse' {[SuggesterStatus]
suggesters :: [SuggesterStatus]
$sel:suggesters:DescribeSuggestersResponse' :: DescribeSuggestersResponse -> [SuggesterStatus]
suggesters} -> [SuggesterStatus]
suggesters) (\s :: DescribeSuggestersResponse
s@DescribeSuggestersResponse' {} [SuggesterStatus]
a -> DescribeSuggestersResponse
s {$sel:suggesters:DescribeSuggestersResponse' :: [SuggesterStatus]
suggesters = [SuggesterStatus]
a} :: DescribeSuggestersResponse) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

instance Prelude.NFData DescribeSuggestersResponse where
  rnf :: DescribeSuggestersResponse -> ()
rnf DescribeSuggestersResponse' {Int
[SuggesterStatus]
suggesters :: [SuggesterStatus]
httpStatus :: Int
$sel:suggesters:DescribeSuggestersResponse' :: DescribeSuggestersResponse -> [SuggesterStatus]
$sel:httpStatus:DescribeSuggestersResponse' :: DescribeSuggestersResponse -> Int
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf [SuggesterStatus]
suggesters