{-# 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.ConnectCases.SearchCases
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Searches for cases within their associated Cases domain. Search results
-- are returned as a paginated list of abridged case documents.
--
-- This operation returns paginated results.
module Amazonka.ConnectCases.SearchCases
  ( -- * Creating a Request
    SearchCases (..),
    newSearchCases,

    -- * Request Lenses
    searchCases_fields,
    searchCases_filter,
    searchCases_maxResults,
    searchCases_nextToken,
    searchCases_searchTerm,
    searchCases_sorts,
    searchCases_domainId,

    -- * Destructuring the Response
    SearchCasesResponse (..),
    newSearchCasesResponse,

    -- * Response Lenses
    searchCasesResponse_nextToken,
    searchCasesResponse_httpStatus,
    searchCasesResponse_cases,
  )
where

import Amazonka.ConnectCases.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:/ 'newSearchCases' smart constructor.
data SearchCases = SearchCases'
  { -- | The list of field identifiers to be returned as part of the response.
    SearchCases -> Maybe [FieldIdentifier]
fields :: Prelude.Maybe [FieldIdentifier],
    -- | A list of filter objects.
    SearchCases -> Maybe CaseFilter
filter' :: Prelude.Maybe CaseFilter,
    -- | The maximum number of cases to return. The current maximum supported
    -- value is 25. This is also the default value when no other value is
    -- provided.
    SearchCases -> Maybe Natural
maxResults :: Prelude.Maybe Prelude.Natural,
    -- | The token for the next set of results. Use the value returned in the
    -- previous response in the next request to retrieve the next set of
    -- results.
    SearchCases -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | A word or phrase used to perform a quick search.
    SearchCases -> Maybe Text
searchTerm :: Prelude.Maybe Prelude.Text,
    -- | A list of sorts where each sort specifies a field and their sort order
    -- to be applied to the results.
    SearchCases -> Maybe [Sort]
sorts :: Prelude.Maybe [Sort],
    -- | The unique identifier of the Cases domain.
    SearchCases -> Text
domainId :: Prelude.Text
  }
  deriving (SearchCases -> SearchCases -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SearchCases -> SearchCases -> Bool
$c/= :: SearchCases -> SearchCases -> Bool
== :: SearchCases -> SearchCases -> Bool
$c== :: SearchCases -> SearchCases -> Bool
Prelude.Eq, ReadPrec [SearchCases]
ReadPrec SearchCases
Int -> ReadS SearchCases
ReadS [SearchCases]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [SearchCases]
$creadListPrec :: ReadPrec [SearchCases]
readPrec :: ReadPrec SearchCases
$creadPrec :: ReadPrec SearchCases
readList :: ReadS [SearchCases]
$creadList :: ReadS [SearchCases]
readsPrec :: Int -> ReadS SearchCases
$creadsPrec :: Int -> ReadS SearchCases
Prelude.Read, Int -> SearchCases -> ShowS
[SearchCases] -> ShowS
SearchCases -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SearchCases] -> ShowS
$cshowList :: [SearchCases] -> ShowS
show :: SearchCases -> String
$cshow :: SearchCases -> String
showsPrec :: Int -> SearchCases -> ShowS
$cshowsPrec :: Int -> SearchCases -> ShowS
Prelude.Show, forall x. Rep SearchCases x -> SearchCases
forall x. SearchCases -> Rep SearchCases x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep SearchCases x -> SearchCases
$cfrom :: forall x. SearchCases -> Rep SearchCases x
Prelude.Generic)

-- |
-- Create a value of 'SearchCases' 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:
--
-- 'fields', 'searchCases_fields' - The list of field identifiers to be returned as part of the response.
--
-- 'filter'', 'searchCases_filter' - A list of filter objects.
--
-- 'maxResults', 'searchCases_maxResults' - The maximum number of cases to return. The current maximum supported
-- value is 25. This is also the default value when no other value is
-- provided.
--
-- 'nextToken', 'searchCases_nextToken' - The token for the next set of results. Use the value returned in the
-- previous response in the next request to retrieve the next set of
-- results.
--
-- 'searchTerm', 'searchCases_searchTerm' - A word or phrase used to perform a quick search.
--
-- 'sorts', 'searchCases_sorts' - A list of sorts where each sort specifies a field and their sort order
-- to be applied to the results.
--
-- 'domainId', 'searchCases_domainId' - The unique identifier of the Cases domain.
newSearchCases ::
  -- | 'domainId'
  Prelude.Text ->
  SearchCases
newSearchCases :: Text -> SearchCases
newSearchCases Text
pDomainId_ =
  SearchCases'
    { $sel:fields:SearchCases' :: Maybe [FieldIdentifier]
fields = forall a. Maybe a
Prelude.Nothing,
      $sel:filter':SearchCases' :: Maybe CaseFilter
filter' = forall a. Maybe a
Prelude.Nothing,
      $sel:maxResults:SearchCases' :: Maybe Natural
maxResults = forall a. Maybe a
Prelude.Nothing,
      $sel:nextToken:SearchCases' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing,
      $sel:searchTerm:SearchCases' :: Maybe Text
searchTerm = forall a. Maybe a
Prelude.Nothing,
      $sel:sorts:SearchCases' :: Maybe [Sort]
sorts = forall a. Maybe a
Prelude.Nothing,
      $sel:domainId:SearchCases' :: Text
domainId = Text
pDomainId_
    }

-- | The list of field identifiers to be returned as part of the response.
searchCases_fields :: Lens.Lens' SearchCases (Prelude.Maybe [FieldIdentifier])
searchCases_fields :: Lens' SearchCases (Maybe [FieldIdentifier])
searchCases_fields = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SearchCases' {Maybe [FieldIdentifier]
fields :: Maybe [FieldIdentifier]
$sel:fields:SearchCases' :: SearchCases -> Maybe [FieldIdentifier]
fields} -> Maybe [FieldIdentifier]
fields) (\s :: SearchCases
s@SearchCases' {} Maybe [FieldIdentifier]
a -> SearchCases
s {$sel:fields:SearchCases' :: Maybe [FieldIdentifier]
fields = Maybe [FieldIdentifier]
a} :: SearchCases) 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

-- | A list of filter objects.
searchCases_filter :: Lens.Lens' SearchCases (Prelude.Maybe CaseFilter)
searchCases_filter :: Lens' SearchCases (Maybe CaseFilter)
searchCases_filter = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SearchCases' {Maybe CaseFilter
filter' :: Maybe CaseFilter
$sel:filter':SearchCases' :: SearchCases -> Maybe CaseFilter
filter'} -> Maybe CaseFilter
filter') (\s :: SearchCases
s@SearchCases' {} Maybe CaseFilter
a -> SearchCases
s {$sel:filter':SearchCases' :: Maybe CaseFilter
filter' = Maybe CaseFilter
a} :: SearchCases)

-- | The maximum number of cases to return. The current maximum supported
-- value is 25. This is also the default value when no other value is
-- provided.
searchCases_maxResults :: Lens.Lens' SearchCases (Prelude.Maybe Prelude.Natural)
searchCases_maxResults :: Lens' SearchCases (Maybe Natural)
searchCases_maxResults = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SearchCases' {Maybe Natural
maxResults :: Maybe Natural
$sel:maxResults:SearchCases' :: SearchCases -> Maybe Natural
maxResults} -> Maybe Natural
maxResults) (\s :: SearchCases
s@SearchCases' {} Maybe Natural
a -> SearchCases
s {$sel:maxResults:SearchCases' :: Maybe Natural
maxResults = Maybe Natural
a} :: SearchCases)

-- | The token for the next set of results. Use the value returned in the
-- previous response in the next request to retrieve the next set of
-- results.
searchCases_nextToken :: Lens.Lens' SearchCases (Prelude.Maybe Prelude.Text)
searchCases_nextToken :: Lens' SearchCases (Maybe Text)
searchCases_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SearchCases' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:SearchCases' :: SearchCases -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: SearchCases
s@SearchCases' {} Maybe Text
a -> SearchCases
s {$sel:nextToken:SearchCases' :: Maybe Text
nextToken = Maybe Text
a} :: SearchCases)

-- | A word or phrase used to perform a quick search.
searchCases_searchTerm :: Lens.Lens' SearchCases (Prelude.Maybe Prelude.Text)
searchCases_searchTerm :: Lens' SearchCases (Maybe Text)
searchCases_searchTerm = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SearchCases' {Maybe Text
searchTerm :: Maybe Text
$sel:searchTerm:SearchCases' :: SearchCases -> Maybe Text
searchTerm} -> Maybe Text
searchTerm) (\s :: SearchCases
s@SearchCases' {} Maybe Text
a -> SearchCases
s {$sel:searchTerm:SearchCases' :: Maybe Text
searchTerm = Maybe Text
a} :: SearchCases)

-- | A list of sorts where each sort specifies a field and their sort order
-- to be applied to the results.
searchCases_sorts :: Lens.Lens' SearchCases (Prelude.Maybe [Sort])
searchCases_sorts :: Lens' SearchCases (Maybe [Sort])
searchCases_sorts = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SearchCases' {Maybe [Sort]
sorts :: Maybe [Sort]
$sel:sorts:SearchCases' :: SearchCases -> Maybe [Sort]
sorts} -> Maybe [Sort]
sorts) (\s :: SearchCases
s@SearchCases' {} Maybe [Sort]
a -> SearchCases
s {$sel:sorts:SearchCases' :: Maybe [Sort]
sorts = Maybe [Sort]
a} :: SearchCases) 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 unique identifier of the Cases domain.
searchCases_domainId :: Lens.Lens' SearchCases Prelude.Text
searchCases_domainId :: Lens' SearchCases Text
searchCases_domainId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SearchCases' {Text
domainId :: Text
$sel:domainId:SearchCases' :: SearchCases -> Text
domainId} -> Text
domainId) (\s :: SearchCases
s@SearchCases' {} Text
a -> SearchCases
s {$sel:domainId:SearchCases' :: Text
domainId = Text
a} :: SearchCases)

instance Core.AWSPager SearchCases where
  page :: SearchCases -> AWSResponse SearchCases -> Maybe SearchCases
page SearchCases
rq AWSResponse SearchCases
rs
    | forall a. AWSTruncated a => a -> Bool
Core.stop
        ( AWSResponse SearchCases
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' SearchCasesResponse (Maybe Text)
searchCasesResponse_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 SearchCases
rs forall s a. s -> Getting a s a -> a
Lens.^. Lens' SearchCasesResponse [SearchCasesResponseItem]
searchCasesResponse_cases) =
        forall a. Maybe a
Prelude.Nothing
    | Bool
Prelude.otherwise =
        forall a. a -> Maybe a
Prelude.Just
          forall a b. (a -> b) -> a -> b
Prelude.$ SearchCases
rq
          forall a b. a -> (a -> b) -> b
Prelude.& Lens' SearchCases (Maybe Text)
searchCases_nextToken
          forall s t a b. ASetter s t a b -> b -> s -> t
Lens..~ AWSResponse SearchCases
rs
          forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' SearchCasesResponse (Maybe Text)
searchCasesResponse_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 SearchCases where
  type AWSResponse SearchCases = SearchCasesResponse
  request :: (Service -> Service) -> SearchCases -> Request SearchCases
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 SearchCases
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse SearchCases)))
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 -> [SearchCasesResponseItem] -> SearchCasesResponse
SearchCasesResponse'
            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.<*> (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.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"cases" forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty)
      )

instance Prelude.Hashable SearchCases where
  hashWithSalt :: Int -> SearchCases -> Int
hashWithSalt Int
_salt SearchCases' {Maybe Natural
Maybe [FieldIdentifier]
Maybe [Sort]
Maybe Text
Maybe CaseFilter
Text
domainId :: Text
sorts :: Maybe [Sort]
searchTerm :: Maybe Text
nextToken :: Maybe Text
maxResults :: Maybe Natural
filter' :: Maybe CaseFilter
fields :: Maybe [FieldIdentifier]
$sel:domainId:SearchCases' :: SearchCases -> Text
$sel:sorts:SearchCases' :: SearchCases -> Maybe [Sort]
$sel:searchTerm:SearchCases' :: SearchCases -> Maybe Text
$sel:nextToken:SearchCases' :: SearchCases -> Maybe Text
$sel:maxResults:SearchCases' :: SearchCases -> Maybe Natural
$sel:filter':SearchCases' :: SearchCases -> Maybe CaseFilter
$sel:fields:SearchCases' :: SearchCases -> Maybe [FieldIdentifier]
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [FieldIdentifier]
fields
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe CaseFilter
filter'
      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
searchTerm
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Sort]
sorts
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
domainId

instance Prelude.NFData SearchCases where
  rnf :: SearchCases -> ()
rnf SearchCases' {Maybe Natural
Maybe [FieldIdentifier]
Maybe [Sort]
Maybe Text
Maybe CaseFilter
Text
domainId :: Text
sorts :: Maybe [Sort]
searchTerm :: Maybe Text
nextToken :: Maybe Text
maxResults :: Maybe Natural
filter' :: Maybe CaseFilter
fields :: Maybe [FieldIdentifier]
$sel:domainId:SearchCases' :: SearchCases -> Text
$sel:sorts:SearchCases' :: SearchCases -> Maybe [Sort]
$sel:searchTerm:SearchCases' :: SearchCases -> Maybe Text
$sel:nextToken:SearchCases' :: SearchCases -> Maybe Text
$sel:maxResults:SearchCases' :: SearchCases -> Maybe Natural
$sel:filter':SearchCases' :: SearchCases -> Maybe CaseFilter
$sel:fields:SearchCases' :: SearchCases -> Maybe [FieldIdentifier]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [FieldIdentifier]
fields
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe CaseFilter
filter'
      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 Maybe Text
searchTerm
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Sort]
sorts
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
domainId

instance Data.ToHeaders SearchCases where
  toHeaders :: SearchCases -> 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.ToJSON SearchCases where
  toJSON :: SearchCases -> Value
toJSON SearchCases' {Maybe Natural
Maybe [FieldIdentifier]
Maybe [Sort]
Maybe Text
Maybe CaseFilter
Text
domainId :: Text
sorts :: Maybe [Sort]
searchTerm :: Maybe Text
nextToken :: Maybe Text
maxResults :: Maybe Natural
filter' :: Maybe CaseFilter
fields :: Maybe [FieldIdentifier]
$sel:domainId:SearchCases' :: SearchCases -> Text
$sel:sorts:SearchCases' :: SearchCases -> Maybe [Sort]
$sel:searchTerm:SearchCases' :: SearchCases -> Maybe Text
$sel:nextToken:SearchCases' :: SearchCases -> Maybe Text
$sel:maxResults:SearchCases' :: SearchCases -> Maybe Natural
$sel:filter':SearchCases' :: SearchCases -> Maybe CaseFilter
$sel:fields:SearchCases' :: SearchCases -> Maybe [FieldIdentifier]
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"fields" 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 [FieldIdentifier]
fields,
            (Key
"filter" 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 CaseFilter
filter',
            (Key
"maxResults" 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 Natural
maxResults,
            (Key
"nextToken" 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
nextToken,
            (Key
"searchTerm" 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
searchTerm,
            (Key
"sorts" 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 [Sort]
sorts
          ]
      )

instance Data.ToPath SearchCases where
  toPath :: SearchCases -> ByteString
toPath SearchCases' {Maybe Natural
Maybe [FieldIdentifier]
Maybe [Sort]
Maybe Text
Maybe CaseFilter
Text
domainId :: Text
sorts :: Maybe [Sort]
searchTerm :: Maybe Text
nextToken :: Maybe Text
maxResults :: Maybe Natural
filter' :: Maybe CaseFilter
fields :: Maybe [FieldIdentifier]
$sel:domainId:SearchCases' :: SearchCases -> Text
$sel:sorts:SearchCases' :: SearchCases -> Maybe [Sort]
$sel:searchTerm:SearchCases' :: SearchCases -> Maybe Text
$sel:nextToken:SearchCases' :: SearchCases -> Maybe Text
$sel:maxResults:SearchCases' :: SearchCases -> Maybe Natural
$sel:filter':SearchCases' :: SearchCases -> Maybe CaseFilter
$sel:fields:SearchCases' :: SearchCases -> Maybe [FieldIdentifier]
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ByteString
"/domains/", forall a. ToByteString a => a -> ByteString
Data.toBS Text
domainId, ByteString
"/cases-search"]

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

-- | /See:/ 'newSearchCasesResponse' smart constructor.
data SearchCasesResponse = SearchCasesResponse'
  { -- | The token for the next set of results. This is null if there are no more
    -- results to return.
    SearchCasesResponse -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | The response's http status code.
    SearchCasesResponse -> Int
httpStatus :: Prelude.Int,
    -- | A list of case documents where each case contains the properties
    -- @CaseId@ and @Fields@ where each field is a complex union structure.
    SearchCasesResponse -> [SearchCasesResponseItem]
cases :: [SearchCasesResponseItem]
  }
  deriving (SearchCasesResponse -> SearchCasesResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SearchCasesResponse -> SearchCasesResponse -> Bool
$c/= :: SearchCasesResponse -> SearchCasesResponse -> Bool
== :: SearchCasesResponse -> SearchCasesResponse -> Bool
$c== :: SearchCasesResponse -> SearchCasesResponse -> Bool
Prelude.Eq, ReadPrec [SearchCasesResponse]
ReadPrec SearchCasesResponse
Int -> ReadS SearchCasesResponse
ReadS [SearchCasesResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [SearchCasesResponse]
$creadListPrec :: ReadPrec [SearchCasesResponse]
readPrec :: ReadPrec SearchCasesResponse
$creadPrec :: ReadPrec SearchCasesResponse
readList :: ReadS [SearchCasesResponse]
$creadList :: ReadS [SearchCasesResponse]
readsPrec :: Int -> ReadS SearchCasesResponse
$creadsPrec :: Int -> ReadS SearchCasesResponse
Prelude.Read, Int -> SearchCasesResponse -> ShowS
[SearchCasesResponse] -> ShowS
SearchCasesResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SearchCasesResponse] -> ShowS
$cshowList :: [SearchCasesResponse] -> ShowS
show :: SearchCasesResponse -> String
$cshow :: SearchCasesResponse -> String
showsPrec :: Int -> SearchCasesResponse -> ShowS
$cshowsPrec :: Int -> SearchCasesResponse -> ShowS
Prelude.Show, forall x. Rep SearchCasesResponse x -> SearchCasesResponse
forall x. SearchCasesResponse -> Rep SearchCasesResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep SearchCasesResponse x -> SearchCasesResponse
$cfrom :: forall x. SearchCasesResponse -> Rep SearchCasesResponse x
Prelude.Generic)

-- |
-- Create a value of 'SearchCasesResponse' 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', 'searchCasesResponse_nextToken' - The token for the next set of results. This is null if there are no more
-- results to return.
--
-- 'httpStatus', 'searchCasesResponse_httpStatus' - The response's http status code.
--
-- 'cases', 'searchCasesResponse_cases' - A list of case documents where each case contains the properties
-- @CaseId@ and @Fields@ where each field is a complex union structure.
newSearchCasesResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  SearchCasesResponse
newSearchCasesResponse :: Int -> SearchCasesResponse
newSearchCasesResponse Int
pHttpStatus_ =
  SearchCasesResponse'
    { $sel:nextToken:SearchCasesResponse' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:SearchCasesResponse' :: Int
httpStatus = Int
pHttpStatus_,
      $sel:cases:SearchCasesResponse' :: [SearchCasesResponseItem]
cases = forall a. Monoid a => a
Prelude.mempty
    }

-- | The token for the next set of results. This is null if there are no more
-- results to return.
searchCasesResponse_nextToken :: Lens.Lens' SearchCasesResponse (Prelude.Maybe Prelude.Text)
searchCasesResponse_nextToken :: Lens' SearchCasesResponse (Maybe Text)
searchCasesResponse_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SearchCasesResponse' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:SearchCasesResponse' :: SearchCasesResponse -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: SearchCasesResponse
s@SearchCasesResponse' {} Maybe Text
a -> SearchCasesResponse
s {$sel:nextToken:SearchCasesResponse' :: Maybe Text
nextToken = Maybe Text
a} :: SearchCasesResponse)

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

-- | A list of case documents where each case contains the properties
-- @CaseId@ and @Fields@ where each field is a complex union structure.
searchCasesResponse_cases :: Lens.Lens' SearchCasesResponse [SearchCasesResponseItem]
searchCasesResponse_cases :: Lens' SearchCasesResponse [SearchCasesResponseItem]
searchCasesResponse_cases = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SearchCasesResponse' {[SearchCasesResponseItem]
cases :: [SearchCasesResponseItem]
$sel:cases:SearchCasesResponse' :: SearchCasesResponse -> [SearchCasesResponseItem]
cases} -> [SearchCasesResponseItem]
cases) (\s :: SearchCasesResponse
s@SearchCasesResponse' {} [SearchCasesResponseItem]
a -> SearchCasesResponse
s {$sel:cases:SearchCasesResponse' :: [SearchCasesResponseItem]
cases = [SearchCasesResponseItem]
a} :: SearchCasesResponse) 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 SearchCasesResponse where
  rnf :: SearchCasesResponse -> ()
rnf SearchCasesResponse' {Int
[SearchCasesResponseItem]
Maybe Text
cases :: [SearchCasesResponseItem]
httpStatus :: Int
nextToken :: Maybe Text
$sel:cases:SearchCasesResponse' :: SearchCasesResponse -> [SearchCasesResponseItem]
$sel:httpStatus:SearchCasesResponse' :: SearchCasesResponse -> Int
$sel:nextToken:SearchCasesResponse' :: SearchCasesResponse -> 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 Int
httpStatus
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf [SearchCasesResponseItem]
cases