{-# 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.EC2.DeleteTransitGatewayRoute
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Deletes the specified route from the specified transit gateway route
-- table.
module Amazonka.EC2.DeleteTransitGatewayRoute
  ( -- * Creating a Request
    DeleteTransitGatewayRoute (..),
    newDeleteTransitGatewayRoute,

    -- * Request Lenses
    deleteTransitGatewayRoute_dryRun,
    deleteTransitGatewayRoute_transitGatewayRouteTableId,
    deleteTransitGatewayRoute_destinationCidrBlock,

    -- * Destructuring the Response
    DeleteTransitGatewayRouteResponse (..),
    newDeleteTransitGatewayRouteResponse,

    -- * Response Lenses
    deleteTransitGatewayRouteResponse_route,
    deleteTransitGatewayRouteResponse_httpStatus,
  )
where

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

-- | /See:/ 'newDeleteTransitGatewayRoute' smart constructor.
data DeleteTransitGatewayRoute = DeleteTransitGatewayRoute'
  { -- | Checks whether you have the required permissions for the action, without
    -- actually making the request, and provides an error response. If you have
    -- the required permissions, the error response is @DryRunOperation@.
    -- Otherwise, it is @UnauthorizedOperation@.
    DeleteTransitGatewayRoute -> Maybe Bool
dryRun :: Prelude.Maybe Prelude.Bool,
    -- | The ID of the transit gateway route table.
    DeleteTransitGatewayRoute -> Text
transitGatewayRouteTableId :: Prelude.Text,
    -- | The CIDR range for the route. This must match the CIDR for the route
    -- exactly.
    DeleteTransitGatewayRoute -> Text
destinationCidrBlock :: Prelude.Text
  }
  deriving (DeleteTransitGatewayRoute -> DeleteTransitGatewayRoute -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DeleteTransitGatewayRoute -> DeleteTransitGatewayRoute -> Bool
$c/= :: DeleteTransitGatewayRoute -> DeleteTransitGatewayRoute -> Bool
== :: DeleteTransitGatewayRoute -> DeleteTransitGatewayRoute -> Bool
$c== :: DeleteTransitGatewayRoute -> DeleteTransitGatewayRoute -> Bool
Prelude.Eq, ReadPrec [DeleteTransitGatewayRoute]
ReadPrec DeleteTransitGatewayRoute
Int -> ReadS DeleteTransitGatewayRoute
ReadS [DeleteTransitGatewayRoute]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DeleteTransitGatewayRoute]
$creadListPrec :: ReadPrec [DeleteTransitGatewayRoute]
readPrec :: ReadPrec DeleteTransitGatewayRoute
$creadPrec :: ReadPrec DeleteTransitGatewayRoute
readList :: ReadS [DeleteTransitGatewayRoute]
$creadList :: ReadS [DeleteTransitGatewayRoute]
readsPrec :: Int -> ReadS DeleteTransitGatewayRoute
$creadsPrec :: Int -> ReadS DeleteTransitGatewayRoute
Prelude.Read, Int -> DeleteTransitGatewayRoute -> ShowS
[DeleteTransitGatewayRoute] -> ShowS
DeleteTransitGatewayRoute -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DeleteTransitGatewayRoute] -> ShowS
$cshowList :: [DeleteTransitGatewayRoute] -> ShowS
show :: DeleteTransitGatewayRoute -> String
$cshow :: DeleteTransitGatewayRoute -> String
showsPrec :: Int -> DeleteTransitGatewayRoute -> ShowS
$cshowsPrec :: Int -> DeleteTransitGatewayRoute -> ShowS
Prelude.Show, forall x.
Rep DeleteTransitGatewayRoute x -> DeleteTransitGatewayRoute
forall x.
DeleteTransitGatewayRoute -> Rep DeleteTransitGatewayRoute x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep DeleteTransitGatewayRoute x -> DeleteTransitGatewayRoute
$cfrom :: forall x.
DeleteTransitGatewayRoute -> Rep DeleteTransitGatewayRoute x
Prelude.Generic)

-- |
-- Create a value of 'DeleteTransitGatewayRoute' 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:
--
-- 'dryRun', 'deleteTransitGatewayRoute_dryRun' - Checks whether you have the required permissions for the action, without
-- actually making the request, and provides an error response. If you have
-- the required permissions, the error response is @DryRunOperation@.
-- Otherwise, it is @UnauthorizedOperation@.
--
-- 'transitGatewayRouteTableId', 'deleteTransitGatewayRoute_transitGatewayRouteTableId' - The ID of the transit gateway route table.
--
-- 'destinationCidrBlock', 'deleteTransitGatewayRoute_destinationCidrBlock' - The CIDR range for the route. This must match the CIDR for the route
-- exactly.
newDeleteTransitGatewayRoute ::
  -- | 'transitGatewayRouteTableId'
  Prelude.Text ->
  -- | 'destinationCidrBlock'
  Prelude.Text ->
  DeleteTransitGatewayRoute
newDeleteTransitGatewayRoute :: Text -> Text -> DeleteTransitGatewayRoute
newDeleteTransitGatewayRoute
  Text
pTransitGatewayRouteTableId_
  Text
pDestinationCidrBlock_ =
    DeleteTransitGatewayRoute'
      { $sel:dryRun:DeleteTransitGatewayRoute' :: Maybe Bool
dryRun =
          forall a. Maybe a
Prelude.Nothing,
        $sel:transitGatewayRouteTableId:DeleteTransitGatewayRoute' :: Text
transitGatewayRouteTableId =
          Text
pTransitGatewayRouteTableId_,
        $sel:destinationCidrBlock:DeleteTransitGatewayRoute' :: Text
destinationCidrBlock = Text
pDestinationCidrBlock_
      }

-- | Checks whether you have the required permissions for the action, without
-- actually making the request, and provides an error response. If you have
-- the required permissions, the error response is @DryRunOperation@.
-- Otherwise, it is @UnauthorizedOperation@.
deleteTransitGatewayRoute_dryRun :: Lens.Lens' DeleteTransitGatewayRoute (Prelude.Maybe Prelude.Bool)
deleteTransitGatewayRoute_dryRun :: Lens' DeleteTransitGatewayRoute (Maybe Bool)
deleteTransitGatewayRoute_dryRun = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DeleteTransitGatewayRoute' {Maybe Bool
dryRun :: Maybe Bool
$sel:dryRun:DeleteTransitGatewayRoute' :: DeleteTransitGatewayRoute -> Maybe Bool
dryRun} -> Maybe Bool
dryRun) (\s :: DeleteTransitGatewayRoute
s@DeleteTransitGatewayRoute' {} Maybe Bool
a -> DeleteTransitGatewayRoute
s {$sel:dryRun:DeleteTransitGatewayRoute' :: Maybe Bool
dryRun = Maybe Bool
a} :: DeleteTransitGatewayRoute)

-- | The ID of the transit gateway route table.
deleteTransitGatewayRoute_transitGatewayRouteTableId :: Lens.Lens' DeleteTransitGatewayRoute Prelude.Text
deleteTransitGatewayRoute_transitGatewayRouteTableId :: Lens' DeleteTransitGatewayRoute Text
deleteTransitGatewayRoute_transitGatewayRouteTableId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DeleteTransitGatewayRoute' {Text
transitGatewayRouteTableId :: Text
$sel:transitGatewayRouteTableId:DeleteTransitGatewayRoute' :: DeleteTransitGatewayRoute -> Text
transitGatewayRouteTableId} -> Text
transitGatewayRouteTableId) (\s :: DeleteTransitGatewayRoute
s@DeleteTransitGatewayRoute' {} Text
a -> DeleteTransitGatewayRoute
s {$sel:transitGatewayRouteTableId:DeleteTransitGatewayRoute' :: Text
transitGatewayRouteTableId = Text
a} :: DeleteTransitGatewayRoute)

-- | The CIDR range for the route. This must match the CIDR for the route
-- exactly.
deleteTransitGatewayRoute_destinationCidrBlock :: Lens.Lens' DeleteTransitGatewayRoute Prelude.Text
deleteTransitGatewayRoute_destinationCidrBlock :: Lens' DeleteTransitGatewayRoute Text
deleteTransitGatewayRoute_destinationCidrBlock = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DeleteTransitGatewayRoute' {Text
destinationCidrBlock :: Text
$sel:destinationCidrBlock:DeleteTransitGatewayRoute' :: DeleteTransitGatewayRoute -> Text
destinationCidrBlock} -> Text
destinationCidrBlock) (\s :: DeleteTransitGatewayRoute
s@DeleteTransitGatewayRoute' {} Text
a -> DeleteTransitGatewayRoute
s {$sel:destinationCidrBlock:DeleteTransitGatewayRoute' :: Text
destinationCidrBlock = Text
a} :: DeleteTransitGatewayRoute)

instance Core.AWSRequest DeleteTransitGatewayRoute where
  type
    AWSResponse DeleteTransitGatewayRoute =
      DeleteTransitGatewayRouteResponse
  request :: (Service -> Service)
-> DeleteTransitGatewayRoute -> Request DeleteTransitGatewayRoute
request Service -> Service
overrides =
    forall a. ToRequest a => Service -> a -> Request a
Request.postQuery (Service -> Service
overrides Service
defaultService)
  response :: forall (m :: * -> *).
MonadResource m =>
(ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy DeleteTransitGatewayRoute
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse DeleteTransitGatewayRoute)))
response =
    forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> [Node] -> Either String (AWSResponse a))
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveXML
      ( \Int
s ResponseHeaders
h [Node]
x ->
          Maybe TransitGatewayRoute
-> Int -> DeleteTransitGatewayRouteResponse
DeleteTransitGatewayRouteResponse'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"route")
            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 DeleteTransitGatewayRoute where
  hashWithSalt :: Int -> DeleteTransitGatewayRoute -> Int
hashWithSalt Int
_salt DeleteTransitGatewayRoute' {Maybe Bool
Text
destinationCidrBlock :: Text
transitGatewayRouteTableId :: Text
dryRun :: Maybe Bool
$sel:destinationCidrBlock:DeleteTransitGatewayRoute' :: DeleteTransitGatewayRoute -> Text
$sel:transitGatewayRouteTableId:DeleteTransitGatewayRoute' :: DeleteTransitGatewayRoute -> Text
$sel:dryRun:DeleteTransitGatewayRoute' :: DeleteTransitGatewayRoute -> Maybe Bool
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
dryRun
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
transitGatewayRouteTableId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
destinationCidrBlock

instance Prelude.NFData DeleteTransitGatewayRoute where
  rnf :: DeleteTransitGatewayRoute -> ()
rnf DeleteTransitGatewayRoute' {Maybe Bool
Text
destinationCidrBlock :: Text
transitGatewayRouteTableId :: Text
dryRun :: Maybe Bool
$sel:destinationCidrBlock:DeleteTransitGatewayRoute' :: DeleteTransitGatewayRoute -> Text
$sel:transitGatewayRouteTableId:DeleteTransitGatewayRoute' :: DeleteTransitGatewayRoute -> Text
$sel:dryRun:DeleteTransitGatewayRoute' :: DeleteTransitGatewayRoute -> Maybe Bool
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Bool
dryRun
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
transitGatewayRouteTableId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
destinationCidrBlock

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

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

instance Data.ToQuery DeleteTransitGatewayRoute where
  toQuery :: DeleteTransitGatewayRoute -> QueryString
toQuery DeleteTransitGatewayRoute' {Maybe Bool
Text
destinationCidrBlock :: Text
transitGatewayRouteTableId :: Text
dryRun :: Maybe Bool
$sel:destinationCidrBlock:DeleteTransitGatewayRoute' :: DeleteTransitGatewayRoute -> Text
$sel:transitGatewayRouteTableId:DeleteTransitGatewayRoute' :: DeleteTransitGatewayRoute -> Text
$sel:dryRun:DeleteTransitGatewayRoute' :: DeleteTransitGatewayRoute -> Maybe Bool
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"Action"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: (ByteString
"DeleteTransitGatewayRoute" :: Prelude.ByteString),
        ByteString
"Version"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: (ByteString
"2016-11-15" :: Prelude.ByteString),
        ByteString
"DryRun" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Bool
dryRun,
        ByteString
"TransitGatewayRouteTableId"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Text
transitGatewayRouteTableId,
        ByteString
"DestinationCidrBlock" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Text
destinationCidrBlock
      ]

-- | /See:/ 'newDeleteTransitGatewayRouteResponse' smart constructor.
data DeleteTransitGatewayRouteResponse = DeleteTransitGatewayRouteResponse'
  { -- | Information about the route.
    DeleteTransitGatewayRouteResponse -> Maybe TransitGatewayRoute
route :: Prelude.Maybe TransitGatewayRoute,
    -- | The response's http status code.
    DeleteTransitGatewayRouteResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (DeleteTransitGatewayRouteResponse
-> DeleteTransitGatewayRouteResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DeleteTransitGatewayRouteResponse
-> DeleteTransitGatewayRouteResponse -> Bool
$c/= :: DeleteTransitGatewayRouteResponse
-> DeleteTransitGatewayRouteResponse -> Bool
== :: DeleteTransitGatewayRouteResponse
-> DeleteTransitGatewayRouteResponse -> Bool
$c== :: DeleteTransitGatewayRouteResponse
-> DeleteTransitGatewayRouteResponse -> Bool
Prelude.Eq, ReadPrec [DeleteTransitGatewayRouteResponse]
ReadPrec DeleteTransitGatewayRouteResponse
Int -> ReadS DeleteTransitGatewayRouteResponse
ReadS [DeleteTransitGatewayRouteResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DeleteTransitGatewayRouteResponse]
$creadListPrec :: ReadPrec [DeleteTransitGatewayRouteResponse]
readPrec :: ReadPrec DeleteTransitGatewayRouteResponse
$creadPrec :: ReadPrec DeleteTransitGatewayRouteResponse
readList :: ReadS [DeleteTransitGatewayRouteResponse]
$creadList :: ReadS [DeleteTransitGatewayRouteResponse]
readsPrec :: Int -> ReadS DeleteTransitGatewayRouteResponse
$creadsPrec :: Int -> ReadS DeleteTransitGatewayRouteResponse
Prelude.Read, Int -> DeleteTransitGatewayRouteResponse -> ShowS
[DeleteTransitGatewayRouteResponse] -> ShowS
DeleteTransitGatewayRouteResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DeleteTransitGatewayRouteResponse] -> ShowS
$cshowList :: [DeleteTransitGatewayRouteResponse] -> ShowS
show :: DeleteTransitGatewayRouteResponse -> String
$cshow :: DeleteTransitGatewayRouteResponse -> String
showsPrec :: Int -> DeleteTransitGatewayRouteResponse -> ShowS
$cshowsPrec :: Int -> DeleteTransitGatewayRouteResponse -> ShowS
Prelude.Show, forall x.
Rep DeleteTransitGatewayRouteResponse x
-> DeleteTransitGatewayRouteResponse
forall x.
DeleteTransitGatewayRouteResponse
-> Rep DeleteTransitGatewayRouteResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep DeleteTransitGatewayRouteResponse x
-> DeleteTransitGatewayRouteResponse
$cfrom :: forall x.
DeleteTransitGatewayRouteResponse
-> Rep DeleteTransitGatewayRouteResponse x
Prelude.Generic)

-- |
-- Create a value of 'DeleteTransitGatewayRouteResponse' 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:
--
-- 'route', 'deleteTransitGatewayRouteResponse_route' - Information about the route.
--
-- 'httpStatus', 'deleteTransitGatewayRouteResponse_httpStatus' - The response's http status code.
newDeleteTransitGatewayRouteResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  DeleteTransitGatewayRouteResponse
newDeleteTransitGatewayRouteResponse :: Int -> DeleteTransitGatewayRouteResponse
newDeleteTransitGatewayRouteResponse Int
pHttpStatus_ =
  DeleteTransitGatewayRouteResponse'
    { $sel:route:DeleteTransitGatewayRouteResponse' :: Maybe TransitGatewayRoute
route =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:DeleteTransitGatewayRouteResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | Information about the route.
deleteTransitGatewayRouteResponse_route :: Lens.Lens' DeleteTransitGatewayRouteResponse (Prelude.Maybe TransitGatewayRoute)
deleteTransitGatewayRouteResponse_route :: Lens' DeleteTransitGatewayRouteResponse (Maybe TransitGatewayRoute)
deleteTransitGatewayRouteResponse_route = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DeleteTransitGatewayRouteResponse' {Maybe TransitGatewayRoute
route :: Maybe TransitGatewayRoute
$sel:route:DeleteTransitGatewayRouteResponse' :: DeleteTransitGatewayRouteResponse -> Maybe TransitGatewayRoute
route} -> Maybe TransitGatewayRoute
route) (\s :: DeleteTransitGatewayRouteResponse
s@DeleteTransitGatewayRouteResponse' {} Maybe TransitGatewayRoute
a -> DeleteTransitGatewayRouteResponse
s {$sel:route:DeleteTransitGatewayRouteResponse' :: Maybe TransitGatewayRoute
route = Maybe TransitGatewayRoute
a} :: DeleteTransitGatewayRouteResponse)

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

instance
  Prelude.NFData
    DeleteTransitGatewayRouteResponse
  where
  rnf :: DeleteTransitGatewayRouteResponse -> ()
rnf DeleteTransitGatewayRouteResponse' {Int
Maybe TransitGatewayRoute
httpStatus :: Int
route :: Maybe TransitGatewayRoute
$sel:httpStatus:DeleteTransitGatewayRouteResponse' :: DeleteTransitGatewayRouteResponse -> Int
$sel:route:DeleteTransitGatewayRouteResponse' :: DeleteTransitGatewayRouteResponse -> Maybe TransitGatewayRoute
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe TransitGatewayRoute
route
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus