{-# 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.MigrationHubReFactorSpaces.DeleteEnvironment
-- 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 an Amazon Web Services Migration Hub Refactor Spaces
-- environment. Before you can delete an environment, you must first delete
-- any applications and services within the environment.
module Amazonka.MigrationHubReFactorSpaces.DeleteEnvironment
  ( -- * Creating a Request
    DeleteEnvironment (..),
    newDeleteEnvironment,

    -- * Request Lenses
    deleteEnvironment_environmentIdentifier,

    -- * Destructuring the Response
    DeleteEnvironmentResponse (..),
    newDeleteEnvironmentResponse,

    -- * Response Lenses
    deleteEnvironmentResponse_arn,
    deleteEnvironmentResponse_environmentId,
    deleteEnvironmentResponse_lastUpdatedTime,
    deleteEnvironmentResponse_name,
    deleteEnvironmentResponse_state,
    deleteEnvironmentResponse_httpStatus,
  )
where

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

-- | /See:/ 'newDeleteEnvironment' smart constructor.
data DeleteEnvironment = DeleteEnvironment'
  { -- | The ID of the environment.
    DeleteEnvironment -> Text
environmentIdentifier :: Prelude.Text
  }
  deriving (DeleteEnvironment -> DeleteEnvironment -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DeleteEnvironment -> DeleteEnvironment -> Bool
$c/= :: DeleteEnvironment -> DeleteEnvironment -> Bool
== :: DeleteEnvironment -> DeleteEnvironment -> Bool
$c== :: DeleteEnvironment -> DeleteEnvironment -> Bool
Prelude.Eq, ReadPrec [DeleteEnvironment]
ReadPrec DeleteEnvironment
Int -> ReadS DeleteEnvironment
ReadS [DeleteEnvironment]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DeleteEnvironment]
$creadListPrec :: ReadPrec [DeleteEnvironment]
readPrec :: ReadPrec DeleteEnvironment
$creadPrec :: ReadPrec DeleteEnvironment
readList :: ReadS [DeleteEnvironment]
$creadList :: ReadS [DeleteEnvironment]
readsPrec :: Int -> ReadS DeleteEnvironment
$creadsPrec :: Int -> ReadS DeleteEnvironment
Prelude.Read, Int -> DeleteEnvironment -> ShowS
[DeleteEnvironment] -> ShowS
DeleteEnvironment -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DeleteEnvironment] -> ShowS
$cshowList :: [DeleteEnvironment] -> ShowS
show :: DeleteEnvironment -> String
$cshow :: DeleteEnvironment -> String
showsPrec :: Int -> DeleteEnvironment -> ShowS
$cshowsPrec :: Int -> DeleteEnvironment -> ShowS
Prelude.Show, forall x. Rep DeleteEnvironment x -> DeleteEnvironment
forall x. DeleteEnvironment -> Rep DeleteEnvironment x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DeleteEnvironment x -> DeleteEnvironment
$cfrom :: forall x. DeleteEnvironment -> Rep DeleteEnvironment x
Prelude.Generic)

-- |
-- Create a value of 'DeleteEnvironment' 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:
--
-- 'environmentIdentifier', 'deleteEnvironment_environmentIdentifier' - The ID of the environment.
newDeleteEnvironment ::
  -- | 'environmentIdentifier'
  Prelude.Text ->
  DeleteEnvironment
newDeleteEnvironment :: Text -> DeleteEnvironment
newDeleteEnvironment Text
pEnvironmentIdentifier_ =
  DeleteEnvironment'
    { $sel:environmentIdentifier:DeleteEnvironment' :: Text
environmentIdentifier =
        Text
pEnvironmentIdentifier_
    }

-- | The ID of the environment.
deleteEnvironment_environmentIdentifier :: Lens.Lens' DeleteEnvironment Prelude.Text
deleteEnvironment_environmentIdentifier :: Lens' DeleteEnvironment Text
deleteEnvironment_environmentIdentifier = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DeleteEnvironment' {Text
environmentIdentifier :: Text
$sel:environmentIdentifier:DeleteEnvironment' :: DeleteEnvironment -> Text
environmentIdentifier} -> Text
environmentIdentifier) (\s :: DeleteEnvironment
s@DeleteEnvironment' {} Text
a -> DeleteEnvironment
s {$sel:environmentIdentifier:DeleteEnvironment' :: Text
environmentIdentifier = Text
a} :: DeleteEnvironment)

instance Core.AWSRequest DeleteEnvironment where
  type
    AWSResponse DeleteEnvironment =
      DeleteEnvironmentResponse
  request :: (Service -> Service)
-> DeleteEnvironment -> Request DeleteEnvironment
request Service -> Service
overrides =
    forall a. ToRequest a => Service -> a -> Request a
Request.delete (Service -> Service
overrides Service
defaultService)
  response :: forall (m :: * -> *).
MonadResource m =>
(ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy DeleteEnvironment
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse DeleteEnvironment)))
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 Text
-> Maybe POSIX
-> Maybe Text
-> Maybe EnvironmentState
-> Int
-> DeleteEnvironmentResponse
DeleteEnvironmentResponse'
            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
"Arn")
            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
"EnvironmentId")
            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
"LastUpdatedTime")
            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
"Name")
            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
"State")
            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 DeleteEnvironment where
  hashWithSalt :: Int -> DeleteEnvironment -> Int
hashWithSalt Int
_salt DeleteEnvironment' {Text
environmentIdentifier :: Text
$sel:environmentIdentifier:DeleteEnvironment' :: DeleteEnvironment -> Text
..} =
    Int
_salt forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
environmentIdentifier

instance Prelude.NFData DeleteEnvironment where
  rnf :: DeleteEnvironment -> ()
rnf DeleteEnvironment' {Text
environmentIdentifier :: Text
$sel:environmentIdentifier:DeleteEnvironment' :: DeleteEnvironment -> Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Text
environmentIdentifier

instance Data.ToHeaders DeleteEnvironment where
  toHeaders :: DeleteEnvironment -> 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 DeleteEnvironment where
  toPath :: DeleteEnvironment -> ByteString
toPath DeleteEnvironment' {Text
environmentIdentifier :: Text
$sel:environmentIdentifier:DeleteEnvironment' :: DeleteEnvironment -> Text
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ByteString
"/environments/", forall a. ToByteString a => a -> ByteString
Data.toBS Text
environmentIdentifier]

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

-- | /See:/ 'newDeleteEnvironmentResponse' smart constructor.
data DeleteEnvironmentResponse = DeleteEnvironmentResponse'
  { -- | The Amazon Resource Name (ARN) of the environment.
    DeleteEnvironmentResponse -> Maybe Text
arn :: Prelude.Maybe Prelude.Text,
    -- | The unique identifier of the environment.
    DeleteEnvironmentResponse -> Maybe Text
environmentId :: Prelude.Maybe Prelude.Text,
    -- | A timestamp that indicates when the environment was last updated.
    DeleteEnvironmentResponse -> Maybe POSIX
lastUpdatedTime :: Prelude.Maybe Data.POSIX,
    -- | The name of the environment.
    DeleteEnvironmentResponse -> Maybe Text
name :: Prelude.Maybe Prelude.Text,
    -- | The current state of the environment.
    DeleteEnvironmentResponse -> Maybe EnvironmentState
state :: Prelude.Maybe EnvironmentState,
    -- | The response's http status code.
    DeleteEnvironmentResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (DeleteEnvironmentResponse -> DeleteEnvironmentResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DeleteEnvironmentResponse -> DeleteEnvironmentResponse -> Bool
$c/= :: DeleteEnvironmentResponse -> DeleteEnvironmentResponse -> Bool
== :: DeleteEnvironmentResponse -> DeleteEnvironmentResponse -> Bool
$c== :: DeleteEnvironmentResponse -> DeleteEnvironmentResponse -> Bool
Prelude.Eq, ReadPrec [DeleteEnvironmentResponse]
ReadPrec DeleteEnvironmentResponse
Int -> ReadS DeleteEnvironmentResponse
ReadS [DeleteEnvironmentResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DeleteEnvironmentResponse]
$creadListPrec :: ReadPrec [DeleteEnvironmentResponse]
readPrec :: ReadPrec DeleteEnvironmentResponse
$creadPrec :: ReadPrec DeleteEnvironmentResponse
readList :: ReadS [DeleteEnvironmentResponse]
$creadList :: ReadS [DeleteEnvironmentResponse]
readsPrec :: Int -> ReadS DeleteEnvironmentResponse
$creadsPrec :: Int -> ReadS DeleteEnvironmentResponse
Prelude.Read, Int -> DeleteEnvironmentResponse -> ShowS
[DeleteEnvironmentResponse] -> ShowS
DeleteEnvironmentResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DeleteEnvironmentResponse] -> ShowS
$cshowList :: [DeleteEnvironmentResponse] -> ShowS
show :: DeleteEnvironmentResponse -> String
$cshow :: DeleteEnvironmentResponse -> String
showsPrec :: Int -> DeleteEnvironmentResponse -> ShowS
$cshowsPrec :: Int -> DeleteEnvironmentResponse -> ShowS
Prelude.Show, forall x.
Rep DeleteEnvironmentResponse x -> DeleteEnvironmentResponse
forall x.
DeleteEnvironmentResponse -> Rep DeleteEnvironmentResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep DeleteEnvironmentResponse x -> DeleteEnvironmentResponse
$cfrom :: forall x.
DeleteEnvironmentResponse -> Rep DeleteEnvironmentResponse x
Prelude.Generic)

-- |
-- Create a value of 'DeleteEnvironmentResponse' 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:
--
-- 'arn', 'deleteEnvironmentResponse_arn' - The Amazon Resource Name (ARN) of the environment.
--
-- 'environmentId', 'deleteEnvironmentResponse_environmentId' - The unique identifier of the environment.
--
-- 'lastUpdatedTime', 'deleteEnvironmentResponse_lastUpdatedTime' - A timestamp that indicates when the environment was last updated.
--
-- 'name', 'deleteEnvironmentResponse_name' - The name of the environment.
--
-- 'state', 'deleteEnvironmentResponse_state' - The current state of the environment.
--
-- 'httpStatus', 'deleteEnvironmentResponse_httpStatus' - The response's http status code.
newDeleteEnvironmentResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  DeleteEnvironmentResponse
newDeleteEnvironmentResponse :: Int -> DeleteEnvironmentResponse
newDeleteEnvironmentResponse Int
pHttpStatus_ =
  DeleteEnvironmentResponse'
    { $sel:arn:DeleteEnvironmentResponse' :: Maybe Text
arn = forall a. Maybe a
Prelude.Nothing,
      $sel:environmentId:DeleteEnvironmentResponse' :: Maybe Text
environmentId = forall a. Maybe a
Prelude.Nothing,
      $sel:lastUpdatedTime:DeleteEnvironmentResponse' :: Maybe POSIX
lastUpdatedTime = forall a. Maybe a
Prelude.Nothing,
      $sel:name:DeleteEnvironmentResponse' :: Maybe Text
name = forall a. Maybe a
Prelude.Nothing,
      $sel:state:DeleteEnvironmentResponse' :: Maybe EnvironmentState
state = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:DeleteEnvironmentResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The Amazon Resource Name (ARN) of the environment.
deleteEnvironmentResponse_arn :: Lens.Lens' DeleteEnvironmentResponse (Prelude.Maybe Prelude.Text)
deleteEnvironmentResponse_arn :: Lens' DeleteEnvironmentResponse (Maybe Text)
deleteEnvironmentResponse_arn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DeleteEnvironmentResponse' {Maybe Text
arn :: Maybe Text
$sel:arn:DeleteEnvironmentResponse' :: DeleteEnvironmentResponse -> Maybe Text
arn} -> Maybe Text
arn) (\s :: DeleteEnvironmentResponse
s@DeleteEnvironmentResponse' {} Maybe Text
a -> DeleteEnvironmentResponse
s {$sel:arn:DeleteEnvironmentResponse' :: Maybe Text
arn = Maybe Text
a} :: DeleteEnvironmentResponse)

-- | The unique identifier of the environment.
deleteEnvironmentResponse_environmentId :: Lens.Lens' DeleteEnvironmentResponse (Prelude.Maybe Prelude.Text)
deleteEnvironmentResponse_environmentId :: Lens' DeleteEnvironmentResponse (Maybe Text)
deleteEnvironmentResponse_environmentId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DeleteEnvironmentResponse' {Maybe Text
environmentId :: Maybe Text
$sel:environmentId:DeleteEnvironmentResponse' :: DeleteEnvironmentResponse -> Maybe Text
environmentId} -> Maybe Text
environmentId) (\s :: DeleteEnvironmentResponse
s@DeleteEnvironmentResponse' {} Maybe Text
a -> DeleteEnvironmentResponse
s {$sel:environmentId:DeleteEnvironmentResponse' :: Maybe Text
environmentId = Maybe Text
a} :: DeleteEnvironmentResponse)

-- | A timestamp that indicates when the environment was last updated.
deleteEnvironmentResponse_lastUpdatedTime :: Lens.Lens' DeleteEnvironmentResponse (Prelude.Maybe Prelude.UTCTime)
deleteEnvironmentResponse_lastUpdatedTime :: Lens' DeleteEnvironmentResponse (Maybe UTCTime)
deleteEnvironmentResponse_lastUpdatedTime = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DeleteEnvironmentResponse' {Maybe POSIX
lastUpdatedTime :: Maybe POSIX
$sel:lastUpdatedTime:DeleteEnvironmentResponse' :: DeleteEnvironmentResponse -> Maybe POSIX
lastUpdatedTime} -> Maybe POSIX
lastUpdatedTime) (\s :: DeleteEnvironmentResponse
s@DeleteEnvironmentResponse' {} Maybe POSIX
a -> DeleteEnvironmentResponse
s {$sel:lastUpdatedTime:DeleteEnvironmentResponse' :: Maybe POSIX
lastUpdatedTime = Maybe POSIX
a} :: DeleteEnvironmentResponse) 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 (a :: Format). Iso' (Time a) UTCTime
Data._Time

-- | The name of the environment.
deleteEnvironmentResponse_name :: Lens.Lens' DeleteEnvironmentResponse (Prelude.Maybe Prelude.Text)
deleteEnvironmentResponse_name :: Lens' DeleteEnvironmentResponse (Maybe Text)
deleteEnvironmentResponse_name = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DeleteEnvironmentResponse' {Maybe Text
name :: Maybe Text
$sel:name:DeleteEnvironmentResponse' :: DeleteEnvironmentResponse -> Maybe Text
name} -> Maybe Text
name) (\s :: DeleteEnvironmentResponse
s@DeleteEnvironmentResponse' {} Maybe Text
a -> DeleteEnvironmentResponse
s {$sel:name:DeleteEnvironmentResponse' :: Maybe Text
name = Maybe Text
a} :: DeleteEnvironmentResponse)

-- | The current state of the environment.
deleteEnvironmentResponse_state :: Lens.Lens' DeleteEnvironmentResponse (Prelude.Maybe EnvironmentState)
deleteEnvironmentResponse_state :: Lens' DeleteEnvironmentResponse (Maybe EnvironmentState)
deleteEnvironmentResponse_state = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DeleteEnvironmentResponse' {Maybe EnvironmentState
state :: Maybe EnvironmentState
$sel:state:DeleteEnvironmentResponse' :: DeleteEnvironmentResponse -> Maybe EnvironmentState
state} -> Maybe EnvironmentState
state) (\s :: DeleteEnvironmentResponse
s@DeleteEnvironmentResponse' {} Maybe EnvironmentState
a -> DeleteEnvironmentResponse
s {$sel:state:DeleteEnvironmentResponse' :: Maybe EnvironmentState
state = Maybe EnvironmentState
a} :: DeleteEnvironmentResponse)

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

instance Prelude.NFData DeleteEnvironmentResponse where
  rnf :: DeleteEnvironmentResponse -> ()
rnf DeleteEnvironmentResponse' {Int
Maybe Text
Maybe POSIX
Maybe EnvironmentState
httpStatus :: Int
state :: Maybe EnvironmentState
name :: Maybe Text
lastUpdatedTime :: Maybe POSIX
environmentId :: Maybe Text
arn :: Maybe Text
$sel:httpStatus:DeleteEnvironmentResponse' :: DeleteEnvironmentResponse -> Int
$sel:state:DeleteEnvironmentResponse' :: DeleteEnvironmentResponse -> Maybe EnvironmentState
$sel:name:DeleteEnvironmentResponse' :: DeleteEnvironmentResponse -> Maybe Text
$sel:lastUpdatedTime:DeleteEnvironmentResponse' :: DeleteEnvironmentResponse -> Maybe POSIX
$sel:environmentId:DeleteEnvironmentResponse' :: DeleteEnvironmentResponse -> Maybe Text
$sel:arn:DeleteEnvironmentResponse' :: DeleteEnvironmentResponse -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
arn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
environmentId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe POSIX
lastUpdatedTime
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
name
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe EnvironmentState
state
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus