{-# 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.CreateCustomEntityType
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Creates a custom pattern that is used to detect sensitive data across
-- the columns and rows of your structured data.
--
-- Each custom pattern you create specifies a regular expression and an
-- optional list of context words. If no context words are passed only a
-- regular expression is checked.
module Amazonka.Glue.CreateCustomEntityType
  ( -- * Creating a Request
    CreateCustomEntityType (..),
    newCreateCustomEntityType,

    -- * Request Lenses
    createCustomEntityType_contextWords,
    createCustomEntityType_name,
    createCustomEntityType_regexString,

    -- * Destructuring the Response
    CreateCustomEntityTypeResponse (..),
    newCreateCustomEntityTypeResponse,

    -- * Response Lenses
    createCustomEntityTypeResponse_name,
    createCustomEntityTypeResponse_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:/ 'newCreateCustomEntityType' smart constructor.
data CreateCustomEntityType = CreateCustomEntityType'
  { -- | A list of context words. If none of these context words are found within
    -- the vicinity of the regular expression the data will not be detected as
    -- sensitive data.
    --
    -- If no context words are passed only a regular expression is checked.
    CreateCustomEntityType -> Maybe (NonEmpty Text)
contextWords :: Prelude.Maybe (Prelude.NonEmpty Prelude.Text),
    -- | A name for the custom pattern that allows it to be retrieved or deleted
    -- later. This name must be unique per Amazon Web Services account.
    CreateCustomEntityType -> Text
name :: Prelude.Text,
    -- | A regular expression string that is used for detecting sensitive data in
    -- a custom pattern.
    CreateCustomEntityType -> Text
regexString :: Prelude.Text
  }
  deriving (CreateCustomEntityType -> CreateCustomEntityType -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateCustomEntityType -> CreateCustomEntityType -> Bool
$c/= :: CreateCustomEntityType -> CreateCustomEntityType -> Bool
== :: CreateCustomEntityType -> CreateCustomEntityType -> Bool
$c== :: CreateCustomEntityType -> CreateCustomEntityType -> Bool
Prelude.Eq, ReadPrec [CreateCustomEntityType]
ReadPrec CreateCustomEntityType
Int -> ReadS CreateCustomEntityType
ReadS [CreateCustomEntityType]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateCustomEntityType]
$creadListPrec :: ReadPrec [CreateCustomEntityType]
readPrec :: ReadPrec CreateCustomEntityType
$creadPrec :: ReadPrec CreateCustomEntityType
readList :: ReadS [CreateCustomEntityType]
$creadList :: ReadS [CreateCustomEntityType]
readsPrec :: Int -> ReadS CreateCustomEntityType
$creadsPrec :: Int -> ReadS CreateCustomEntityType
Prelude.Read, Int -> CreateCustomEntityType -> ShowS
[CreateCustomEntityType] -> ShowS
CreateCustomEntityType -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateCustomEntityType] -> ShowS
$cshowList :: [CreateCustomEntityType] -> ShowS
show :: CreateCustomEntityType -> String
$cshow :: CreateCustomEntityType -> String
showsPrec :: Int -> CreateCustomEntityType -> ShowS
$cshowsPrec :: Int -> CreateCustomEntityType -> ShowS
Prelude.Show, forall x. Rep CreateCustomEntityType x -> CreateCustomEntityType
forall x. CreateCustomEntityType -> Rep CreateCustomEntityType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateCustomEntityType x -> CreateCustomEntityType
$cfrom :: forall x. CreateCustomEntityType -> Rep CreateCustomEntityType x
Prelude.Generic)

-- |
-- Create a value of 'CreateCustomEntityType' 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:
--
-- 'contextWords', 'createCustomEntityType_contextWords' - A list of context words. If none of these context words are found within
-- the vicinity of the regular expression the data will not be detected as
-- sensitive data.
--
-- If no context words are passed only a regular expression is checked.
--
-- 'name', 'createCustomEntityType_name' - A name for the custom pattern that allows it to be retrieved or deleted
-- later. This name must be unique per Amazon Web Services account.
--
-- 'regexString', 'createCustomEntityType_regexString' - A regular expression string that is used for detecting sensitive data in
-- a custom pattern.
newCreateCustomEntityType ::
  -- | 'name'
  Prelude.Text ->
  -- | 'regexString'
  Prelude.Text ->
  CreateCustomEntityType
newCreateCustomEntityType :: Text -> Text -> CreateCustomEntityType
newCreateCustomEntityType Text
pName_ Text
pRegexString_ =
  CreateCustomEntityType'
    { $sel:contextWords:CreateCustomEntityType' :: Maybe (NonEmpty Text)
contextWords =
        forall a. Maybe a
Prelude.Nothing,
      $sel:name:CreateCustomEntityType' :: Text
name = Text
pName_,
      $sel:regexString:CreateCustomEntityType' :: Text
regexString = Text
pRegexString_
    }

-- | A list of context words. If none of these context words are found within
-- the vicinity of the regular expression the data will not be detected as
-- sensitive data.
--
-- If no context words are passed only a regular expression is checked.
createCustomEntityType_contextWords :: Lens.Lens' CreateCustomEntityType (Prelude.Maybe (Prelude.NonEmpty Prelude.Text))
createCustomEntityType_contextWords :: Lens' CreateCustomEntityType (Maybe (NonEmpty Text))
createCustomEntityType_contextWords = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateCustomEntityType' {Maybe (NonEmpty Text)
contextWords :: Maybe (NonEmpty Text)
$sel:contextWords:CreateCustomEntityType' :: CreateCustomEntityType -> Maybe (NonEmpty Text)
contextWords} -> Maybe (NonEmpty Text)
contextWords) (\s :: CreateCustomEntityType
s@CreateCustomEntityType' {} Maybe (NonEmpty Text)
a -> CreateCustomEntityType
s {$sel:contextWords:CreateCustomEntityType' :: Maybe (NonEmpty Text)
contextWords = Maybe (NonEmpty Text)
a} :: CreateCustomEntityType) 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

-- | A name for the custom pattern that allows it to be retrieved or deleted
-- later. This name must be unique per Amazon Web Services account.
createCustomEntityType_name :: Lens.Lens' CreateCustomEntityType Prelude.Text
createCustomEntityType_name :: Lens' CreateCustomEntityType Text
createCustomEntityType_name = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateCustomEntityType' {Text
name :: Text
$sel:name:CreateCustomEntityType' :: CreateCustomEntityType -> Text
name} -> Text
name) (\s :: CreateCustomEntityType
s@CreateCustomEntityType' {} Text
a -> CreateCustomEntityType
s {$sel:name:CreateCustomEntityType' :: Text
name = Text
a} :: CreateCustomEntityType)

-- | A regular expression string that is used for detecting sensitive data in
-- a custom pattern.
createCustomEntityType_regexString :: Lens.Lens' CreateCustomEntityType Prelude.Text
createCustomEntityType_regexString :: Lens' CreateCustomEntityType Text
createCustomEntityType_regexString = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateCustomEntityType' {Text
regexString :: Text
$sel:regexString:CreateCustomEntityType' :: CreateCustomEntityType -> Text
regexString} -> Text
regexString) (\s :: CreateCustomEntityType
s@CreateCustomEntityType' {} Text
a -> CreateCustomEntityType
s {$sel:regexString:CreateCustomEntityType' :: Text
regexString = Text
a} :: CreateCustomEntityType)

instance Core.AWSRequest CreateCustomEntityType where
  type
    AWSResponse CreateCustomEntityType =
      CreateCustomEntityTypeResponse
  request :: (Service -> Service)
-> CreateCustomEntityType -> Request CreateCustomEntityType
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 CreateCustomEntityType
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse CreateCustomEntityType)))
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 -> Int -> CreateCustomEntityTypeResponse
CreateCustomEntityTypeResponse'
            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
"Name")
            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 CreateCustomEntityType where
  hashWithSalt :: Int -> CreateCustomEntityType -> Int
hashWithSalt Int
_salt CreateCustomEntityType' {Maybe (NonEmpty Text)
Text
regexString :: Text
name :: Text
contextWords :: Maybe (NonEmpty Text)
$sel:regexString:CreateCustomEntityType' :: CreateCustomEntityType -> Text
$sel:name:CreateCustomEntityType' :: CreateCustomEntityType -> Text
$sel:contextWords:CreateCustomEntityType' :: CreateCustomEntityType -> Maybe (NonEmpty Text)
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (NonEmpty Text)
contextWords
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
name
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
regexString

instance Prelude.NFData CreateCustomEntityType where
  rnf :: CreateCustomEntityType -> ()
rnf CreateCustomEntityType' {Maybe (NonEmpty Text)
Text
regexString :: Text
name :: Text
contextWords :: Maybe (NonEmpty Text)
$sel:regexString:CreateCustomEntityType' :: CreateCustomEntityType -> Text
$sel:name:CreateCustomEntityType' :: CreateCustomEntityType -> Text
$sel:contextWords:CreateCustomEntityType' :: CreateCustomEntityType -> Maybe (NonEmpty Text)
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe (NonEmpty Text)
contextWords
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
name
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
regexString

instance Data.ToHeaders CreateCustomEntityType where
  toHeaders :: CreateCustomEntityType -> 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.CreateCustomEntityType" ::
                          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 CreateCustomEntityType where
  toJSON :: CreateCustomEntityType -> Value
toJSON CreateCustomEntityType' {Maybe (NonEmpty Text)
Text
regexString :: Text
name :: Text
contextWords :: Maybe (NonEmpty Text)
$sel:regexString:CreateCustomEntityType' :: CreateCustomEntityType -> Text
$sel:name:CreateCustomEntityType' :: CreateCustomEntityType -> Text
$sel:contextWords:CreateCustomEntityType' :: CreateCustomEntityType -> Maybe (NonEmpty Text)
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"ContextWords" 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 (NonEmpty Text)
contextWords,
            forall a. a -> Maybe a
Prelude.Just (Key
"Name" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
name),
            forall a. a -> Maybe a
Prelude.Just (Key
"RegexString" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
regexString)
          ]
      )

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

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

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

-- |
-- Create a value of 'CreateCustomEntityTypeResponse' 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:
--
-- 'name', 'createCustomEntityTypeResponse_name' - The name of the custom pattern you created.
--
-- 'httpStatus', 'createCustomEntityTypeResponse_httpStatus' - The response's http status code.
newCreateCustomEntityTypeResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  CreateCustomEntityTypeResponse
newCreateCustomEntityTypeResponse :: Int -> CreateCustomEntityTypeResponse
newCreateCustomEntityTypeResponse Int
pHttpStatus_ =
  CreateCustomEntityTypeResponse'
    { $sel:name:CreateCustomEntityTypeResponse' :: Maybe Text
name =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:CreateCustomEntityTypeResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The name of the custom pattern you created.
createCustomEntityTypeResponse_name :: Lens.Lens' CreateCustomEntityTypeResponse (Prelude.Maybe Prelude.Text)
createCustomEntityTypeResponse_name :: Lens' CreateCustomEntityTypeResponse (Maybe Text)
createCustomEntityTypeResponse_name = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateCustomEntityTypeResponse' {Maybe Text
name :: Maybe Text
$sel:name:CreateCustomEntityTypeResponse' :: CreateCustomEntityTypeResponse -> Maybe Text
name} -> Maybe Text
name) (\s :: CreateCustomEntityTypeResponse
s@CreateCustomEntityTypeResponse' {} Maybe Text
a -> CreateCustomEntityTypeResponse
s {$sel:name:CreateCustomEntityTypeResponse' :: Maybe Text
name = Maybe Text
a} :: CreateCustomEntityTypeResponse)

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

instance
  Prelude.NFData
    CreateCustomEntityTypeResponse
  where
  rnf :: CreateCustomEntityTypeResponse -> ()
rnf CreateCustomEntityTypeResponse' {Int
Maybe Text
httpStatus :: Int
name :: Maybe Text
$sel:httpStatus:CreateCustomEntityTypeResponse' :: CreateCustomEntityTypeResponse -> Int
$sel:name:CreateCustomEntityTypeResponse' :: CreateCustomEntityTypeResponse -> Maybe Text
..} =
    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 Int
httpStatus