{-# 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.Comprehend.ContainsPiiEntities
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Analyzes input text for the presence of personally identifiable
-- information (PII) and returns the labels of identified PII entity types
-- such as name, address, bank account number, or phone number.
module Amazonka.Comprehend.ContainsPiiEntities
  ( -- * Creating a Request
    ContainsPiiEntities (..),
    newContainsPiiEntities,

    -- * Request Lenses
    containsPiiEntities_text,
    containsPiiEntities_languageCode,

    -- * Destructuring the Response
    ContainsPiiEntitiesResponse (..),
    newContainsPiiEntitiesResponse,

    -- * Response Lenses
    containsPiiEntitiesResponse_labels,
    containsPiiEntitiesResponse_httpStatus,
  )
where

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

-- | /See:/ 'newContainsPiiEntities' smart constructor.
data ContainsPiiEntities = ContainsPiiEntities'
  { -- | A UTF-8 text string. The maximum string size is 100 KB.
    ContainsPiiEntities -> Text
text :: Prelude.Text,
    -- | The language of the input documents. Currently, English is the only
    -- valid language.
    ContainsPiiEntities -> LanguageCode
languageCode :: LanguageCode
  }
  deriving (ContainsPiiEntities -> ContainsPiiEntities -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ContainsPiiEntities -> ContainsPiiEntities -> Bool
$c/= :: ContainsPiiEntities -> ContainsPiiEntities -> Bool
== :: ContainsPiiEntities -> ContainsPiiEntities -> Bool
$c== :: ContainsPiiEntities -> ContainsPiiEntities -> Bool
Prelude.Eq, ReadPrec [ContainsPiiEntities]
ReadPrec ContainsPiiEntities
Int -> ReadS ContainsPiiEntities
ReadS [ContainsPiiEntities]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ContainsPiiEntities]
$creadListPrec :: ReadPrec [ContainsPiiEntities]
readPrec :: ReadPrec ContainsPiiEntities
$creadPrec :: ReadPrec ContainsPiiEntities
readList :: ReadS [ContainsPiiEntities]
$creadList :: ReadS [ContainsPiiEntities]
readsPrec :: Int -> ReadS ContainsPiiEntities
$creadsPrec :: Int -> ReadS ContainsPiiEntities
Prelude.Read, Int -> ContainsPiiEntities -> ShowS
[ContainsPiiEntities] -> ShowS
ContainsPiiEntities -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ContainsPiiEntities] -> ShowS
$cshowList :: [ContainsPiiEntities] -> ShowS
show :: ContainsPiiEntities -> String
$cshow :: ContainsPiiEntities -> String
showsPrec :: Int -> ContainsPiiEntities -> ShowS
$cshowsPrec :: Int -> ContainsPiiEntities -> ShowS
Prelude.Show, forall x. Rep ContainsPiiEntities x -> ContainsPiiEntities
forall x. ContainsPiiEntities -> Rep ContainsPiiEntities x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ContainsPiiEntities x -> ContainsPiiEntities
$cfrom :: forall x. ContainsPiiEntities -> Rep ContainsPiiEntities x
Prelude.Generic)

-- |
-- Create a value of 'ContainsPiiEntities' 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:
--
-- 'text', 'containsPiiEntities_text' - A UTF-8 text string. The maximum string size is 100 KB.
--
-- 'languageCode', 'containsPiiEntities_languageCode' - The language of the input documents. Currently, English is the only
-- valid language.
newContainsPiiEntities ::
  -- | 'text'
  Prelude.Text ->
  -- | 'languageCode'
  LanguageCode ->
  ContainsPiiEntities
newContainsPiiEntities :: Text -> LanguageCode -> ContainsPiiEntities
newContainsPiiEntities Text
pText_ LanguageCode
pLanguageCode_ =
  ContainsPiiEntities'
    { $sel:text:ContainsPiiEntities' :: Text
text = Text
pText_,
      $sel:languageCode:ContainsPiiEntities' :: LanguageCode
languageCode = LanguageCode
pLanguageCode_
    }

-- | A UTF-8 text string. The maximum string size is 100 KB.
containsPiiEntities_text :: Lens.Lens' ContainsPiiEntities Prelude.Text
containsPiiEntities_text :: Lens' ContainsPiiEntities Text
containsPiiEntities_text = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ContainsPiiEntities' {Text
text :: Text
$sel:text:ContainsPiiEntities' :: ContainsPiiEntities -> Text
text} -> Text
text) (\s :: ContainsPiiEntities
s@ContainsPiiEntities' {} Text
a -> ContainsPiiEntities
s {$sel:text:ContainsPiiEntities' :: Text
text = Text
a} :: ContainsPiiEntities)

-- | The language of the input documents. Currently, English is the only
-- valid language.
containsPiiEntities_languageCode :: Lens.Lens' ContainsPiiEntities LanguageCode
containsPiiEntities_languageCode :: Lens' ContainsPiiEntities LanguageCode
containsPiiEntities_languageCode = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ContainsPiiEntities' {LanguageCode
languageCode :: LanguageCode
$sel:languageCode:ContainsPiiEntities' :: ContainsPiiEntities -> LanguageCode
languageCode} -> LanguageCode
languageCode) (\s :: ContainsPiiEntities
s@ContainsPiiEntities' {} LanguageCode
a -> ContainsPiiEntities
s {$sel:languageCode:ContainsPiiEntities' :: LanguageCode
languageCode = LanguageCode
a} :: ContainsPiiEntities)

instance Core.AWSRequest ContainsPiiEntities where
  type
    AWSResponse ContainsPiiEntities =
      ContainsPiiEntitiesResponse
  request :: (Service -> Service)
-> ContainsPiiEntities -> Request ContainsPiiEntities
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 ContainsPiiEntities
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse ContainsPiiEntities)))
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 [EntityLabel] -> Int -> ContainsPiiEntitiesResponse
ContainsPiiEntitiesResponse'
            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
"Labels" forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty)
            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 ContainsPiiEntities where
  hashWithSalt :: Int -> ContainsPiiEntities -> Int
hashWithSalt Int
_salt ContainsPiiEntities' {Text
LanguageCode
languageCode :: LanguageCode
text :: Text
$sel:languageCode:ContainsPiiEntities' :: ContainsPiiEntities -> LanguageCode
$sel:text:ContainsPiiEntities' :: ContainsPiiEntities -> Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
text
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` LanguageCode
languageCode

instance Prelude.NFData ContainsPiiEntities where
  rnf :: ContainsPiiEntities -> ()
rnf ContainsPiiEntities' {Text
LanguageCode
languageCode :: LanguageCode
text :: Text
$sel:languageCode:ContainsPiiEntities' :: ContainsPiiEntities -> LanguageCode
$sel:text:ContainsPiiEntities' :: ContainsPiiEntities -> Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Text
text
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf LanguageCode
languageCode

instance Data.ToHeaders ContainsPiiEntities where
  toHeaders :: ContainsPiiEntities -> 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
"Comprehend_20171127.ContainsPiiEntities" ::
                          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 ContainsPiiEntities where
  toJSON :: ContainsPiiEntities -> Value
toJSON ContainsPiiEntities' {Text
LanguageCode
languageCode :: LanguageCode
text :: Text
$sel:languageCode:ContainsPiiEntities' :: ContainsPiiEntities -> LanguageCode
$sel:text:ContainsPiiEntities' :: ContainsPiiEntities -> Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ forall a. a -> Maybe a
Prelude.Just (Key
"Text" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
text),
            forall a. a -> Maybe a
Prelude.Just (Key
"LanguageCode" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= LanguageCode
languageCode)
          ]
      )

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

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

-- | /See:/ 'newContainsPiiEntitiesResponse' smart constructor.
data ContainsPiiEntitiesResponse = ContainsPiiEntitiesResponse'
  { -- | The labels used in the document being analyzed. Individual labels
    -- represent personally identifiable information (PII) entity types.
    ContainsPiiEntitiesResponse -> Maybe [EntityLabel]
labels :: Prelude.Maybe [EntityLabel],
    -- | The response's http status code.
    ContainsPiiEntitiesResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (ContainsPiiEntitiesResponse -> ContainsPiiEntitiesResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ContainsPiiEntitiesResponse -> ContainsPiiEntitiesResponse -> Bool
$c/= :: ContainsPiiEntitiesResponse -> ContainsPiiEntitiesResponse -> Bool
== :: ContainsPiiEntitiesResponse -> ContainsPiiEntitiesResponse -> Bool
$c== :: ContainsPiiEntitiesResponse -> ContainsPiiEntitiesResponse -> Bool
Prelude.Eq, ReadPrec [ContainsPiiEntitiesResponse]
ReadPrec ContainsPiiEntitiesResponse
Int -> ReadS ContainsPiiEntitiesResponse
ReadS [ContainsPiiEntitiesResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ContainsPiiEntitiesResponse]
$creadListPrec :: ReadPrec [ContainsPiiEntitiesResponse]
readPrec :: ReadPrec ContainsPiiEntitiesResponse
$creadPrec :: ReadPrec ContainsPiiEntitiesResponse
readList :: ReadS [ContainsPiiEntitiesResponse]
$creadList :: ReadS [ContainsPiiEntitiesResponse]
readsPrec :: Int -> ReadS ContainsPiiEntitiesResponse
$creadsPrec :: Int -> ReadS ContainsPiiEntitiesResponse
Prelude.Read, Int -> ContainsPiiEntitiesResponse -> ShowS
[ContainsPiiEntitiesResponse] -> ShowS
ContainsPiiEntitiesResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ContainsPiiEntitiesResponse] -> ShowS
$cshowList :: [ContainsPiiEntitiesResponse] -> ShowS
show :: ContainsPiiEntitiesResponse -> String
$cshow :: ContainsPiiEntitiesResponse -> String
showsPrec :: Int -> ContainsPiiEntitiesResponse -> ShowS
$cshowsPrec :: Int -> ContainsPiiEntitiesResponse -> ShowS
Prelude.Show, forall x.
Rep ContainsPiiEntitiesResponse x -> ContainsPiiEntitiesResponse
forall x.
ContainsPiiEntitiesResponse -> Rep ContainsPiiEntitiesResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep ContainsPiiEntitiesResponse x -> ContainsPiiEntitiesResponse
$cfrom :: forall x.
ContainsPiiEntitiesResponse -> Rep ContainsPiiEntitiesResponse x
Prelude.Generic)

-- |
-- Create a value of 'ContainsPiiEntitiesResponse' 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:
--
-- 'labels', 'containsPiiEntitiesResponse_labels' - The labels used in the document being analyzed. Individual labels
-- represent personally identifiable information (PII) entity types.
--
-- 'httpStatus', 'containsPiiEntitiesResponse_httpStatus' - The response's http status code.
newContainsPiiEntitiesResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  ContainsPiiEntitiesResponse
newContainsPiiEntitiesResponse :: Int -> ContainsPiiEntitiesResponse
newContainsPiiEntitiesResponse Int
pHttpStatus_ =
  ContainsPiiEntitiesResponse'
    { $sel:labels:ContainsPiiEntitiesResponse' :: Maybe [EntityLabel]
labels =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:ContainsPiiEntitiesResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The labels used in the document being analyzed. Individual labels
-- represent personally identifiable information (PII) entity types.
containsPiiEntitiesResponse_labels :: Lens.Lens' ContainsPiiEntitiesResponse (Prelude.Maybe [EntityLabel])
containsPiiEntitiesResponse_labels :: Lens' ContainsPiiEntitiesResponse (Maybe [EntityLabel])
containsPiiEntitiesResponse_labels = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ContainsPiiEntitiesResponse' {Maybe [EntityLabel]
labels :: Maybe [EntityLabel]
$sel:labels:ContainsPiiEntitiesResponse' :: ContainsPiiEntitiesResponse -> Maybe [EntityLabel]
labels} -> Maybe [EntityLabel]
labels) (\s :: ContainsPiiEntitiesResponse
s@ContainsPiiEntitiesResponse' {} Maybe [EntityLabel]
a -> ContainsPiiEntitiesResponse
s {$sel:labels:ContainsPiiEntitiesResponse' :: Maybe [EntityLabel]
labels = Maybe [EntityLabel]
a} :: ContainsPiiEntitiesResponse) 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

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

instance Prelude.NFData ContainsPiiEntitiesResponse where
  rnf :: ContainsPiiEntitiesResponse -> ()
rnf ContainsPiiEntitiesResponse' {Int
Maybe [EntityLabel]
httpStatus :: Int
labels :: Maybe [EntityLabel]
$sel:httpStatus:ContainsPiiEntitiesResponse' :: ContainsPiiEntitiesResponse -> Int
$sel:labels:ContainsPiiEntitiesResponse' :: ContainsPiiEntitiesResponse -> Maybe [EntityLabel]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [EntityLabel]
labels
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus