{-# 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.CloudDirectory.ListObjectParentPaths
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Retrieves all available parent paths for any object type such as node,
-- leaf node, policy node, and index node objects. For more information
-- about objects, see
-- <https://docs.aws.amazon.com/clouddirectory/latest/developerguide/key_concepts_directorystructure.html Directory Structure>.
--
-- Use this API to evaluate all parents for an object. The call returns all
-- objects from the root of the directory up to the requested object. The
-- API returns the number of paths based on user-defined @MaxResults@, in
-- case there are multiple paths to the parent. The order of the paths and
-- nodes returned is consistent among multiple API calls unless the objects
-- are deleted or moved. Paths not leading to the directory root are
-- ignored from the target object.
--
-- This operation returns paginated results.
module Amazonka.CloudDirectory.ListObjectParentPaths
  ( -- * Creating a Request
    ListObjectParentPaths (..),
    newListObjectParentPaths,

    -- * Request Lenses
    listObjectParentPaths_maxResults,
    listObjectParentPaths_nextToken,
    listObjectParentPaths_directoryArn,
    listObjectParentPaths_objectReference,

    -- * Destructuring the Response
    ListObjectParentPathsResponse (..),
    newListObjectParentPathsResponse,

    -- * Response Lenses
    listObjectParentPathsResponse_nextToken,
    listObjectParentPathsResponse_pathToObjectIdentifiersList,
    listObjectParentPathsResponse_httpStatus,
  )
where

import Amazonka.CloudDirectory.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:/ 'newListObjectParentPaths' smart constructor.
data ListObjectParentPaths = ListObjectParentPaths'
  { -- | The maximum number of items to be retrieved in a single call. This is an
    -- approximate number.
    ListObjectParentPaths -> Maybe Natural
maxResults :: Prelude.Maybe Prelude.Natural,
    -- | The pagination token.
    ListObjectParentPaths -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | The ARN of the directory to which the parent path applies.
    ListObjectParentPaths -> Text
directoryArn :: Prelude.Text,
    -- | The reference that identifies the object whose parent paths are listed.
    ListObjectParentPaths -> ObjectReference
objectReference :: ObjectReference
  }
  deriving (ListObjectParentPaths -> ListObjectParentPaths -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListObjectParentPaths -> ListObjectParentPaths -> Bool
$c/= :: ListObjectParentPaths -> ListObjectParentPaths -> Bool
== :: ListObjectParentPaths -> ListObjectParentPaths -> Bool
$c== :: ListObjectParentPaths -> ListObjectParentPaths -> Bool
Prelude.Eq, ReadPrec [ListObjectParentPaths]
ReadPrec ListObjectParentPaths
Int -> ReadS ListObjectParentPaths
ReadS [ListObjectParentPaths]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListObjectParentPaths]
$creadListPrec :: ReadPrec [ListObjectParentPaths]
readPrec :: ReadPrec ListObjectParentPaths
$creadPrec :: ReadPrec ListObjectParentPaths
readList :: ReadS [ListObjectParentPaths]
$creadList :: ReadS [ListObjectParentPaths]
readsPrec :: Int -> ReadS ListObjectParentPaths
$creadsPrec :: Int -> ReadS ListObjectParentPaths
Prelude.Read, Int -> ListObjectParentPaths -> ShowS
[ListObjectParentPaths] -> ShowS
ListObjectParentPaths -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListObjectParentPaths] -> ShowS
$cshowList :: [ListObjectParentPaths] -> ShowS
show :: ListObjectParentPaths -> String
$cshow :: ListObjectParentPaths -> String
showsPrec :: Int -> ListObjectParentPaths -> ShowS
$cshowsPrec :: Int -> ListObjectParentPaths -> ShowS
Prelude.Show, forall x. Rep ListObjectParentPaths x -> ListObjectParentPaths
forall x. ListObjectParentPaths -> Rep ListObjectParentPaths x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ListObjectParentPaths x -> ListObjectParentPaths
$cfrom :: forall x. ListObjectParentPaths -> Rep ListObjectParentPaths x
Prelude.Generic)

-- |
-- Create a value of 'ListObjectParentPaths' 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', 'listObjectParentPaths_maxResults' - The maximum number of items to be retrieved in a single call. This is an
-- approximate number.
--
-- 'nextToken', 'listObjectParentPaths_nextToken' - The pagination token.
--
-- 'directoryArn', 'listObjectParentPaths_directoryArn' - The ARN of the directory to which the parent path applies.
--
-- 'objectReference', 'listObjectParentPaths_objectReference' - The reference that identifies the object whose parent paths are listed.
newListObjectParentPaths ::
  -- | 'directoryArn'
  Prelude.Text ->
  -- | 'objectReference'
  ObjectReference ->
  ListObjectParentPaths
newListObjectParentPaths :: Text -> ObjectReference -> ListObjectParentPaths
newListObjectParentPaths
  Text
pDirectoryArn_
  ObjectReference
pObjectReference_ =
    ListObjectParentPaths'
      { $sel:maxResults:ListObjectParentPaths' :: Maybe Natural
maxResults =
          forall a. Maybe a
Prelude.Nothing,
        $sel:nextToken:ListObjectParentPaths' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing,
        $sel:directoryArn:ListObjectParentPaths' :: Text
directoryArn = Text
pDirectoryArn_,
        $sel:objectReference:ListObjectParentPaths' :: ObjectReference
objectReference = ObjectReference
pObjectReference_
      }

-- | The maximum number of items to be retrieved in a single call. This is an
-- approximate number.
listObjectParentPaths_maxResults :: Lens.Lens' ListObjectParentPaths (Prelude.Maybe Prelude.Natural)
listObjectParentPaths_maxResults :: Lens' ListObjectParentPaths (Maybe Natural)
listObjectParentPaths_maxResults = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListObjectParentPaths' {Maybe Natural
maxResults :: Maybe Natural
$sel:maxResults:ListObjectParentPaths' :: ListObjectParentPaths -> Maybe Natural
maxResults} -> Maybe Natural
maxResults) (\s :: ListObjectParentPaths
s@ListObjectParentPaths' {} Maybe Natural
a -> ListObjectParentPaths
s {$sel:maxResults:ListObjectParentPaths' :: Maybe Natural
maxResults = Maybe Natural
a} :: ListObjectParentPaths)

-- | The pagination token.
listObjectParentPaths_nextToken :: Lens.Lens' ListObjectParentPaths (Prelude.Maybe Prelude.Text)
listObjectParentPaths_nextToken :: Lens' ListObjectParentPaths (Maybe Text)
listObjectParentPaths_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListObjectParentPaths' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:ListObjectParentPaths' :: ListObjectParentPaths -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: ListObjectParentPaths
s@ListObjectParentPaths' {} Maybe Text
a -> ListObjectParentPaths
s {$sel:nextToken:ListObjectParentPaths' :: Maybe Text
nextToken = Maybe Text
a} :: ListObjectParentPaths)

-- | The ARN of the directory to which the parent path applies.
listObjectParentPaths_directoryArn :: Lens.Lens' ListObjectParentPaths Prelude.Text
listObjectParentPaths_directoryArn :: Lens' ListObjectParentPaths Text
listObjectParentPaths_directoryArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListObjectParentPaths' {Text
directoryArn :: Text
$sel:directoryArn:ListObjectParentPaths' :: ListObjectParentPaths -> Text
directoryArn} -> Text
directoryArn) (\s :: ListObjectParentPaths
s@ListObjectParentPaths' {} Text
a -> ListObjectParentPaths
s {$sel:directoryArn:ListObjectParentPaths' :: Text
directoryArn = Text
a} :: ListObjectParentPaths)

-- | The reference that identifies the object whose parent paths are listed.
listObjectParentPaths_objectReference :: Lens.Lens' ListObjectParentPaths ObjectReference
listObjectParentPaths_objectReference :: Lens' ListObjectParentPaths ObjectReference
listObjectParentPaths_objectReference = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListObjectParentPaths' {ObjectReference
objectReference :: ObjectReference
$sel:objectReference:ListObjectParentPaths' :: ListObjectParentPaths -> ObjectReference
objectReference} -> ObjectReference
objectReference) (\s :: ListObjectParentPaths
s@ListObjectParentPaths' {} ObjectReference
a -> ListObjectParentPaths
s {$sel:objectReference:ListObjectParentPaths' :: ObjectReference
objectReference = ObjectReference
a} :: ListObjectParentPaths)

instance Core.AWSPager ListObjectParentPaths where
  page :: ListObjectParentPaths
-> AWSResponse ListObjectParentPaths -> Maybe ListObjectParentPaths
page ListObjectParentPaths
rq AWSResponse ListObjectParentPaths
rs
    | forall a. AWSTruncated a => a -> Bool
Core.stop
        ( AWSResponse ListObjectParentPaths
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' ListObjectParentPathsResponse (Maybe Text)
listObjectParentPathsResponse_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 ListObjectParentPaths
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens'
  ListObjectParentPathsResponse (Maybe [PathToObjectIdentifiers])
listObjectParentPathsResponse_pathToObjectIdentifiersList
            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.$ ListObjectParentPaths
rq
          forall a b. a -> (a -> b) -> b
Prelude.& Lens' ListObjectParentPaths (Maybe Text)
listObjectParentPaths_nextToken
          forall s t a b. ASetter s t a b -> b -> s -> t
Lens..~ AWSResponse ListObjectParentPaths
rs
          forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' ListObjectParentPathsResponse (Maybe Text)
listObjectParentPathsResponse_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 ListObjectParentPaths where
  type
    AWSResponse ListObjectParentPaths =
      ListObjectParentPathsResponse
  request :: (Service -> Service)
-> ListObjectParentPaths -> Request ListObjectParentPaths
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 ListObjectParentPaths
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse ListObjectParentPaths)))
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 [PathToObjectIdentifiers]
-> Int
-> ListObjectParentPathsResponse
ListObjectParentPathsResponse'
            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
"PathToObjectIdentifiersList"
                            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 ListObjectParentPaths where
  hashWithSalt :: Int -> ListObjectParentPaths -> Int
hashWithSalt Int
_salt ListObjectParentPaths' {Maybe Natural
Maybe Text
Text
ObjectReference
objectReference :: ObjectReference
directoryArn :: Text
nextToken :: Maybe Text
maxResults :: Maybe Natural
$sel:objectReference:ListObjectParentPaths' :: ListObjectParentPaths -> ObjectReference
$sel:directoryArn:ListObjectParentPaths' :: ListObjectParentPaths -> Text
$sel:nextToken:ListObjectParentPaths' :: ListObjectParentPaths -> Maybe Text
$sel:maxResults:ListObjectParentPaths' :: ListObjectParentPaths -> 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` Text
directoryArn
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` ObjectReference
objectReference

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

instance Data.ToHeaders ListObjectParentPaths where
  toHeaders :: ListObjectParentPaths -> ResponseHeaders
toHeaders ListObjectParentPaths' {Maybe Natural
Maybe Text
Text
ObjectReference
objectReference :: ObjectReference
directoryArn :: Text
nextToken :: Maybe Text
maxResults :: Maybe Natural
$sel:objectReference:ListObjectParentPaths' :: ListObjectParentPaths -> ObjectReference
$sel:directoryArn:ListObjectParentPaths' :: ListObjectParentPaths -> Text
$sel:nextToken:ListObjectParentPaths' :: ListObjectParentPaths -> Maybe Text
$sel:maxResults:ListObjectParentPaths' :: ListObjectParentPaths -> Maybe Natural
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [HeaderName
"x-amz-data-partition" forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# Text
directoryArn]

instance Data.ToJSON ListObjectParentPaths where
  toJSON :: ListObjectParentPaths -> Value
toJSON ListObjectParentPaths' {Maybe Natural
Maybe Text
Text
ObjectReference
objectReference :: ObjectReference
directoryArn :: Text
nextToken :: Maybe Text
maxResults :: Maybe Natural
$sel:objectReference:ListObjectParentPaths' :: ListObjectParentPaths -> ObjectReference
$sel:directoryArn:ListObjectParentPaths' :: ListObjectParentPaths -> Text
$sel:nextToken:ListObjectParentPaths' :: ListObjectParentPaths -> Maybe Text
$sel:maxResults:ListObjectParentPaths' :: ListObjectParentPaths -> Maybe Natural
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (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,
            forall a. a -> Maybe a
Prelude.Just
              (Key
"ObjectReference" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= ObjectReference
objectReference)
          ]
      )

instance Data.ToPath ListObjectParentPaths where
  toPath :: ListObjectParentPaths -> ByteString
toPath =
    forall a b. a -> b -> a
Prelude.const
      ByteString
"/amazonclouddirectory/2017-01-11/object/parentpaths"

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

-- | /See:/ 'newListObjectParentPathsResponse' smart constructor.
data ListObjectParentPathsResponse = ListObjectParentPathsResponse'
  { -- | The pagination token.
    ListObjectParentPathsResponse -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | Returns the path to the @ObjectIdentifiers@ that are associated with the
    -- directory.
    ListObjectParentPathsResponse -> Maybe [PathToObjectIdentifiers]
pathToObjectIdentifiersList :: Prelude.Maybe [PathToObjectIdentifiers],
    -- | The response's http status code.
    ListObjectParentPathsResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (ListObjectParentPathsResponse
-> ListObjectParentPathsResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListObjectParentPathsResponse
-> ListObjectParentPathsResponse -> Bool
$c/= :: ListObjectParentPathsResponse
-> ListObjectParentPathsResponse -> Bool
== :: ListObjectParentPathsResponse
-> ListObjectParentPathsResponse -> Bool
$c== :: ListObjectParentPathsResponse
-> ListObjectParentPathsResponse -> Bool
Prelude.Eq, ReadPrec [ListObjectParentPathsResponse]
ReadPrec ListObjectParentPathsResponse
Int -> ReadS ListObjectParentPathsResponse
ReadS [ListObjectParentPathsResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListObjectParentPathsResponse]
$creadListPrec :: ReadPrec [ListObjectParentPathsResponse]
readPrec :: ReadPrec ListObjectParentPathsResponse
$creadPrec :: ReadPrec ListObjectParentPathsResponse
readList :: ReadS [ListObjectParentPathsResponse]
$creadList :: ReadS [ListObjectParentPathsResponse]
readsPrec :: Int -> ReadS ListObjectParentPathsResponse
$creadsPrec :: Int -> ReadS ListObjectParentPathsResponse
Prelude.Read, Int -> ListObjectParentPathsResponse -> ShowS
[ListObjectParentPathsResponse] -> ShowS
ListObjectParentPathsResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListObjectParentPathsResponse] -> ShowS
$cshowList :: [ListObjectParentPathsResponse] -> ShowS
show :: ListObjectParentPathsResponse -> String
$cshow :: ListObjectParentPathsResponse -> String
showsPrec :: Int -> ListObjectParentPathsResponse -> ShowS
$cshowsPrec :: Int -> ListObjectParentPathsResponse -> ShowS
Prelude.Show, forall x.
Rep ListObjectParentPathsResponse x
-> ListObjectParentPathsResponse
forall x.
ListObjectParentPathsResponse
-> Rep ListObjectParentPathsResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep ListObjectParentPathsResponse x
-> ListObjectParentPathsResponse
$cfrom :: forall x.
ListObjectParentPathsResponse
-> Rep ListObjectParentPathsResponse x
Prelude.Generic)

-- |
-- Create a value of 'ListObjectParentPathsResponse' 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', 'listObjectParentPathsResponse_nextToken' - The pagination token.
--
-- 'pathToObjectIdentifiersList', 'listObjectParentPathsResponse_pathToObjectIdentifiersList' - Returns the path to the @ObjectIdentifiers@ that are associated with the
-- directory.
--
-- 'httpStatus', 'listObjectParentPathsResponse_httpStatus' - The response's http status code.
newListObjectParentPathsResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  ListObjectParentPathsResponse
newListObjectParentPathsResponse :: Int -> ListObjectParentPathsResponse
newListObjectParentPathsResponse Int
pHttpStatus_ =
  ListObjectParentPathsResponse'
    { $sel:nextToken:ListObjectParentPathsResponse' :: Maybe Text
nextToken =
        forall a. Maybe a
Prelude.Nothing,
      $sel:pathToObjectIdentifiersList:ListObjectParentPathsResponse' :: Maybe [PathToObjectIdentifiers]
pathToObjectIdentifiersList =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:ListObjectParentPathsResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The pagination token.
listObjectParentPathsResponse_nextToken :: Lens.Lens' ListObjectParentPathsResponse (Prelude.Maybe Prelude.Text)
listObjectParentPathsResponse_nextToken :: Lens' ListObjectParentPathsResponse (Maybe Text)
listObjectParentPathsResponse_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListObjectParentPathsResponse' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:ListObjectParentPathsResponse' :: ListObjectParentPathsResponse -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: ListObjectParentPathsResponse
s@ListObjectParentPathsResponse' {} Maybe Text
a -> ListObjectParentPathsResponse
s {$sel:nextToken:ListObjectParentPathsResponse' :: Maybe Text
nextToken = Maybe Text
a} :: ListObjectParentPathsResponse)

-- | Returns the path to the @ObjectIdentifiers@ that are associated with the
-- directory.
listObjectParentPathsResponse_pathToObjectIdentifiersList :: Lens.Lens' ListObjectParentPathsResponse (Prelude.Maybe [PathToObjectIdentifiers])
listObjectParentPathsResponse_pathToObjectIdentifiersList :: Lens'
  ListObjectParentPathsResponse (Maybe [PathToObjectIdentifiers])
listObjectParentPathsResponse_pathToObjectIdentifiersList = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListObjectParentPathsResponse' {Maybe [PathToObjectIdentifiers]
pathToObjectIdentifiersList :: Maybe [PathToObjectIdentifiers]
$sel:pathToObjectIdentifiersList:ListObjectParentPathsResponse' :: ListObjectParentPathsResponse -> Maybe [PathToObjectIdentifiers]
pathToObjectIdentifiersList} -> Maybe [PathToObjectIdentifiers]
pathToObjectIdentifiersList) (\s :: ListObjectParentPathsResponse
s@ListObjectParentPathsResponse' {} Maybe [PathToObjectIdentifiers]
a -> ListObjectParentPathsResponse
s {$sel:pathToObjectIdentifiersList:ListObjectParentPathsResponse' :: Maybe [PathToObjectIdentifiers]
pathToObjectIdentifiersList = Maybe [PathToObjectIdentifiers]
a} :: ListObjectParentPathsResponse) 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.
listObjectParentPathsResponse_httpStatus :: Lens.Lens' ListObjectParentPathsResponse Prelude.Int
listObjectParentPathsResponse_httpStatus :: Lens' ListObjectParentPathsResponse Int
listObjectParentPathsResponse_httpStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListObjectParentPathsResponse' {Int
httpStatus :: Int
$sel:httpStatus:ListObjectParentPathsResponse' :: ListObjectParentPathsResponse -> Int
httpStatus} -> Int
httpStatus) (\s :: ListObjectParentPathsResponse
s@ListObjectParentPathsResponse' {} Int
a -> ListObjectParentPathsResponse
s {$sel:httpStatus:ListObjectParentPathsResponse' :: Int
httpStatus = Int
a} :: ListObjectParentPathsResponse)

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