{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
{-# OPTIONS_GHC -fno-warn-unused-matches #-}

-- Derived from AWS service descriptions, licensed under Apache 2.0.

-- |
-- Module      : Amazonka.Textract.Types.ExpenseField
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
module Amazonka.Textract.Types.ExpenseField 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 Amazonka.Textract.Types.ExpenseCurrency
import Amazonka.Textract.Types.ExpenseDetection
import Amazonka.Textract.Types.ExpenseGroupProperty
import Amazonka.Textract.Types.ExpenseType

-- | Breakdown of detected information, seperated into the catagories Type,
-- LabelDetection, and ValueDetection
--
-- /See:/ 'newExpenseField' smart constructor.
data ExpenseField = ExpenseField'
  { -- | Shows the kind of currency, both the code and confidence associated with
    -- any monatary value detected.
    ExpenseField -> Maybe ExpenseCurrency
currency :: Prelude.Maybe ExpenseCurrency,
    -- | Shows which group a response object belongs to, such as whether an
    -- address line belongs to the vendor\'s address or the recipent\'s
    -- address.
    ExpenseField -> Maybe [ExpenseGroupProperty]
groupProperties :: Prelude.Maybe [ExpenseGroupProperty],
    -- | The explicitly stated label of a detected element.
    ExpenseField -> Maybe ExpenseDetection
labelDetection :: Prelude.Maybe ExpenseDetection,
    -- | The page number the value was detected on.
    ExpenseField -> Maybe Natural
pageNumber :: Prelude.Maybe Prelude.Natural,
    -- | The implied label of a detected element. Present alongside
    -- LabelDetection for explicit elements.
    ExpenseField -> Maybe ExpenseType
type' :: Prelude.Maybe ExpenseType,
    -- | The value of a detected element. Present in explicit and implicit
    -- elements.
    ExpenseField -> Maybe ExpenseDetection
valueDetection :: Prelude.Maybe ExpenseDetection
  }
  deriving (ExpenseField -> ExpenseField -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ExpenseField -> ExpenseField -> Bool
$c/= :: ExpenseField -> ExpenseField -> Bool
== :: ExpenseField -> ExpenseField -> Bool
$c== :: ExpenseField -> ExpenseField -> Bool
Prelude.Eq, ReadPrec [ExpenseField]
ReadPrec ExpenseField
Int -> ReadS ExpenseField
ReadS [ExpenseField]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ExpenseField]
$creadListPrec :: ReadPrec [ExpenseField]
readPrec :: ReadPrec ExpenseField
$creadPrec :: ReadPrec ExpenseField
readList :: ReadS [ExpenseField]
$creadList :: ReadS [ExpenseField]
readsPrec :: Int -> ReadS ExpenseField
$creadsPrec :: Int -> ReadS ExpenseField
Prelude.Read, Int -> ExpenseField -> ShowS
[ExpenseField] -> ShowS
ExpenseField -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ExpenseField] -> ShowS
$cshowList :: [ExpenseField] -> ShowS
show :: ExpenseField -> String
$cshow :: ExpenseField -> String
showsPrec :: Int -> ExpenseField -> ShowS
$cshowsPrec :: Int -> ExpenseField -> ShowS
Prelude.Show, forall x. Rep ExpenseField x -> ExpenseField
forall x. ExpenseField -> Rep ExpenseField x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ExpenseField x -> ExpenseField
$cfrom :: forall x. ExpenseField -> Rep ExpenseField x
Prelude.Generic)

-- |
-- Create a value of 'ExpenseField' 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:
--
-- 'currency', 'expenseField_currency' - Shows the kind of currency, both the code and confidence associated with
-- any monatary value detected.
--
-- 'groupProperties', 'expenseField_groupProperties' - Shows which group a response object belongs to, such as whether an
-- address line belongs to the vendor\'s address or the recipent\'s
-- address.
--
-- 'labelDetection', 'expenseField_labelDetection' - The explicitly stated label of a detected element.
--
-- 'pageNumber', 'expenseField_pageNumber' - The page number the value was detected on.
--
-- 'type'', 'expenseField_type' - The implied label of a detected element. Present alongside
-- LabelDetection for explicit elements.
--
-- 'valueDetection', 'expenseField_valueDetection' - The value of a detected element. Present in explicit and implicit
-- elements.
newExpenseField ::
  ExpenseField
newExpenseField :: ExpenseField
newExpenseField =
  ExpenseField'
    { $sel:currency:ExpenseField' :: Maybe ExpenseCurrency
currency = forall a. Maybe a
Prelude.Nothing,
      $sel:groupProperties:ExpenseField' :: Maybe [ExpenseGroupProperty]
groupProperties = forall a. Maybe a
Prelude.Nothing,
      $sel:labelDetection:ExpenseField' :: Maybe ExpenseDetection
labelDetection = forall a. Maybe a
Prelude.Nothing,
      $sel:pageNumber:ExpenseField' :: Maybe Natural
pageNumber = forall a. Maybe a
Prelude.Nothing,
      $sel:type':ExpenseField' :: Maybe ExpenseType
type' = forall a. Maybe a
Prelude.Nothing,
      $sel:valueDetection:ExpenseField' :: Maybe ExpenseDetection
valueDetection = forall a. Maybe a
Prelude.Nothing
    }

-- | Shows the kind of currency, both the code and confidence associated with
-- any monatary value detected.
expenseField_currency :: Lens.Lens' ExpenseField (Prelude.Maybe ExpenseCurrency)
expenseField_currency :: Lens' ExpenseField (Maybe ExpenseCurrency)
expenseField_currency = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ExpenseField' {Maybe ExpenseCurrency
currency :: Maybe ExpenseCurrency
$sel:currency:ExpenseField' :: ExpenseField -> Maybe ExpenseCurrency
currency} -> Maybe ExpenseCurrency
currency) (\s :: ExpenseField
s@ExpenseField' {} Maybe ExpenseCurrency
a -> ExpenseField
s {$sel:currency:ExpenseField' :: Maybe ExpenseCurrency
currency = Maybe ExpenseCurrency
a} :: ExpenseField)

-- | Shows which group a response object belongs to, such as whether an
-- address line belongs to the vendor\'s address or the recipent\'s
-- address.
expenseField_groupProperties :: Lens.Lens' ExpenseField (Prelude.Maybe [ExpenseGroupProperty])
expenseField_groupProperties :: Lens' ExpenseField (Maybe [ExpenseGroupProperty])
expenseField_groupProperties = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ExpenseField' {Maybe [ExpenseGroupProperty]
groupProperties :: Maybe [ExpenseGroupProperty]
$sel:groupProperties:ExpenseField' :: ExpenseField -> Maybe [ExpenseGroupProperty]
groupProperties} -> Maybe [ExpenseGroupProperty]
groupProperties) (\s :: ExpenseField
s@ExpenseField' {} Maybe [ExpenseGroupProperty]
a -> ExpenseField
s {$sel:groupProperties:ExpenseField' :: Maybe [ExpenseGroupProperty]
groupProperties = Maybe [ExpenseGroupProperty]
a} :: ExpenseField) 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 explicitly stated label of a detected element.
expenseField_labelDetection :: Lens.Lens' ExpenseField (Prelude.Maybe ExpenseDetection)
expenseField_labelDetection :: Lens' ExpenseField (Maybe ExpenseDetection)
expenseField_labelDetection = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ExpenseField' {Maybe ExpenseDetection
labelDetection :: Maybe ExpenseDetection
$sel:labelDetection:ExpenseField' :: ExpenseField -> Maybe ExpenseDetection
labelDetection} -> Maybe ExpenseDetection
labelDetection) (\s :: ExpenseField
s@ExpenseField' {} Maybe ExpenseDetection
a -> ExpenseField
s {$sel:labelDetection:ExpenseField' :: Maybe ExpenseDetection
labelDetection = Maybe ExpenseDetection
a} :: ExpenseField)

-- | The page number the value was detected on.
expenseField_pageNumber :: Lens.Lens' ExpenseField (Prelude.Maybe Prelude.Natural)
expenseField_pageNumber :: Lens' ExpenseField (Maybe Natural)
expenseField_pageNumber = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ExpenseField' {Maybe Natural
pageNumber :: Maybe Natural
$sel:pageNumber:ExpenseField' :: ExpenseField -> Maybe Natural
pageNumber} -> Maybe Natural
pageNumber) (\s :: ExpenseField
s@ExpenseField' {} Maybe Natural
a -> ExpenseField
s {$sel:pageNumber:ExpenseField' :: Maybe Natural
pageNumber = Maybe Natural
a} :: ExpenseField)

-- | The implied label of a detected element. Present alongside
-- LabelDetection for explicit elements.
expenseField_type :: Lens.Lens' ExpenseField (Prelude.Maybe ExpenseType)
expenseField_type :: Lens' ExpenseField (Maybe ExpenseType)
expenseField_type = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ExpenseField' {Maybe ExpenseType
type' :: Maybe ExpenseType
$sel:type':ExpenseField' :: ExpenseField -> Maybe ExpenseType
type'} -> Maybe ExpenseType
type') (\s :: ExpenseField
s@ExpenseField' {} Maybe ExpenseType
a -> ExpenseField
s {$sel:type':ExpenseField' :: Maybe ExpenseType
type' = Maybe ExpenseType
a} :: ExpenseField)

-- | The value of a detected element. Present in explicit and implicit
-- elements.
expenseField_valueDetection :: Lens.Lens' ExpenseField (Prelude.Maybe ExpenseDetection)
expenseField_valueDetection :: Lens' ExpenseField (Maybe ExpenseDetection)
expenseField_valueDetection = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ExpenseField' {Maybe ExpenseDetection
valueDetection :: Maybe ExpenseDetection
$sel:valueDetection:ExpenseField' :: ExpenseField -> Maybe ExpenseDetection
valueDetection} -> Maybe ExpenseDetection
valueDetection) (\s :: ExpenseField
s@ExpenseField' {} Maybe ExpenseDetection
a -> ExpenseField
s {$sel:valueDetection:ExpenseField' :: Maybe ExpenseDetection
valueDetection = Maybe ExpenseDetection
a} :: ExpenseField)

instance Data.FromJSON ExpenseField where
  parseJSON :: Value -> Parser ExpenseField
parseJSON =
    forall a. String -> (Object -> Parser a) -> Value -> Parser a
Data.withObject
      String
"ExpenseField"
      ( \Object
x ->
          Maybe ExpenseCurrency
-> Maybe [ExpenseGroupProperty]
-> Maybe ExpenseDetection
-> Maybe Natural
-> Maybe ExpenseType
-> Maybe ExpenseDetection
-> ExpenseField
ExpenseField'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"Currency")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ( Object
x
                            forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"GroupProperties"
                            forall a. Parser (Maybe a) -> a -> Parser a
Data..!= forall a. Monoid a => a
Prelude.mempty
                        )
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"LabelDetection")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"PageNumber")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"Type")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"ValueDetection")
      )

instance Prelude.Hashable ExpenseField where
  hashWithSalt :: Int -> ExpenseField -> Int
hashWithSalt Int
_salt ExpenseField' {Maybe Natural
Maybe [ExpenseGroupProperty]
Maybe ExpenseCurrency
Maybe ExpenseType
Maybe ExpenseDetection
valueDetection :: Maybe ExpenseDetection
type' :: Maybe ExpenseType
pageNumber :: Maybe Natural
labelDetection :: Maybe ExpenseDetection
groupProperties :: Maybe [ExpenseGroupProperty]
currency :: Maybe ExpenseCurrency
$sel:valueDetection:ExpenseField' :: ExpenseField -> Maybe ExpenseDetection
$sel:type':ExpenseField' :: ExpenseField -> Maybe ExpenseType
$sel:pageNumber:ExpenseField' :: ExpenseField -> Maybe Natural
$sel:labelDetection:ExpenseField' :: ExpenseField -> Maybe ExpenseDetection
$sel:groupProperties:ExpenseField' :: ExpenseField -> Maybe [ExpenseGroupProperty]
$sel:currency:ExpenseField' :: ExpenseField -> Maybe ExpenseCurrency
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe ExpenseCurrency
currency
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [ExpenseGroupProperty]
groupProperties
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe ExpenseDetection
labelDetection
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Natural
pageNumber
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe ExpenseType
type'
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe ExpenseDetection
valueDetection

instance Prelude.NFData ExpenseField where
  rnf :: ExpenseField -> ()
rnf ExpenseField' {Maybe Natural
Maybe [ExpenseGroupProperty]
Maybe ExpenseCurrency
Maybe ExpenseType
Maybe ExpenseDetection
valueDetection :: Maybe ExpenseDetection
type' :: Maybe ExpenseType
pageNumber :: Maybe Natural
labelDetection :: Maybe ExpenseDetection
groupProperties :: Maybe [ExpenseGroupProperty]
currency :: Maybe ExpenseCurrency
$sel:valueDetection:ExpenseField' :: ExpenseField -> Maybe ExpenseDetection
$sel:type':ExpenseField' :: ExpenseField -> Maybe ExpenseType
$sel:pageNumber:ExpenseField' :: ExpenseField -> Maybe Natural
$sel:labelDetection:ExpenseField' :: ExpenseField -> Maybe ExpenseDetection
$sel:groupProperties:ExpenseField' :: ExpenseField -> Maybe [ExpenseGroupProperty]
$sel:currency:ExpenseField' :: ExpenseField -> Maybe ExpenseCurrency
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe ExpenseCurrency
currency
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [ExpenseGroupProperty]
groupProperties
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe ExpenseDetection
labelDetection
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Natural
pageNumber
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe ExpenseType
type'
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe ExpenseDetection
valueDetection