{-# 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.SageMaker.DeleteSpace
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Used to delete a space.
module Amazonka.SageMaker.DeleteSpace
  ( -- * Creating a Request
    DeleteSpace (..),
    newDeleteSpace,

    -- * Request Lenses
    deleteSpace_domainId,
    deleteSpace_spaceName,

    -- * Destructuring the Response
    DeleteSpaceResponse (..),
    newDeleteSpaceResponse,
  )
where

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
import Amazonka.SageMaker.Types

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

-- |
-- Create a value of 'DeleteSpace' 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:
--
-- 'domainId', 'deleteSpace_domainId' - The ID of the associated Domain.
--
-- 'spaceName', 'deleteSpace_spaceName' - The name of the space.
newDeleteSpace ::
  -- | 'domainId'
  Prelude.Text ->
  -- | 'spaceName'
  Prelude.Text ->
  DeleteSpace
newDeleteSpace :: Text -> Text -> DeleteSpace
newDeleteSpace Text
pDomainId_ Text
pSpaceName_ =
  DeleteSpace'
    { $sel:domainId:DeleteSpace' :: Text
domainId = Text
pDomainId_,
      $sel:spaceName:DeleteSpace' :: Text
spaceName = Text
pSpaceName_
    }

-- | The ID of the associated Domain.
deleteSpace_domainId :: Lens.Lens' DeleteSpace Prelude.Text
deleteSpace_domainId :: Lens' DeleteSpace Text
deleteSpace_domainId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DeleteSpace' {Text
domainId :: Text
$sel:domainId:DeleteSpace' :: DeleteSpace -> Text
domainId} -> Text
domainId) (\s :: DeleteSpace
s@DeleteSpace' {} Text
a -> DeleteSpace
s {$sel:domainId:DeleteSpace' :: Text
domainId = Text
a} :: DeleteSpace)

-- | The name of the space.
deleteSpace_spaceName :: Lens.Lens' DeleteSpace Prelude.Text
deleteSpace_spaceName :: Lens' DeleteSpace Text
deleteSpace_spaceName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DeleteSpace' {Text
spaceName :: Text
$sel:spaceName:DeleteSpace' :: DeleteSpace -> Text
spaceName} -> Text
spaceName) (\s :: DeleteSpace
s@DeleteSpace' {} Text
a -> DeleteSpace
s {$sel:spaceName:DeleteSpace' :: Text
spaceName = Text
a} :: DeleteSpace)

instance Core.AWSRequest DeleteSpace where
  type AWSResponse DeleteSpace = DeleteSpaceResponse
  request :: (Service -> Service) -> DeleteSpace -> Request DeleteSpace
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 DeleteSpace
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse DeleteSpace)))
response = forall (m :: * -> *) a.
MonadResource m =>
AWSResponse a
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveNull DeleteSpaceResponse
DeleteSpaceResponse'

instance Prelude.Hashable DeleteSpace where
  hashWithSalt :: Int -> DeleteSpace -> Int
hashWithSalt Int
_salt DeleteSpace' {Text
spaceName :: Text
domainId :: Text
$sel:spaceName:DeleteSpace' :: DeleteSpace -> Text
$sel:domainId:DeleteSpace' :: DeleteSpace -> Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
domainId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
spaceName

instance Prelude.NFData DeleteSpace where
  rnf :: DeleteSpace -> ()
rnf DeleteSpace' {Text
spaceName :: Text
domainId :: Text
$sel:spaceName:DeleteSpace' :: DeleteSpace -> Text
$sel:domainId:DeleteSpace' :: DeleteSpace -> Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Text
domainId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
spaceName

instance Data.ToHeaders DeleteSpace where
  toHeaders :: DeleteSpace -> [Header]
toHeaders =
    forall a b. a -> b -> a
Prelude.const
      ( forall a. Monoid a => [a] -> a
Prelude.mconcat
          [ HeaderName
"X-Amz-Target"
              forall a. ToHeader a => HeaderName -> a -> [Header]
Data.=# (ByteString
"SageMaker.DeleteSpace" :: Prelude.ByteString),
            HeaderName
"Content-Type"
              forall a. ToHeader a => HeaderName -> a -> [Header]
Data.=# ( ByteString
"application/x-amz-json-1.1" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Data.ToJSON DeleteSpace where
  toJSON :: DeleteSpace -> Value
toJSON DeleteSpace' {Text
spaceName :: Text
domainId :: Text
$sel:spaceName:DeleteSpace' :: DeleteSpace -> Text
$sel:domainId:DeleteSpace' :: DeleteSpace -> Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ forall a. a -> Maybe a
Prelude.Just (Key
"DomainId" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
domainId),
            forall a. a -> Maybe a
Prelude.Just (Key
"SpaceName" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
spaceName)
          ]
      )

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

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

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

-- |
-- Create a value of 'DeleteSpaceResponse' 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.
newDeleteSpaceResponse ::
  DeleteSpaceResponse
newDeleteSpaceResponse :: DeleteSpaceResponse
newDeleteSpaceResponse = DeleteSpaceResponse
DeleteSpaceResponse'

instance Prelude.NFData DeleteSpaceResponse where
  rnf :: DeleteSpaceResponse -> ()
rnf DeleteSpaceResponse
_ = ()