{-# 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.CustomerProfiles.ListProfileObjects
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Returns a list of objects associated with a profile of a given
-- ProfileObjectType.
module Amazonka.CustomerProfiles.ListProfileObjects
  ( -- * Creating a Request
    ListProfileObjects (..),
    newListProfileObjects,

    -- * Request Lenses
    listProfileObjects_maxResults,
    listProfileObjects_nextToken,
    listProfileObjects_objectFilter,
    listProfileObjects_domainName,
    listProfileObjects_objectTypeName,
    listProfileObjects_profileId,

    -- * Destructuring the Response
    ListProfileObjectsResponse (..),
    newListProfileObjectsResponse,

    -- * Response Lenses
    listProfileObjectsResponse_items,
    listProfileObjectsResponse_nextToken,
    listProfileObjectsResponse_httpStatus,
  )
where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import Amazonka.CustomerProfiles.Types
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:/ 'newListProfileObjects' smart constructor.
data ListProfileObjects = ListProfileObjects'
  { -- | The maximum number of objects returned per page.
    ListProfileObjects -> Maybe Natural
maxResults :: Prelude.Maybe Prelude.Natural,
    -- | The pagination token from the previous call to ListProfileObjects.
    ListProfileObjects -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | Applies a filter to the response to include profile objects with the
    -- specified index values. This filter is only supported for ObjectTypeName
    -- _asset, _case and _order.
    ListProfileObjects -> Maybe ObjectFilter
objectFilter :: Prelude.Maybe ObjectFilter,
    -- | The unique name of the domain.
    ListProfileObjects -> Text
domainName :: Prelude.Text,
    -- | The name of the profile object type.
    ListProfileObjects -> Text
objectTypeName :: Prelude.Text,
    -- | The unique identifier of a customer profile.
    ListProfileObjects -> Text
profileId :: Prelude.Text
  }
  deriving (ListProfileObjects -> ListProfileObjects -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListProfileObjects -> ListProfileObjects -> Bool
$c/= :: ListProfileObjects -> ListProfileObjects -> Bool
== :: ListProfileObjects -> ListProfileObjects -> Bool
$c== :: ListProfileObjects -> ListProfileObjects -> Bool
Prelude.Eq, ReadPrec [ListProfileObjects]
ReadPrec ListProfileObjects
Int -> ReadS ListProfileObjects
ReadS [ListProfileObjects]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListProfileObjects]
$creadListPrec :: ReadPrec [ListProfileObjects]
readPrec :: ReadPrec ListProfileObjects
$creadPrec :: ReadPrec ListProfileObjects
readList :: ReadS [ListProfileObjects]
$creadList :: ReadS [ListProfileObjects]
readsPrec :: Int -> ReadS ListProfileObjects
$creadsPrec :: Int -> ReadS ListProfileObjects
Prelude.Read, Int -> ListProfileObjects -> ShowS
[ListProfileObjects] -> ShowS
ListProfileObjects -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListProfileObjects] -> ShowS
$cshowList :: [ListProfileObjects] -> ShowS
show :: ListProfileObjects -> String
$cshow :: ListProfileObjects -> String
showsPrec :: Int -> ListProfileObjects -> ShowS
$cshowsPrec :: Int -> ListProfileObjects -> ShowS
Prelude.Show, forall x. Rep ListProfileObjects x -> ListProfileObjects
forall x. ListProfileObjects -> Rep ListProfileObjects x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ListProfileObjects x -> ListProfileObjects
$cfrom :: forall x. ListProfileObjects -> Rep ListProfileObjects x
Prelude.Generic)

-- |
-- Create a value of 'ListProfileObjects' 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', 'listProfileObjects_maxResults' - The maximum number of objects returned per page.
--
-- 'nextToken', 'listProfileObjects_nextToken' - The pagination token from the previous call to ListProfileObjects.
--
-- 'objectFilter', 'listProfileObjects_objectFilter' - Applies a filter to the response to include profile objects with the
-- specified index values. This filter is only supported for ObjectTypeName
-- _asset, _case and _order.
--
-- 'domainName', 'listProfileObjects_domainName' - The unique name of the domain.
--
-- 'objectTypeName', 'listProfileObjects_objectTypeName' - The name of the profile object type.
--
-- 'profileId', 'listProfileObjects_profileId' - The unique identifier of a customer profile.
newListProfileObjects ::
  -- | 'domainName'
  Prelude.Text ->
  -- | 'objectTypeName'
  Prelude.Text ->
  -- | 'profileId'
  Prelude.Text ->
  ListProfileObjects
newListProfileObjects :: Text -> Text -> Text -> ListProfileObjects
newListProfileObjects
  Text
pDomainName_
  Text
pObjectTypeName_
  Text
pProfileId_ =
    ListProfileObjects'
      { $sel:maxResults:ListProfileObjects' :: Maybe Natural
maxResults = forall a. Maybe a
Prelude.Nothing,
        $sel:nextToken:ListProfileObjects' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing,
        $sel:objectFilter:ListProfileObjects' :: Maybe ObjectFilter
objectFilter = forall a. Maybe a
Prelude.Nothing,
        $sel:domainName:ListProfileObjects' :: Text
domainName = Text
pDomainName_,
        $sel:objectTypeName:ListProfileObjects' :: Text
objectTypeName = Text
pObjectTypeName_,
        $sel:profileId:ListProfileObjects' :: Text
profileId = Text
pProfileId_
      }

-- | The maximum number of objects returned per page.
listProfileObjects_maxResults :: Lens.Lens' ListProfileObjects (Prelude.Maybe Prelude.Natural)
listProfileObjects_maxResults :: Lens' ListProfileObjects (Maybe Natural)
listProfileObjects_maxResults = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListProfileObjects' {Maybe Natural
maxResults :: Maybe Natural
$sel:maxResults:ListProfileObjects' :: ListProfileObjects -> Maybe Natural
maxResults} -> Maybe Natural
maxResults) (\s :: ListProfileObjects
s@ListProfileObjects' {} Maybe Natural
a -> ListProfileObjects
s {$sel:maxResults:ListProfileObjects' :: Maybe Natural
maxResults = Maybe Natural
a} :: ListProfileObjects)

-- | The pagination token from the previous call to ListProfileObjects.
listProfileObjects_nextToken :: Lens.Lens' ListProfileObjects (Prelude.Maybe Prelude.Text)
listProfileObjects_nextToken :: Lens' ListProfileObjects (Maybe Text)
listProfileObjects_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListProfileObjects' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:ListProfileObjects' :: ListProfileObjects -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: ListProfileObjects
s@ListProfileObjects' {} Maybe Text
a -> ListProfileObjects
s {$sel:nextToken:ListProfileObjects' :: Maybe Text
nextToken = Maybe Text
a} :: ListProfileObjects)

-- | Applies a filter to the response to include profile objects with the
-- specified index values. This filter is only supported for ObjectTypeName
-- _asset, _case and _order.
listProfileObjects_objectFilter :: Lens.Lens' ListProfileObjects (Prelude.Maybe ObjectFilter)
listProfileObjects_objectFilter :: Lens' ListProfileObjects (Maybe ObjectFilter)
listProfileObjects_objectFilter = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListProfileObjects' {Maybe ObjectFilter
objectFilter :: Maybe ObjectFilter
$sel:objectFilter:ListProfileObjects' :: ListProfileObjects -> Maybe ObjectFilter
objectFilter} -> Maybe ObjectFilter
objectFilter) (\s :: ListProfileObjects
s@ListProfileObjects' {} Maybe ObjectFilter
a -> ListProfileObjects
s {$sel:objectFilter:ListProfileObjects' :: Maybe ObjectFilter
objectFilter = Maybe ObjectFilter
a} :: ListProfileObjects)

-- | The unique name of the domain.
listProfileObjects_domainName :: Lens.Lens' ListProfileObjects Prelude.Text
listProfileObjects_domainName :: Lens' ListProfileObjects Text
listProfileObjects_domainName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListProfileObjects' {Text
domainName :: Text
$sel:domainName:ListProfileObjects' :: ListProfileObjects -> Text
domainName} -> Text
domainName) (\s :: ListProfileObjects
s@ListProfileObjects' {} Text
a -> ListProfileObjects
s {$sel:domainName:ListProfileObjects' :: Text
domainName = Text
a} :: ListProfileObjects)

-- | The name of the profile object type.
listProfileObjects_objectTypeName :: Lens.Lens' ListProfileObjects Prelude.Text
listProfileObjects_objectTypeName :: Lens' ListProfileObjects Text
listProfileObjects_objectTypeName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListProfileObjects' {Text
objectTypeName :: Text
$sel:objectTypeName:ListProfileObjects' :: ListProfileObjects -> Text
objectTypeName} -> Text
objectTypeName) (\s :: ListProfileObjects
s@ListProfileObjects' {} Text
a -> ListProfileObjects
s {$sel:objectTypeName:ListProfileObjects' :: Text
objectTypeName = Text
a} :: ListProfileObjects)

-- | The unique identifier of a customer profile.
listProfileObjects_profileId :: Lens.Lens' ListProfileObjects Prelude.Text
listProfileObjects_profileId :: Lens' ListProfileObjects Text
listProfileObjects_profileId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListProfileObjects' {Text
profileId :: Text
$sel:profileId:ListProfileObjects' :: ListProfileObjects -> Text
profileId} -> Text
profileId) (\s :: ListProfileObjects
s@ListProfileObjects' {} Text
a -> ListProfileObjects
s {$sel:profileId:ListProfileObjects' :: Text
profileId = Text
a} :: ListProfileObjects)

instance Core.AWSRequest ListProfileObjects where
  type
    AWSResponse ListProfileObjects =
      ListProfileObjectsResponse
  request :: (Service -> Service)
-> ListProfileObjects -> Request ListProfileObjects
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 ListProfileObjects
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse ListProfileObjects)))
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 [ListProfileObjectsItem]
-> Maybe Text -> Int -> ListProfileObjectsResponse
ListProfileObjectsResponse'
            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
"Items" 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 ListProfileObjects where
  hashWithSalt :: Int -> ListProfileObjects -> Int
hashWithSalt Int
_salt ListProfileObjects' {Maybe Natural
Maybe Text
Maybe ObjectFilter
Text
profileId :: Text
objectTypeName :: Text
domainName :: Text
objectFilter :: Maybe ObjectFilter
nextToken :: Maybe Text
maxResults :: Maybe Natural
$sel:profileId:ListProfileObjects' :: ListProfileObjects -> Text
$sel:objectTypeName:ListProfileObjects' :: ListProfileObjects -> Text
$sel:domainName:ListProfileObjects' :: ListProfileObjects -> Text
$sel:objectFilter:ListProfileObjects' :: ListProfileObjects -> Maybe ObjectFilter
$sel:nextToken:ListProfileObjects' :: ListProfileObjects -> Maybe Text
$sel:maxResults:ListProfileObjects' :: ListProfileObjects -> 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 ObjectFilter
objectFilter
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
domainName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
objectTypeName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
profileId

instance Prelude.NFData ListProfileObjects where
  rnf :: ListProfileObjects -> ()
rnf ListProfileObjects' {Maybe Natural
Maybe Text
Maybe ObjectFilter
Text
profileId :: Text
objectTypeName :: Text
domainName :: Text
objectFilter :: Maybe ObjectFilter
nextToken :: Maybe Text
maxResults :: Maybe Natural
$sel:profileId:ListProfileObjects' :: ListProfileObjects -> Text
$sel:objectTypeName:ListProfileObjects' :: ListProfileObjects -> Text
$sel:domainName:ListProfileObjects' :: ListProfileObjects -> Text
$sel:objectFilter:ListProfileObjects' :: ListProfileObjects -> Maybe ObjectFilter
$sel:nextToken:ListProfileObjects' :: ListProfileObjects -> Maybe Text
$sel:maxResults:ListProfileObjects' :: ListProfileObjects -> 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 ObjectFilter
objectFilter
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
domainName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
objectTypeName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
profileId

instance Data.ToHeaders ListProfileObjects where
  toHeaders :: ListProfileObjects -> 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 ListProfileObjects where
  toJSON :: ListProfileObjects -> Value
toJSON ListProfileObjects' {Maybe Natural
Maybe Text
Maybe ObjectFilter
Text
profileId :: Text
objectTypeName :: Text
domainName :: Text
objectFilter :: Maybe ObjectFilter
nextToken :: Maybe Text
maxResults :: Maybe Natural
$sel:profileId:ListProfileObjects' :: ListProfileObjects -> Text
$sel:objectTypeName:ListProfileObjects' :: ListProfileObjects -> Text
$sel:domainName:ListProfileObjects' :: ListProfileObjects -> Text
$sel:objectFilter:ListProfileObjects' :: ListProfileObjects -> Maybe ObjectFilter
$sel:nextToken:ListProfileObjects' :: ListProfileObjects -> Maybe Text
$sel:maxResults:ListProfileObjects' :: ListProfileObjects -> Maybe Natural
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"ObjectFilter" 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 ObjectFilter
objectFilter,
            forall a. a -> Maybe a
Prelude.Just
              (Key
"ObjectTypeName" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
objectTypeName),
            forall a. a -> Maybe a
Prelude.Just (Key
"ProfileId" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
profileId)
          ]
      )

instance Data.ToPath ListProfileObjects where
  toPath :: ListProfileObjects -> ByteString
toPath ListProfileObjects' {Maybe Natural
Maybe Text
Maybe ObjectFilter
Text
profileId :: Text
objectTypeName :: Text
domainName :: Text
objectFilter :: Maybe ObjectFilter
nextToken :: Maybe Text
maxResults :: Maybe Natural
$sel:profileId:ListProfileObjects' :: ListProfileObjects -> Text
$sel:objectTypeName:ListProfileObjects' :: ListProfileObjects -> Text
$sel:domainName:ListProfileObjects' :: ListProfileObjects -> Text
$sel:objectFilter:ListProfileObjects' :: ListProfileObjects -> Maybe ObjectFilter
$sel:nextToken:ListProfileObjects' :: ListProfileObjects -> Maybe Text
$sel:maxResults:ListProfileObjects' :: ListProfileObjects -> Maybe Natural
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"/domains/",
        forall a. ToByteString a => a -> ByteString
Data.toBS Text
domainName,
        ByteString
"/profiles/objects"
      ]

instance Data.ToQuery ListProfileObjects where
  toQuery :: ListProfileObjects -> QueryString
toQuery ListProfileObjects' {Maybe Natural
Maybe Text
Maybe ObjectFilter
Text
profileId :: Text
objectTypeName :: Text
domainName :: Text
objectFilter :: Maybe ObjectFilter
nextToken :: Maybe Text
maxResults :: Maybe Natural
$sel:profileId:ListProfileObjects' :: ListProfileObjects -> Text
$sel:objectTypeName:ListProfileObjects' :: ListProfileObjects -> Text
$sel:domainName:ListProfileObjects' :: ListProfileObjects -> Text
$sel:objectFilter:ListProfileObjects' :: ListProfileObjects -> Maybe ObjectFilter
$sel:nextToken:ListProfileObjects' :: ListProfileObjects -> Maybe Text
$sel:maxResults:ListProfileObjects' :: ListProfileObjects -> Maybe Natural
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"max-results" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Natural
maxResults,
        ByteString
"next-token" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Text
nextToken
      ]

-- | /See:/ 'newListProfileObjectsResponse' smart constructor.
data ListProfileObjectsResponse = ListProfileObjectsResponse'
  { -- | The list of ListProfileObject instances.
    ListProfileObjectsResponse -> Maybe [ListProfileObjectsItem]
items :: Prelude.Maybe [ListProfileObjectsItem],
    -- | The pagination token from the previous call to ListProfileObjects.
    ListProfileObjectsResponse -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | The response's http status code.
    ListProfileObjectsResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (ListProfileObjectsResponse -> ListProfileObjectsResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListProfileObjectsResponse -> ListProfileObjectsResponse -> Bool
$c/= :: ListProfileObjectsResponse -> ListProfileObjectsResponse -> Bool
== :: ListProfileObjectsResponse -> ListProfileObjectsResponse -> Bool
$c== :: ListProfileObjectsResponse -> ListProfileObjectsResponse -> Bool
Prelude.Eq, ReadPrec [ListProfileObjectsResponse]
ReadPrec ListProfileObjectsResponse
Int -> ReadS ListProfileObjectsResponse
ReadS [ListProfileObjectsResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListProfileObjectsResponse]
$creadListPrec :: ReadPrec [ListProfileObjectsResponse]
readPrec :: ReadPrec ListProfileObjectsResponse
$creadPrec :: ReadPrec ListProfileObjectsResponse
readList :: ReadS [ListProfileObjectsResponse]
$creadList :: ReadS [ListProfileObjectsResponse]
readsPrec :: Int -> ReadS ListProfileObjectsResponse
$creadsPrec :: Int -> ReadS ListProfileObjectsResponse
Prelude.Read, Int -> ListProfileObjectsResponse -> ShowS
[ListProfileObjectsResponse] -> ShowS
ListProfileObjectsResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListProfileObjectsResponse] -> ShowS
$cshowList :: [ListProfileObjectsResponse] -> ShowS
show :: ListProfileObjectsResponse -> String
$cshow :: ListProfileObjectsResponse -> String
showsPrec :: Int -> ListProfileObjectsResponse -> ShowS
$cshowsPrec :: Int -> ListProfileObjectsResponse -> ShowS
Prelude.Show, forall x.
Rep ListProfileObjectsResponse x -> ListProfileObjectsResponse
forall x.
ListProfileObjectsResponse -> Rep ListProfileObjectsResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep ListProfileObjectsResponse x -> ListProfileObjectsResponse
$cfrom :: forall x.
ListProfileObjectsResponse -> Rep ListProfileObjectsResponse x
Prelude.Generic)

-- |
-- Create a value of 'ListProfileObjectsResponse' 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:
--
-- 'items', 'listProfileObjectsResponse_items' - The list of ListProfileObject instances.
--
-- 'nextToken', 'listProfileObjectsResponse_nextToken' - The pagination token from the previous call to ListProfileObjects.
--
-- 'httpStatus', 'listProfileObjectsResponse_httpStatus' - The response's http status code.
newListProfileObjectsResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  ListProfileObjectsResponse
newListProfileObjectsResponse :: Int -> ListProfileObjectsResponse
newListProfileObjectsResponse Int
pHttpStatus_ =
  ListProfileObjectsResponse'
    { $sel:items:ListProfileObjectsResponse' :: Maybe [ListProfileObjectsItem]
items =
        forall a. Maybe a
Prelude.Nothing,
      $sel:nextToken:ListProfileObjectsResponse' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:ListProfileObjectsResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The list of ListProfileObject instances.
listProfileObjectsResponse_items :: Lens.Lens' ListProfileObjectsResponse (Prelude.Maybe [ListProfileObjectsItem])
listProfileObjectsResponse_items :: Lens' ListProfileObjectsResponse (Maybe [ListProfileObjectsItem])
listProfileObjectsResponse_items = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListProfileObjectsResponse' {Maybe [ListProfileObjectsItem]
items :: Maybe [ListProfileObjectsItem]
$sel:items:ListProfileObjectsResponse' :: ListProfileObjectsResponse -> Maybe [ListProfileObjectsItem]
items} -> Maybe [ListProfileObjectsItem]
items) (\s :: ListProfileObjectsResponse
s@ListProfileObjectsResponse' {} Maybe [ListProfileObjectsItem]
a -> ListProfileObjectsResponse
s {$sel:items:ListProfileObjectsResponse' :: Maybe [ListProfileObjectsItem]
items = Maybe [ListProfileObjectsItem]
a} :: ListProfileObjectsResponse) 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 pagination token from the previous call to ListProfileObjects.
listProfileObjectsResponse_nextToken :: Lens.Lens' ListProfileObjectsResponse (Prelude.Maybe Prelude.Text)
listProfileObjectsResponse_nextToken :: Lens' ListProfileObjectsResponse (Maybe Text)
listProfileObjectsResponse_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListProfileObjectsResponse' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:ListProfileObjectsResponse' :: ListProfileObjectsResponse -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: ListProfileObjectsResponse
s@ListProfileObjectsResponse' {} Maybe Text
a -> ListProfileObjectsResponse
s {$sel:nextToken:ListProfileObjectsResponse' :: Maybe Text
nextToken = Maybe Text
a} :: ListProfileObjectsResponse)

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

instance Prelude.NFData ListProfileObjectsResponse where
  rnf :: ListProfileObjectsResponse -> ()
rnf ListProfileObjectsResponse' {Int
Maybe [ListProfileObjectsItem]
Maybe Text
httpStatus :: Int
nextToken :: Maybe Text
items :: Maybe [ListProfileObjectsItem]
$sel:httpStatus:ListProfileObjectsResponse' :: ListProfileObjectsResponse -> Int
$sel:nextToken:ListProfileObjectsResponse' :: ListProfileObjectsResponse -> Maybe Text
$sel:items:ListProfileObjectsResponse' :: ListProfileObjectsResponse -> Maybe [ListProfileObjectsItem]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [ListProfileObjectsItem]
items
      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