{-# 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.Nimble.ListStudioMembers
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Get all users in a given studio membership.
--
-- @ListStudioMembers@ only returns admin members.
--
-- This operation returns paginated results.
module Amazonka.Nimble.ListStudioMembers
  ( -- * Creating a Request
    ListStudioMembers (..),
    newListStudioMembers,

    -- * Request Lenses
    listStudioMembers_maxResults,
    listStudioMembers_nextToken,
    listStudioMembers_studioId,

    -- * Destructuring the Response
    ListStudioMembersResponse (..),
    newListStudioMembersResponse,

    -- * Response Lenses
    listStudioMembersResponse_members,
    listStudioMembersResponse_nextToken,
    listStudioMembersResponse_httpStatus,
  )
where

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

-- | /See:/ 'newListStudioMembers' smart constructor.
data ListStudioMembers = ListStudioMembers'
  { -- | The max number of results to return in the response.
    ListStudioMembers -> Maybe Natural
maxResults :: Prelude.Maybe Prelude.Natural,
    -- | The token for the next set of results, or null if there are no more
    -- results.
    ListStudioMembers -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | The studio ID.
    ListStudioMembers -> Text
studioId :: Prelude.Text
  }
  deriving (ListStudioMembers -> ListStudioMembers -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListStudioMembers -> ListStudioMembers -> Bool
$c/= :: ListStudioMembers -> ListStudioMembers -> Bool
== :: ListStudioMembers -> ListStudioMembers -> Bool
$c== :: ListStudioMembers -> ListStudioMembers -> Bool
Prelude.Eq, ReadPrec [ListStudioMembers]
ReadPrec ListStudioMembers
Int -> ReadS ListStudioMembers
ReadS [ListStudioMembers]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListStudioMembers]
$creadListPrec :: ReadPrec [ListStudioMembers]
readPrec :: ReadPrec ListStudioMembers
$creadPrec :: ReadPrec ListStudioMembers
readList :: ReadS [ListStudioMembers]
$creadList :: ReadS [ListStudioMembers]
readsPrec :: Int -> ReadS ListStudioMembers
$creadsPrec :: Int -> ReadS ListStudioMembers
Prelude.Read, Int -> ListStudioMembers -> ShowS
[ListStudioMembers] -> ShowS
ListStudioMembers -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListStudioMembers] -> ShowS
$cshowList :: [ListStudioMembers] -> ShowS
show :: ListStudioMembers -> String
$cshow :: ListStudioMembers -> String
showsPrec :: Int -> ListStudioMembers -> ShowS
$cshowsPrec :: Int -> ListStudioMembers -> ShowS
Prelude.Show, forall x. Rep ListStudioMembers x -> ListStudioMembers
forall x. ListStudioMembers -> Rep ListStudioMembers x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ListStudioMembers x -> ListStudioMembers
$cfrom :: forall x. ListStudioMembers -> Rep ListStudioMembers x
Prelude.Generic)

-- |
-- Create a value of 'ListStudioMembers' 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', 'listStudioMembers_maxResults' - The max number of results to return in the response.
--
-- 'nextToken', 'listStudioMembers_nextToken' - The token for the next set of results, or null if there are no more
-- results.
--
-- 'studioId', 'listStudioMembers_studioId' - The studio ID.
newListStudioMembers ::
  -- | 'studioId'
  Prelude.Text ->
  ListStudioMembers
newListStudioMembers :: Text -> ListStudioMembers
newListStudioMembers Text
pStudioId_ =
  ListStudioMembers'
    { $sel:maxResults:ListStudioMembers' :: Maybe Natural
maxResults = forall a. Maybe a
Prelude.Nothing,
      $sel:nextToken:ListStudioMembers' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing,
      $sel:studioId:ListStudioMembers' :: Text
studioId = Text
pStudioId_
    }

-- | The max number of results to return in the response.
listStudioMembers_maxResults :: Lens.Lens' ListStudioMembers (Prelude.Maybe Prelude.Natural)
listStudioMembers_maxResults :: Lens' ListStudioMembers (Maybe Natural)
listStudioMembers_maxResults = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListStudioMembers' {Maybe Natural
maxResults :: Maybe Natural
$sel:maxResults:ListStudioMembers' :: ListStudioMembers -> Maybe Natural
maxResults} -> Maybe Natural
maxResults) (\s :: ListStudioMembers
s@ListStudioMembers' {} Maybe Natural
a -> ListStudioMembers
s {$sel:maxResults:ListStudioMembers' :: Maybe Natural
maxResults = Maybe Natural
a} :: ListStudioMembers)

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

-- | The studio ID.
listStudioMembers_studioId :: Lens.Lens' ListStudioMembers Prelude.Text
listStudioMembers_studioId :: Lens' ListStudioMembers Text
listStudioMembers_studioId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListStudioMembers' {Text
studioId :: Text
$sel:studioId:ListStudioMembers' :: ListStudioMembers -> Text
studioId} -> Text
studioId) (\s :: ListStudioMembers
s@ListStudioMembers' {} Text
a -> ListStudioMembers
s {$sel:studioId:ListStudioMembers' :: Text
studioId = Text
a} :: ListStudioMembers)

instance Core.AWSPager ListStudioMembers where
  page :: ListStudioMembers
-> AWSResponse ListStudioMembers -> Maybe ListStudioMembers
page ListStudioMembers
rq AWSResponse ListStudioMembers
rs
    | forall a. AWSTruncated a => a -> Bool
Core.stop
        ( AWSResponse ListStudioMembers
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' ListStudioMembersResponse (Maybe Text)
listStudioMembersResponse_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 ListStudioMembers
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' ListStudioMembersResponse (Maybe [StudioMembership])
listStudioMembersResponse_members
            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.$ ListStudioMembers
rq
          forall a b. a -> (a -> b) -> b
Prelude.& Lens' ListStudioMembers (Maybe Text)
listStudioMembers_nextToken
          forall s t a b. ASetter s t a b -> b -> s -> t
Lens..~ AWSResponse ListStudioMembers
rs
          forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' ListStudioMembersResponse (Maybe Text)
listStudioMembersResponse_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 ListStudioMembers where
  type
    AWSResponse ListStudioMembers =
      ListStudioMembersResponse
  request :: (Service -> Service)
-> ListStudioMembers -> Request ListStudioMembers
request Service -> Service
overrides =
    forall a. ToRequest a => Service -> a -> Request a
Request.get (Service -> Service
overrides Service
defaultService)
  response :: forall (m :: * -> *).
MonadResource m =>
(ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy ListStudioMembers
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse ListStudioMembers)))
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 [StudioMembership]
-> Maybe Text -> Int -> ListStudioMembersResponse
ListStudioMembersResponse'
            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
"members" 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 ListStudioMembers where
  hashWithSalt :: Int -> ListStudioMembers -> Int
hashWithSalt Int
_salt ListStudioMembers' {Maybe Natural
Maybe Text
Text
studioId :: Text
nextToken :: Maybe Text
maxResults :: Maybe Natural
$sel:studioId:ListStudioMembers' :: ListStudioMembers -> Text
$sel:nextToken:ListStudioMembers' :: ListStudioMembers -> Maybe Text
$sel:maxResults:ListStudioMembers' :: ListStudioMembers -> 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
studioId

instance Prelude.NFData ListStudioMembers where
  rnf :: ListStudioMembers -> ()
rnf ListStudioMembers' {Maybe Natural
Maybe Text
Text
studioId :: Text
nextToken :: Maybe Text
maxResults :: Maybe Natural
$sel:studioId:ListStudioMembers' :: ListStudioMembers -> Text
$sel:nextToken:ListStudioMembers' :: ListStudioMembers -> Maybe Text
$sel:maxResults:ListStudioMembers' :: ListStudioMembers -> 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
studioId

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

instance Data.ToPath ListStudioMembers where
  toPath :: ListStudioMembers -> ByteString
toPath ListStudioMembers' {Maybe Natural
Maybe Text
Text
studioId :: Text
nextToken :: Maybe Text
maxResults :: Maybe Natural
$sel:studioId:ListStudioMembers' :: ListStudioMembers -> Text
$sel:nextToken:ListStudioMembers' :: ListStudioMembers -> Maybe Text
$sel:maxResults:ListStudioMembers' :: ListStudioMembers -> Maybe Natural
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"/2020-08-01/studios/",
        forall a. ToByteString a => a -> ByteString
Data.toBS Text
studioId,
        ByteString
"/membership"
      ]

instance Data.ToQuery ListStudioMembers where
  toQuery :: ListStudioMembers -> QueryString
toQuery ListStudioMembers' {Maybe Natural
Maybe Text
Text
studioId :: Text
nextToken :: Maybe Text
maxResults :: Maybe Natural
$sel:studioId:ListStudioMembers' :: ListStudioMembers -> Text
$sel:nextToken:ListStudioMembers' :: ListStudioMembers -> Maybe Text
$sel:maxResults:ListStudioMembers' :: ListStudioMembers -> Maybe Natural
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"maxResults" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Natural
maxResults,
        ByteString
"nextToken" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Text
nextToken
      ]

-- | /See:/ 'newListStudioMembersResponse' smart constructor.
data ListStudioMembersResponse = ListStudioMembersResponse'
  { -- | A list of admin members.
    ListStudioMembersResponse -> Maybe [StudioMembership]
members :: Prelude.Maybe [StudioMembership],
    -- | The token for the next set of results, or null if there are no more
    -- results.
    ListStudioMembersResponse -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | The response's http status code.
    ListStudioMembersResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (ListStudioMembersResponse -> ListStudioMembersResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListStudioMembersResponse -> ListStudioMembersResponse -> Bool
$c/= :: ListStudioMembersResponse -> ListStudioMembersResponse -> Bool
== :: ListStudioMembersResponse -> ListStudioMembersResponse -> Bool
$c== :: ListStudioMembersResponse -> ListStudioMembersResponse -> Bool
Prelude.Eq, ReadPrec [ListStudioMembersResponse]
ReadPrec ListStudioMembersResponse
Int -> ReadS ListStudioMembersResponse
ReadS [ListStudioMembersResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListStudioMembersResponse]
$creadListPrec :: ReadPrec [ListStudioMembersResponse]
readPrec :: ReadPrec ListStudioMembersResponse
$creadPrec :: ReadPrec ListStudioMembersResponse
readList :: ReadS [ListStudioMembersResponse]
$creadList :: ReadS [ListStudioMembersResponse]
readsPrec :: Int -> ReadS ListStudioMembersResponse
$creadsPrec :: Int -> ReadS ListStudioMembersResponse
Prelude.Read, Int -> ListStudioMembersResponse -> ShowS
[ListStudioMembersResponse] -> ShowS
ListStudioMembersResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListStudioMembersResponse] -> ShowS
$cshowList :: [ListStudioMembersResponse] -> ShowS
show :: ListStudioMembersResponse -> String
$cshow :: ListStudioMembersResponse -> String
showsPrec :: Int -> ListStudioMembersResponse -> ShowS
$cshowsPrec :: Int -> ListStudioMembersResponse -> ShowS
Prelude.Show, forall x.
Rep ListStudioMembersResponse x -> ListStudioMembersResponse
forall x.
ListStudioMembersResponse -> Rep ListStudioMembersResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep ListStudioMembersResponse x -> ListStudioMembersResponse
$cfrom :: forall x.
ListStudioMembersResponse -> Rep ListStudioMembersResponse x
Prelude.Generic)

-- |
-- Create a value of 'ListStudioMembersResponse' 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:
--
-- 'members', 'listStudioMembersResponse_members' - A list of admin members.
--
-- 'nextToken', 'listStudioMembersResponse_nextToken' - The token for the next set of results, or null if there are no more
-- results.
--
-- 'httpStatus', 'listStudioMembersResponse_httpStatus' - The response's http status code.
newListStudioMembersResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  ListStudioMembersResponse
newListStudioMembersResponse :: Int -> ListStudioMembersResponse
newListStudioMembersResponse Int
pHttpStatus_ =
  ListStudioMembersResponse'
    { $sel:members:ListStudioMembersResponse' :: Maybe [StudioMembership]
members =
        forall a. Maybe a
Prelude.Nothing,
      $sel:nextToken:ListStudioMembersResponse' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:ListStudioMembersResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | A list of admin members.
listStudioMembersResponse_members :: Lens.Lens' ListStudioMembersResponse (Prelude.Maybe [StudioMembership])
listStudioMembersResponse_members :: Lens' ListStudioMembersResponse (Maybe [StudioMembership])
listStudioMembersResponse_members = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListStudioMembersResponse' {Maybe [StudioMembership]
members :: Maybe [StudioMembership]
$sel:members:ListStudioMembersResponse' :: ListStudioMembersResponse -> Maybe [StudioMembership]
members} -> Maybe [StudioMembership]
members) (\s :: ListStudioMembersResponse
s@ListStudioMembersResponse' {} Maybe [StudioMembership]
a -> ListStudioMembersResponse
s {$sel:members:ListStudioMembersResponse' :: Maybe [StudioMembership]
members = Maybe [StudioMembership]
a} :: ListStudioMembersResponse) 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 token for the next set of results, or null if there are no more
-- results.
listStudioMembersResponse_nextToken :: Lens.Lens' ListStudioMembersResponse (Prelude.Maybe Prelude.Text)
listStudioMembersResponse_nextToken :: Lens' ListStudioMembersResponse (Maybe Text)
listStudioMembersResponse_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListStudioMembersResponse' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:ListStudioMembersResponse' :: ListStudioMembersResponse -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: ListStudioMembersResponse
s@ListStudioMembersResponse' {} Maybe Text
a -> ListStudioMembersResponse
s {$sel:nextToken:ListStudioMembersResponse' :: Maybe Text
nextToken = Maybe Text
a} :: ListStudioMembersResponse)

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

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