{-# 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.Textract.AnalyzeExpense
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- @AnalyzeExpense@ synchronously analyzes an input document for
-- financially related relationships between text.
--
-- Information is returned as @ExpenseDocuments@ and seperated as follows:
--
-- -   @LineItemGroups@- A data set containing @LineItems@ which store
--     information about the lines of text, such as an item purchased and
--     its price on a receipt.
--
-- -   @SummaryFields@- Contains all other information a receipt, such as
--     header information or the vendors name.
module Amazonka.Textract.AnalyzeExpense
  ( -- * Creating a Request
    AnalyzeExpense (..),
    newAnalyzeExpense,

    -- * Request Lenses
    analyzeExpense_document,

    -- * Destructuring the Response
    AnalyzeExpenseResponse (..),
    newAnalyzeExpenseResponse,

    -- * Response Lenses
    analyzeExpenseResponse_documentMetadata,
    analyzeExpenseResponse_expenseDocuments,
    analyzeExpenseResponse_httpStatus,
  )
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.Textract.Types

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

-- |
-- Create a value of 'AnalyzeExpense' 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:
--
-- 'document', 'analyzeExpense_document' - Undocumented member.
newAnalyzeExpense ::
  -- | 'document'
  Document ->
  AnalyzeExpense
newAnalyzeExpense :: Document -> AnalyzeExpense
newAnalyzeExpense Document
pDocument_ =
  AnalyzeExpense' {$sel:document:AnalyzeExpense' :: Document
document = Document
pDocument_}

-- | Undocumented member.
analyzeExpense_document :: Lens.Lens' AnalyzeExpense Document
analyzeExpense_document :: Lens' AnalyzeExpense Document
analyzeExpense_document = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\AnalyzeExpense' {Document
document :: Document
$sel:document:AnalyzeExpense' :: AnalyzeExpense -> Document
document} -> Document
document) (\s :: AnalyzeExpense
s@AnalyzeExpense' {} Document
a -> AnalyzeExpense
s {$sel:document:AnalyzeExpense' :: Document
document = Document
a} :: AnalyzeExpense)

instance Core.AWSRequest AnalyzeExpense where
  type
    AWSResponse AnalyzeExpense =
      AnalyzeExpenseResponse
  request :: (Service -> Service) -> AnalyzeExpense -> Request AnalyzeExpense
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 AnalyzeExpense
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse AnalyzeExpense)))
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 DocumentMetadata
-> Maybe [ExpenseDocument] -> Int -> AnalyzeExpenseResponse
AnalyzeExpenseResponse'
            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
"DocumentMetadata")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ( Object
x
                            forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"ExpenseDocuments"
                            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 AnalyzeExpense where
  hashWithSalt :: Int -> AnalyzeExpense -> Int
hashWithSalt Int
_salt AnalyzeExpense' {Document
document :: Document
$sel:document:AnalyzeExpense' :: AnalyzeExpense -> Document
..} =
    Int
_salt forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Document
document

instance Prelude.NFData AnalyzeExpense where
  rnf :: AnalyzeExpense -> ()
rnf AnalyzeExpense' {Document
document :: Document
$sel:document:AnalyzeExpense' :: AnalyzeExpense -> Document
..} = forall a. NFData a => a -> ()
Prelude.rnf Document
document

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

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

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

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

-- |
-- Create a value of 'AnalyzeExpenseResponse' 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:
--
-- 'documentMetadata', 'analyzeExpenseResponse_documentMetadata' - Undocumented member.
--
-- 'expenseDocuments', 'analyzeExpenseResponse_expenseDocuments' - The expenses detected by Amazon Textract.
--
-- 'httpStatus', 'analyzeExpenseResponse_httpStatus' - The response's http status code.
newAnalyzeExpenseResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  AnalyzeExpenseResponse
newAnalyzeExpenseResponse :: Int -> AnalyzeExpenseResponse
newAnalyzeExpenseResponse Int
pHttpStatus_ =
  AnalyzeExpenseResponse'
    { $sel:documentMetadata:AnalyzeExpenseResponse' :: Maybe DocumentMetadata
documentMetadata =
        forall a. Maybe a
Prelude.Nothing,
      $sel:expenseDocuments:AnalyzeExpenseResponse' :: Maybe [ExpenseDocument]
expenseDocuments = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:AnalyzeExpenseResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | Undocumented member.
analyzeExpenseResponse_documentMetadata :: Lens.Lens' AnalyzeExpenseResponse (Prelude.Maybe DocumentMetadata)
analyzeExpenseResponse_documentMetadata :: Lens' AnalyzeExpenseResponse (Maybe DocumentMetadata)
analyzeExpenseResponse_documentMetadata = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\AnalyzeExpenseResponse' {Maybe DocumentMetadata
documentMetadata :: Maybe DocumentMetadata
$sel:documentMetadata:AnalyzeExpenseResponse' :: AnalyzeExpenseResponse -> Maybe DocumentMetadata
documentMetadata} -> Maybe DocumentMetadata
documentMetadata) (\s :: AnalyzeExpenseResponse
s@AnalyzeExpenseResponse' {} Maybe DocumentMetadata
a -> AnalyzeExpenseResponse
s {$sel:documentMetadata:AnalyzeExpenseResponse' :: Maybe DocumentMetadata
documentMetadata = Maybe DocumentMetadata
a} :: AnalyzeExpenseResponse)

-- | The expenses detected by Amazon Textract.
analyzeExpenseResponse_expenseDocuments :: Lens.Lens' AnalyzeExpenseResponse (Prelude.Maybe [ExpenseDocument])
analyzeExpenseResponse_expenseDocuments :: Lens' AnalyzeExpenseResponse (Maybe [ExpenseDocument])
analyzeExpenseResponse_expenseDocuments = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\AnalyzeExpenseResponse' {Maybe [ExpenseDocument]
expenseDocuments :: Maybe [ExpenseDocument]
$sel:expenseDocuments:AnalyzeExpenseResponse' :: AnalyzeExpenseResponse -> Maybe [ExpenseDocument]
expenseDocuments} -> Maybe [ExpenseDocument]
expenseDocuments) (\s :: AnalyzeExpenseResponse
s@AnalyzeExpenseResponse' {} Maybe [ExpenseDocument]
a -> AnalyzeExpenseResponse
s {$sel:expenseDocuments:AnalyzeExpenseResponse' :: Maybe [ExpenseDocument]
expenseDocuments = Maybe [ExpenseDocument]
a} :: AnalyzeExpenseResponse) 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.
analyzeExpenseResponse_httpStatus :: Lens.Lens' AnalyzeExpenseResponse Prelude.Int
analyzeExpenseResponse_httpStatus :: Lens' AnalyzeExpenseResponse Int
analyzeExpenseResponse_httpStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\AnalyzeExpenseResponse' {Int
httpStatus :: Int
$sel:httpStatus:AnalyzeExpenseResponse' :: AnalyzeExpenseResponse -> Int
httpStatus} -> Int
httpStatus) (\s :: AnalyzeExpenseResponse
s@AnalyzeExpenseResponse' {} Int
a -> AnalyzeExpenseResponse
s {$sel:httpStatus:AnalyzeExpenseResponse' :: Int
httpStatus = Int
a} :: AnalyzeExpenseResponse)

instance Prelude.NFData AnalyzeExpenseResponse where
  rnf :: AnalyzeExpenseResponse -> ()
rnf AnalyzeExpenseResponse' {Int
Maybe [ExpenseDocument]
Maybe DocumentMetadata
httpStatus :: Int
expenseDocuments :: Maybe [ExpenseDocument]
documentMetadata :: Maybe DocumentMetadata
$sel:httpStatus:AnalyzeExpenseResponse' :: AnalyzeExpenseResponse -> Int
$sel:expenseDocuments:AnalyzeExpenseResponse' :: AnalyzeExpenseResponse -> Maybe [ExpenseDocument]
$sel:documentMetadata:AnalyzeExpenseResponse' :: AnalyzeExpenseResponse -> Maybe DocumentMetadata
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe DocumentMetadata
documentMetadata
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [ExpenseDocument]
expenseDocuments
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus