{-# 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.Glue.UpdateClassifier
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Modifies an existing classifier (a @GrokClassifier@, an @XMLClassifier@,
-- a @JsonClassifier@, or a @CsvClassifier@, depending on which field is
-- present).
module Amazonka.Glue.UpdateClassifier
  ( -- * Creating a Request
    UpdateClassifier (..),
    newUpdateClassifier,

    -- * Request Lenses
    updateClassifier_csvClassifier,
    updateClassifier_grokClassifier,
    updateClassifier_jsonClassifier,
    updateClassifier_xMLClassifier,

    -- * Destructuring the Response
    UpdateClassifierResponse (..),
    newUpdateClassifierResponse,

    -- * Response Lenses
    updateClassifierResponse_httpStatus,
  )
where

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

-- | /See:/ 'newUpdateClassifier' smart constructor.
data UpdateClassifier = UpdateClassifier'
  { -- | A @CsvClassifier@ object with updated fields.
    UpdateClassifier -> Maybe UpdateCsvClassifierRequest
csvClassifier :: Prelude.Maybe UpdateCsvClassifierRequest,
    -- | A @GrokClassifier@ object with updated fields.
    UpdateClassifier -> Maybe UpdateGrokClassifierRequest
grokClassifier :: Prelude.Maybe UpdateGrokClassifierRequest,
    -- | A @JsonClassifier@ object with updated fields.
    UpdateClassifier -> Maybe UpdateJsonClassifierRequest
jsonClassifier :: Prelude.Maybe UpdateJsonClassifierRequest,
    -- | An @XMLClassifier@ object with updated fields.
    UpdateClassifier -> Maybe UpdateXMLClassifierRequest
xMLClassifier :: Prelude.Maybe UpdateXMLClassifierRequest
  }
  deriving (UpdateClassifier -> UpdateClassifier -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UpdateClassifier -> UpdateClassifier -> Bool
$c/= :: UpdateClassifier -> UpdateClassifier -> Bool
== :: UpdateClassifier -> UpdateClassifier -> Bool
$c== :: UpdateClassifier -> UpdateClassifier -> Bool
Prelude.Eq, ReadPrec [UpdateClassifier]
ReadPrec UpdateClassifier
Int -> ReadS UpdateClassifier
ReadS [UpdateClassifier]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [UpdateClassifier]
$creadListPrec :: ReadPrec [UpdateClassifier]
readPrec :: ReadPrec UpdateClassifier
$creadPrec :: ReadPrec UpdateClassifier
readList :: ReadS [UpdateClassifier]
$creadList :: ReadS [UpdateClassifier]
readsPrec :: Int -> ReadS UpdateClassifier
$creadsPrec :: Int -> ReadS UpdateClassifier
Prelude.Read, Int -> UpdateClassifier -> ShowS
[UpdateClassifier] -> ShowS
UpdateClassifier -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [UpdateClassifier] -> ShowS
$cshowList :: [UpdateClassifier] -> ShowS
show :: UpdateClassifier -> String
$cshow :: UpdateClassifier -> String
showsPrec :: Int -> UpdateClassifier -> ShowS
$cshowsPrec :: Int -> UpdateClassifier -> ShowS
Prelude.Show, forall x. Rep UpdateClassifier x -> UpdateClassifier
forall x. UpdateClassifier -> Rep UpdateClassifier x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep UpdateClassifier x -> UpdateClassifier
$cfrom :: forall x. UpdateClassifier -> Rep UpdateClassifier x
Prelude.Generic)

-- |
-- Create a value of 'UpdateClassifier' 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:
--
-- 'csvClassifier', 'updateClassifier_csvClassifier' - A @CsvClassifier@ object with updated fields.
--
-- 'grokClassifier', 'updateClassifier_grokClassifier' - A @GrokClassifier@ object with updated fields.
--
-- 'jsonClassifier', 'updateClassifier_jsonClassifier' - A @JsonClassifier@ object with updated fields.
--
-- 'xMLClassifier', 'updateClassifier_xMLClassifier' - An @XMLClassifier@ object with updated fields.
newUpdateClassifier ::
  UpdateClassifier
newUpdateClassifier :: UpdateClassifier
newUpdateClassifier =
  UpdateClassifier'
    { $sel:csvClassifier:UpdateClassifier' :: Maybe UpdateCsvClassifierRequest
csvClassifier = forall a. Maybe a
Prelude.Nothing,
      $sel:grokClassifier:UpdateClassifier' :: Maybe UpdateGrokClassifierRequest
grokClassifier = forall a. Maybe a
Prelude.Nothing,
      $sel:jsonClassifier:UpdateClassifier' :: Maybe UpdateJsonClassifierRequest
jsonClassifier = forall a. Maybe a
Prelude.Nothing,
      $sel:xMLClassifier:UpdateClassifier' :: Maybe UpdateXMLClassifierRequest
xMLClassifier = forall a. Maybe a
Prelude.Nothing
    }

-- | A @CsvClassifier@ object with updated fields.
updateClassifier_csvClassifier :: Lens.Lens' UpdateClassifier (Prelude.Maybe UpdateCsvClassifierRequest)
updateClassifier_csvClassifier :: Lens' UpdateClassifier (Maybe UpdateCsvClassifierRequest)
updateClassifier_csvClassifier = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateClassifier' {Maybe UpdateCsvClassifierRequest
csvClassifier :: Maybe UpdateCsvClassifierRequest
$sel:csvClassifier:UpdateClassifier' :: UpdateClassifier -> Maybe UpdateCsvClassifierRequest
csvClassifier} -> Maybe UpdateCsvClassifierRequest
csvClassifier) (\s :: UpdateClassifier
s@UpdateClassifier' {} Maybe UpdateCsvClassifierRequest
a -> UpdateClassifier
s {$sel:csvClassifier:UpdateClassifier' :: Maybe UpdateCsvClassifierRequest
csvClassifier = Maybe UpdateCsvClassifierRequest
a} :: UpdateClassifier)

-- | A @GrokClassifier@ object with updated fields.
updateClassifier_grokClassifier :: Lens.Lens' UpdateClassifier (Prelude.Maybe UpdateGrokClassifierRequest)
updateClassifier_grokClassifier :: Lens' UpdateClassifier (Maybe UpdateGrokClassifierRequest)
updateClassifier_grokClassifier = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateClassifier' {Maybe UpdateGrokClassifierRequest
grokClassifier :: Maybe UpdateGrokClassifierRequest
$sel:grokClassifier:UpdateClassifier' :: UpdateClassifier -> Maybe UpdateGrokClassifierRequest
grokClassifier} -> Maybe UpdateGrokClassifierRequest
grokClassifier) (\s :: UpdateClassifier
s@UpdateClassifier' {} Maybe UpdateGrokClassifierRequest
a -> UpdateClassifier
s {$sel:grokClassifier:UpdateClassifier' :: Maybe UpdateGrokClassifierRequest
grokClassifier = Maybe UpdateGrokClassifierRequest
a} :: UpdateClassifier)

-- | A @JsonClassifier@ object with updated fields.
updateClassifier_jsonClassifier :: Lens.Lens' UpdateClassifier (Prelude.Maybe UpdateJsonClassifierRequest)
updateClassifier_jsonClassifier :: Lens' UpdateClassifier (Maybe UpdateJsonClassifierRequest)
updateClassifier_jsonClassifier = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateClassifier' {Maybe UpdateJsonClassifierRequest
jsonClassifier :: Maybe UpdateJsonClassifierRequest
$sel:jsonClassifier:UpdateClassifier' :: UpdateClassifier -> Maybe UpdateJsonClassifierRequest
jsonClassifier} -> Maybe UpdateJsonClassifierRequest
jsonClassifier) (\s :: UpdateClassifier
s@UpdateClassifier' {} Maybe UpdateJsonClassifierRequest
a -> UpdateClassifier
s {$sel:jsonClassifier:UpdateClassifier' :: Maybe UpdateJsonClassifierRequest
jsonClassifier = Maybe UpdateJsonClassifierRequest
a} :: UpdateClassifier)

-- | An @XMLClassifier@ object with updated fields.
updateClassifier_xMLClassifier :: Lens.Lens' UpdateClassifier (Prelude.Maybe UpdateXMLClassifierRequest)
updateClassifier_xMLClassifier :: Lens' UpdateClassifier (Maybe UpdateXMLClassifierRequest)
updateClassifier_xMLClassifier = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateClassifier' {Maybe UpdateXMLClassifierRequest
xMLClassifier :: Maybe UpdateXMLClassifierRequest
$sel:xMLClassifier:UpdateClassifier' :: UpdateClassifier -> Maybe UpdateXMLClassifierRequest
xMLClassifier} -> Maybe UpdateXMLClassifierRequest
xMLClassifier) (\s :: UpdateClassifier
s@UpdateClassifier' {} Maybe UpdateXMLClassifierRequest
a -> UpdateClassifier
s {$sel:xMLClassifier:UpdateClassifier' :: Maybe UpdateXMLClassifierRequest
xMLClassifier = Maybe UpdateXMLClassifierRequest
a} :: UpdateClassifier)

instance Core.AWSRequest UpdateClassifier where
  type
    AWSResponse UpdateClassifier =
      UpdateClassifierResponse
  request :: (Service -> Service)
-> UpdateClassifier -> Request UpdateClassifier
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 UpdateClassifier
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse UpdateClassifier)))
response =
    forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> () -> Either String (AWSResponse a))
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveEmpty
      ( \Int
s ResponseHeaders
h ()
x ->
          Int -> UpdateClassifierResponse
UpdateClassifierResponse'
            forall (f :: * -> *) a b. Functor 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 UpdateClassifier where
  hashWithSalt :: Int -> UpdateClassifier -> Int
hashWithSalt Int
_salt UpdateClassifier' {Maybe UpdateCsvClassifierRequest
Maybe UpdateGrokClassifierRequest
Maybe UpdateJsonClassifierRequest
Maybe UpdateXMLClassifierRequest
xMLClassifier :: Maybe UpdateXMLClassifierRequest
jsonClassifier :: Maybe UpdateJsonClassifierRequest
grokClassifier :: Maybe UpdateGrokClassifierRequest
csvClassifier :: Maybe UpdateCsvClassifierRequest
$sel:xMLClassifier:UpdateClassifier' :: UpdateClassifier -> Maybe UpdateXMLClassifierRequest
$sel:jsonClassifier:UpdateClassifier' :: UpdateClassifier -> Maybe UpdateJsonClassifierRequest
$sel:grokClassifier:UpdateClassifier' :: UpdateClassifier -> Maybe UpdateGrokClassifierRequest
$sel:csvClassifier:UpdateClassifier' :: UpdateClassifier -> Maybe UpdateCsvClassifierRequest
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe UpdateCsvClassifierRequest
csvClassifier
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe UpdateGrokClassifierRequest
grokClassifier
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe UpdateJsonClassifierRequest
jsonClassifier
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe UpdateXMLClassifierRequest
xMLClassifier

instance Prelude.NFData UpdateClassifier where
  rnf :: UpdateClassifier -> ()
rnf UpdateClassifier' {Maybe UpdateCsvClassifierRequest
Maybe UpdateGrokClassifierRequest
Maybe UpdateJsonClassifierRequest
Maybe UpdateXMLClassifierRequest
xMLClassifier :: Maybe UpdateXMLClassifierRequest
jsonClassifier :: Maybe UpdateJsonClassifierRequest
grokClassifier :: Maybe UpdateGrokClassifierRequest
csvClassifier :: Maybe UpdateCsvClassifierRequest
$sel:xMLClassifier:UpdateClassifier' :: UpdateClassifier -> Maybe UpdateXMLClassifierRequest
$sel:jsonClassifier:UpdateClassifier' :: UpdateClassifier -> Maybe UpdateJsonClassifierRequest
$sel:grokClassifier:UpdateClassifier' :: UpdateClassifier -> Maybe UpdateGrokClassifierRequest
$sel:csvClassifier:UpdateClassifier' :: UpdateClassifier -> Maybe UpdateCsvClassifierRequest
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe UpdateCsvClassifierRequest
csvClassifier
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe UpdateGrokClassifierRequest
grokClassifier
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe UpdateJsonClassifierRequest
jsonClassifier
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe UpdateXMLClassifierRequest
xMLClassifier

instance Data.ToHeaders UpdateClassifier where
  toHeaders :: UpdateClassifier -> ResponseHeaders
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 -> ResponseHeaders
Data.=# (ByteString
"AWSGlue.UpdateClassifier" :: Prelude.ByteString),
            HeaderName
"Content-Type"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"application/x-amz-json-1.1" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Data.ToJSON UpdateClassifier where
  toJSON :: UpdateClassifier -> Value
toJSON UpdateClassifier' {Maybe UpdateCsvClassifierRequest
Maybe UpdateGrokClassifierRequest
Maybe UpdateJsonClassifierRequest
Maybe UpdateXMLClassifierRequest
xMLClassifier :: Maybe UpdateXMLClassifierRequest
jsonClassifier :: Maybe UpdateJsonClassifierRequest
grokClassifier :: Maybe UpdateGrokClassifierRequest
csvClassifier :: Maybe UpdateCsvClassifierRequest
$sel:xMLClassifier:UpdateClassifier' :: UpdateClassifier -> Maybe UpdateXMLClassifierRequest
$sel:jsonClassifier:UpdateClassifier' :: UpdateClassifier -> Maybe UpdateJsonClassifierRequest
$sel:grokClassifier:UpdateClassifier' :: UpdateClassifier -> Maybe UpdateGrokClassifierRequest
$sel:csvClassifier:UpdateClassifier' :: UpdateClassifier -> Maybe UpdateCsvClassifierRequest
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"CsvClassifier" 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 UpdateCsvClassifierRequest
csvClassifier,
            (Key
"GrokClassifier" 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 UpdateGrokClassifierRequest
grokClassifier,
            (Key
"JsonClassifier" 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 UpdateJsonClassifierRequest
jsonClassifier,
            (Key
"XMLClassifier" 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 UpdateXMLClassifierRequest
xMLClassifier
          ]
      )

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

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

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

-- |
-- Create a value of 'UpdateClassifierResponse' 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:
--
-- 'httpStatus', 'updateClassifierResponse_httpStatus' - The response's http status code.
newUpdateClassifierResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  UpdateClassifierResponse
newUpdateClassifierResponse :: Int -> UpdateClassifierResponse
newUpdateClassifierResponse Int
pHttpStatus_ =
  UpdateClassifierResponse'
    { $sel:httpStatus:UpdateClassifierResponse' :: Int
httpStatus =
        Int
pHttpStatus_
    }

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

instance Prelude.NFData UpdateClassifierResponse where
  rnf :: UpdateClassifierResponse -> ()
rnf UpdateClassifierResponse' {Int
httpStatus :: Int
$sel:httpStatus:UpdateClassifierResponse' :: UpdateClassifierResponse -> Int
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus