{-# 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.SWF.CountClosedWorkflowExecutions
-- Copyright   : (c) 2013-2021 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay <brendan.g.hay+amazonka@gmail.com>
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Returns the number of closed workflow executions within the given domain
-- that meet the specified filtering criteria.
--
-- This operation is eventually consistent. The results are best effort and
-- may not exactly reflect recent updates and changes.
--
-- __Access Control__
--
-- You can use IAM policies to control this action\'s access to Amazon SWF
-- resources as follows:
--
-- -   Use a @Resource@ element with the domain name to limit the action to
--     only specified domains.
--
-- -   Use an @Action@ element to allow or deny permission to call this
--     action.
--
-- -   Constrain the following parameters by using a @Condition@ element
--     with the appropriate keys.
--
--     -   @tagFilter.tag@: String constraint. The key is
--         @swf:tagFilter.tag@.
--
--     -   @typeFilter.name@: String constraint. The key is
--         @swf:typeFilter.name@.
--
--     -   @typeFilter.version@: String constraint. The key is
--         @swf:typeFilter.version@.
--
-- If the caller doesn\'t have sufficient permissions to invoke the action,
-- or the parameter values fall outside the specified constraints, the
-- action fails. The associated event attribute\'s @cause@ parameter is set
-- to @OPERATION_NOT_PERMITTED@. For details and example IAM policies, see
-- <https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html Using IAM to Manage Access to Amazon SWF Workflows>
-- in the /Amazon SWF Developer Guide/.
module Amazonka.SWF.CountClosedWorkflowExecutions
  ( -- * Creating a Request
    CountClosedWorkflowExecutions (..),
    newCountClosedWorkflowExecutions,

    -- * Request Lenses
    countClosedWorkflowExecutions_executionFilter,
    countClosedWorkflowExecutions_closeStatusFilter,
    countClosedWorkflowExecutions_typeFilter,
    countClosedWorkflowExecutions_closeTimeFilter,
    countClosedWorkflowExecutions_tagFilter,
    countClosedWorkflowExecutions_startTimeFilter,
    countClosedWorkflowExecutions_domain,

    -- * Destructuring the Response
    WorkflowExecutionCount (..),
    newWorkflowExecutionCount,

    -- * Response Lenses
    workflowExecutionCount_truncated,
    workflowExecutionCount_count,
  )
where

import qualified Amazonka.Core as Core
import qualified Amazonka.Lens as Lens
import qualified Amazonka.Prelude as Prelude
import qualified Amazonka.Request as Request
import qualified Amazonka.Response as Response
import Amazonka.SWF.Types

-- | /See:/ 'newCountClosedWorkflowExecutions' smart constructor.
data CountClosedWorkflowExecutions = CountClosedWorkflowExecutions'
  { -- | If specified, only workflow executions matching the @WorkflowId@ in the
    -- filter are counted.
    --
    -- @closeStatusFilter@, @executionFilter@, @typeFilter@ and @tagFilter@ are
    -- mutually exclusive. You can specify at most one of these in a request.
    CountClosedWorkflowExecutions -> Maybe WorkflowExecutionFilter
executionFilter :: Prelude.Maybe WorkflowExecutionFilter,
    -- | If specified, only workflow executions that match this close status are
    -- counted. This filter has an affect only if @executionStatus@ is
    -- specified as @CLOSED@.
    --
    -- @closeStatusFilter@, @executionFilter@, @typeFilter@ and @tagFilter@ are
    -- mutually exclusive. You can specify at most one of these in a request.
    CountClosedWorkflowExecutions -> Maybe CloseStatusFilter
closeStatusFilter :: Prelude.Maybe CloseStatusFilter,
    -- | If specified, indicates the type of the workflow executions to be
    -- counted.
    --
    -- @closeStatusFilter@, @executionFilter@, @typeFilter@ and @tagFilter@ are
    -- mutually exclusive. You can specify at most one of these in a request.
    CountClosedWorkflowExecutions -> Maybe WorkflowTypeFilter
typeFilter :: Prelude.Maybe WorkflowTypeFilter,
    -- | If specified, only workflow executions that meet the close time criteria
    -- of the filter are counted.
    --
    -- @startTimeFilter@ and @closeTimeFilter@ are mutually exclusive. You must
    -- specify one of these in a request but not both.
    CountClosedWorkflowExecutions -> Maybe ExecutionTimeFilter
closeTimeFilter :: Prelude.Maybe ExecutionTimeFilter,
    -- | If specified, only executions that have a tag that matches the filter
    -- are counted.
    --
    -- @closeStatusFilter@, @executionFilter@, @typeFilter@ and @tagFilter@ are
    -- mutually exclusive. You can specify at most one of these in a request.
    CountClosedWorkflowExecutions -> Maybe TagFilter
tagFilter :: Prelude.Maybe TagFilter,
    -- | If specified, only workflow executions that meet the start time criteria
    -- of the filter are counted.
    --
    -- @startTimeFilter@ and @closeTimeFilter@ are mutually exclusive. You must
    -- specify one of these in a request but not both.
    CountClosedWorkflowExecutions -> Maybe ExecutionTimeFilter
startTimeFilter :: Prelude.Maybe ExecutionTimeFilter,
    -- | The name of the domain containing the workflow executions to count.
    CountClosedWorkflowExecutions -> Text
domain :: Prelude.Text
  }
  deriving (CountClosedWorkflowExecutions
-> CountClosedWorkflowExecutions -> Bool
(CountClosedWorkflowExecutions
 -> CountClosedWorkflowExecutions -> Bool)
-> (CountClosedWorkflowExecutions
    -> CountClosedWorkflowExecutions -> Bool)
-> Eq CountClosedWorkflowExecutions
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CountClosedWorkflowExecutions
-> CountClosedWorkflowExecutions -> Bool
$c/= :: CountClosedWorkflowExecutions
-> CountClosedWorkflowExecutions -> Bool
== :: CountClosedWorkflowExecutions
-> CountClosedWorkflowExecutions -> Bool
$c== :: CountClosedWorkflowExecutions
-> CountClosedWorkflowExecutions -> Bool
Prelude.Eq, ReadPrec [CountClosedWorkflowExecutions]
ReadPrec CountClosedWorkflowExecutions
Int -> ReadS CountClosedWorkflowExecutions
ReadS [CountClosedWorkflowExecutions]
(Int -> ReadS CountClosedWorkflowExecutions)
-> ReadS [CountClosedWorkflowExecutions]
-> ReadPrec CountClosedWorkflowExecutions
-> ReadPrec [CountClosedWorkflowExecutions]
-> Read CountClosedWorkflowExecutions
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CountClosedWorkflowExecutions]
$creadListPrec :: ReadPrec [CountClosedWorkflowExecutions]
readPrec :: ReadPrec CountClosedWorkflowExecutions
$creadPrec :: ReadPrec CountClosedWorkflowExecutions
readList :: ReadS [CountClosedWorkflowExecutions]
$creadList :: ReadS [CountClosedWorkflowExecutions]
readsPrec :: Int -> ReadS CountClosedWorkflowExecutions
$creadsPrec :: Int -> ReadS CountClosedWorkflowExecutions
Prelude.Read, Int -> CountClosedWorkflowExecutions -> ShowS
[CountClosedWorkflowExecutions] -> ShowS
CountClosedWorkflowExecutions -> String
(Int -> CountClosedWorkflowExecutions -> ShowS)
-> (CountClosedWorkflowExecutions -> String)
-> ([CountClosedWorkflowExecutions] -> ShowS)
-> Show CountClosedWorkflowExecutions
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CountClosedWorkflowExecutions] -> ShowS
$cshowList :: [CountClosedWorkflowExecutions] -> ShowS
show :: CountClosedWorkflowExecutions -> String
$cshow :: CountClosedWorkflowExecutions -> String
showsPrec :: Int -> CountClosedWorkflowExecutions -> ShowS
$cshowsPrec :: Int -> CountClosedWorkflowExecutions -> ShowS
Prelude.Show, (forall x.
 CountClosedWorkflowExecutions
 -> Rep CountClosedWorkflowExecutions x)
-> (forall x.
    Rep CountClosedWorkflowExecutions x
    -> CountClosedWorkflowExecutions)
-> Generic CountClosedWorkflowExecutions
forall x.
Rep CountClosedWorkflowExecutions x
-> CountClosedWorkflowExecutions
forall x.
CountClosedWorkflowExecutions
-> Rep CountClosedWorkflowExecutions x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep CountClosedWorkflowExecutions x
-> CountClosedWorkflowExecutions
$cfrom :: forall x.
CountClosedWorkflowExecutions
-> Rep CountClosedWorkflowExecutions x
Prelude.Generic)

-- |
-- Create a value of 'CountClosedWorkflowExecutions' 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:
--
-- 'executionFilter', 'countClosedWorkflowExecutions_executionFilter' - If specified, only workflow executions matching the @WorkflowId@ in the
-- filter are counted.
--
-- @closeStatusFilter@, @executionFilter@, @typeFilter@ and @tagFilter@ are
-- mutually exclusive. You can specify at most one of these in a request.
--
-- 'closeStatusFilter', 'countClosedWorkflowExecutions_closeStatusFilter' - If specified, only workflow executions that match this close status are
-- counted. This filter has an affect only if @executionStatus@ is
-- specified as @CLOSED@.
--
-- @closeStatusFilter@, @executionFilter@, @typeFilter@ and @tagFilter@ are
-- mutually exclusive. You can specify at most one of these in a request.
--
-- 'typeFilter', 'countClosedWorkflowExecutions_typeFilter' - If specified, indicates the type of the workflow executions to be
-- counted.
--
-- @closeStatusFilter@, @executionFilter@, @typeFilter@ and @tagFilter@ are
-- mutually exclusive. You can specify at most one of these in a request.
--
-- 'closeTimeFilter', 'countClosedWorkflowExecutions_closeTimeFilter' - If specified, only workflow executions that meet the close time criteria
-- of the filter are counted.
--
-- @startTimeFilter@ and @closeTimeFilter@ are mutually exclusive. You must
-- specify one of these in a request but not both.
--
-- 'tagFilter', 'countClosedWorkflowExecutions_tagFilter' - If specified, only executions that have a tag that matches the filter
-- are counted.
--
-- @closeStatusFilter@, @executionFilter@, @typeFilter@ and @tagFilter@ are
-- mutually exclusive. You can specify at most one of these in a request.
--
-- 'startTimeFilter', 'countClosedWorkflowExecutions_startTimeFilter' - If specified, only workflow executions that meet the start time criteria
-- of the filter are counted.
--
-- @startTimeFilter@ and @closeTimeFilter@ are mutually exclusive. You must
-- specify one of these in a request but not both.
--
-- 'domain', 'countClosedWorkflowExecutions_domain' - The name of the domain containing the workflow executions to count.
newCountClosedWorkflowExecutions ::
  -- | 'domain'
  Prelude.Text ->
  CountClosedWorkflowExecutions
newCountClosedWorkflowExecutions :: Text -> CountClosedWorkflowExecutions
newCountClosedWorkflowExecutions Text
pDomain_ =
  CountClosedWorkflowExecutions' :: Maybe WorkflowExecutionFilter
-> Maybe CloseStatusFilter
-> Maybe WorkflowTypeFilter
-> Maybe ExecutionTimeFilter
-> Maybe TagFilter
-> Maybe ExecutionTimeFilter
-> Text
-> CountClosedWorkflowExecutions
CountClosedWorkflowExecutions'
    { $sel:executionFilter:CountClosedWorkflowExecutions' :: Maybe WorkflowExecutionFilter
executionFilter =
        Maybe WorkflowExecutionFilter
forall a. Maybe a
Prelude.Nothing,
      $sel:closeStatusFilter:CountClosedWorkflowExecutions' :: Maybe CloseStatusFilter
closeStatusFilter = Maybe CloseStatusFilter
forall a. Maybe a
Prelude.Nothing,
      $sel:typeFilter:CountClosedWorkflowExecutions' :: Maybe WorkflowTypeFilter
typeFilter = Maybe WorkflowTypeFilter
forall a. Maybe a
Prelude.Nothing,
      $sel:closeTimeFilter:CountClosedWorkflowExecutions' :: Maybe ExecutionTimeFilter
closeTimeFilter = Maybe ExecutionTimeFilter
forall a. Maybe a
Prelude.Nothing,
      $sel:tagFilter:CountClosedWorkflowExecutions' :: Maybe TagFilter
tagFilter = Maybe TagFilter
forall a. Maybe a
Prelude.Nothing,
      $sel:startTimeFilter:CountClosedWorkflowExecutions' :: Maybe ExecutionTimeFilter
startTimeFilter = Maybe ExecutionTimeFilter
forall a. Maybe a
Prelude.Nothing,
      $sel:domain:CountClosedWorkflowExecutions' :: Text
domain = Text
pDomain_
    }

-- | If specified, only workflow executions matching the @WorkflowId@ in the
-- filter are counted.
--
-- @closeStatusFilter@, @executionFilter@, @typeFilter@ and @tagFilter@ are
-- mutually exclusive. You can specify at most one of these in a request.
countClosedWorkflowExecutions_executionFilter :: Lens.Lens' CountClosedWorkflowExecutions (Prelude.Maybe WorkflowExecutionFilter)
countClosedWorkflowExecutions_executionFilter :: (Maybe WorkflowExecutionFilter
 -> f (Maybe WorkflowExecutionFilter))
-> CountClosedWorkflowExecutions -> f CountClosedWorkflowExecutions
countClosedWorkflowExecutions_executionFilter = (CountClosedWorkflowExecutions -> Maybe WorkflowExecutionFilter)
-> (CountClosedWorkflowExecutions
    -> Maybe WorkflowExecutionFilter -> CountClosedWorkflowExecutions)
-> Lens
     CountClosedWorkflowExecutions
     CountClosedWorkflowExecutions
     (Maybe WorkflowExecutionFilter)
     (Maybe WorkflowExecutionFilter)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CountClosedWorkflowExecutions' {Maybe WorkflowExecutionFilter
executionFilter :: Maybe WorkflowExecutionFilter
$sel:executionFilter:CountClosedWorkflowExecutions' :: CountClosedWorkflowExecutions -> Maybe WorkflowExecutionFilter
executionFilter} -> Maybe WorkflowExecutionFilter
executionFilter) (\s :: CountClosedWorkflowExecutions
s@CountClosedWorkflowExecutions' {} Maybe WorkflowExecutionFilter
a -> CountClosedWorkflowExecutions
s {$sel:executionFilter:CountClosedWorkflowExecutions' :: Maybe WorkflowExecutionFilter
executionFilter = Maybe WorkflowExecutionFilter
a} :: CountClosedWorkflowExecutions)

-- | If specified, only workflow executions that match this close status are
-- counted. This filter has an affect only if @executionStatus@ is
-- specified as @CLOSED@.
--
-- @closeStatusFilter@, @executionFilter@, @typeFilter@ and @tagFilter@ are
-- mutually exclusive. You can specify at most one of these in a request.
countClosedWorkflowExecutions_closeStatusFilter :: Lens.Lens' CountClosedWorkflowExecutions (Prelude.Maybe CloseStatusFilter)
countClosedWorkflowExecutions_closeStatusFilter :: (Maybe CloseStatusFilter -> f (Maybe CloseStatusFilter))
-> CountClosedWorkflowExecutions -> f CountClosedWorkflowExecutions
countClosedWorkflowExecutions_closeStatusFilter = (CountClosedWorkflowExecutions -> Maybe CloseStatusFilter)
-> (CountClosedWorkflowExecutions
    -> Maybe CloseStatusFilter -> CountClosedWorkflowExecutions)
-> Lens
     CountClosedWorkflowExecutions
     CountClosedWorkflowExecutions
     (Maybe CloseStatusFilter)
     (Maybe CloseStatusFilter)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CountClosedWorkflowExecutions' {Maybe CloseStatusFilter
closeStatusFilter :: Maybe CloseStatusFilter
$sel:closeStatusFilter:CountClosedWorkflowExecutions' :: CountClosedWorkflowExecutions -> Maybe CloseStatusFilter
closeStatusFilter} -> Maybe CloseStatusFilter
closeStatusFilter) (\s :: CountClosedWorkflowExecutions
s@CountClosedWorkflowExecutions' {} Maybe CloseStatusFilter
a -> CountClosedWorkflowExecutions
s {$sel:closeStatusFilter:CountClosedWorkflowExecutions' :: Maybe CloseStatusFilter
closeStatusFilter = Maybe CloseStatusFilter
a} :: CountClosedWorkflowExecutions)

-- | If specified, indicates the type of the workflow executions to be
-- counted.
--
-- @closeStatusFilter@, @executionFilter@, @typeFilter@ and @tagFilter@ are
-- mutually exclusive. You can specify at most one of these in a request.
countClosedWorkflowExecutions_typeFilter :: Lens.Lens' CountClosedWorkflowExecutions (Prelude.Maybe WorkflowTypeFilter)
countClosedWorkflowExecutions_typeFilter :: (Maybe WorkflowTypeFilter -> f (Maybe WorkflowTypeFilter))
-> CountClosedWorkflowExecutions -> f CountClosedWorkflowExecutions
countClosedWorkflowExecutions_typeFilter = (CountClosedWorkflowExecutions -> Maybe WorkflowTypeFilter)
-> (CountClosedWorkflowExecutions
    -> Maybe WorkflowTypeFilter -> CountClosedWorkflowExecutions)
-> Lens
     CountClosedWorkflowExecutions
     CountClosedWorkflowExecutions
     (Maybe WorkflowTypeFilter)
     (Maybe WorkflowTypeFilter)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CountClosedWorkflowExecutions' {Maybe WorkflowTypeFilter
typeFilter :: Maybe WorkflowTypeFilter
$sel:typeFilter:CountClosedWorkflowExecutions' :: CountClosedWorkflowExecutions -> Maybe WorkflowTypeFilter
typeFilter} -> Maybe WorkflowTypeFilter
typeFilter) (\s :: CountClosedWorkflowExecutions
s@CountClosedWorkflowExecutions' {} Maybe WorkflowTypeFilter
a -> CountClosedWorkflowExecutions
s {$sel:typeFilter:CountClosedWorkflowExecutions' :: Maybe WorkflowTypeFilter
typeFilter = Maybe WorkflowTypeFilter
a} :: CountClosedWorkflowExecutions)

-- | If specified, only workflow executions that meet the close time criteria
-- of the filter are counted.
--
-- @startTimeFilter@ and @closeTimeFilter@ are mutually exclusive. You must
-- specify one of these in a request but not both.
countClosedWorkflowExecutions_closeTimeFilter :: Lens.Lens' CountClosedWorkflowExecutions (Prelude.Maybe ExecutionTimeFilter)
countClosedWorkflowExecutions_closeTimeFilter :: (Maybe ExecutionTimeFilter -> f (Maybe ExecutionTimeFilter))
-> CountClosedWorkflowExecutions -> f CountClosedWorkflowExecutions
countClosedWorkflowExecutions_closeTimeFilter = (CountClosedWorkflowExecutions -> Maybe ExecutionTimeFilter)
-> (CountClosedWorkflowExecutions
    -> Maybe ExecutionTimeFilter -> CountClosedWorkflowExecutions)
-> Lens
     CountClosedWorkflowExecutions
     CountClosedWorkflowExecutions
     (Maybe ExecutionTimeFilter)
     (Maybe ExecutionTimeFilter)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CountClosedWorkflowExecutions' {Maybe ExecutionTimeFilter
closeTimeFilter :: Maybe ExecutionTimeFilter
$sel:closeTimeFilter:CountClosedWorkflowExecutions' :: CountClosedWorkflowExecutions -> Maybe ExecutionTimeFilter
closeTimeFilter} -> Maybe ExecutionTimeFilter
closeTimeFilter) (\s :: CountClosedWorkflowExecutions
s@CountClosedWorkflowExecutions' {} Maybe ExecutionTimeFilter
a -> CountClosedWorkflowExecutions
s {$sel:closeTimeFilter:CountClosedWorkflowExecutions' :: Maybe ExecutionTimeFilter
closeTimeFilter = Maybe ExecutionTimeFilter
a} :: CountClosedWorkflowExecutions)

-- | If specified, only executions that have a tag that matches the filter
-- are counted.
--
-- @closeStatusFilter@, @executionFilter@, @typeFilter@ and @tagFilter@ are
-- mutually exclusive. You can specify at most one of these in a request.
countClosedWorkflowExecutions_tagFilter :: Lens.Lens' CountClosedWorkflowExecutions (Prelude.Maybe TagFilter)
countClosedWorkflowExecutions_tagFilter :: (Maybe TagFilter -> f (Maybe TagFilter))
-> CountClosedWorkflowExecutions -> f CountClosedWorkflowExecutions
countClosedWorkflowExecutions_tagFilter = (CountClosedWorkflowExecutions -> Maybe TagFilter)
-> (CountClosedWorkflowExecutions
    -> Maybe TagFilter -> CountClosedWorkflowExecutions)
-> Lens
     CountClosedWorkflowExecutions
     CountClosedWorkflowExecutions
     (Maybe TagFilter)
     (Maybe TagFilter)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CountClosedWorkflowExecutions' {Maybe TagFilter
tagFilter :: Maybe TagFilter
$sel:tagFilter:CountClosedWorkflowExecutions' :: CountClosedWorkflowExecutions -> Maybe TagFilter
tagFilter} -> Maybe TagFilter
tagFilter) (\s :: CountClosedWorkflowExecutions
s@CountClosedWorkflowExecutions' {} Maybe TagFilter
a -> CountClosedWorkflowExecutions
s {$sel:tagFilter:CountClosedWorkflowExecutions' :: Maybe TagFilter
tagFilter = Maybe TagFilter
a} :: CountClosedWorkflowExecutions)

-- | If specified, only workflow executions that meet the start time criteria
-- of the filter are counted.
--
-- @startTimeFilter@ and @closeTimeFilter@ are mutually exclusive. You must
-- specify one of these in a request but not both.
countClosedWorkflowExecutions_startTimeFilter :: Lens.Lens' CountClosedWorkflowExecutions (Prelude.Maybe ExecutionTimeFilter)
countClosedWorkflowExecutions_startTimeFilter :: (Maybe ExecutionTimeFilter -> f (Maybe ExecutionTimeFilter))
-> CountClosedWorkflowExecutions -> f CountClosedWorkflowExecutions
countClosedWorkflowExecutions_startTimeFilter = (CountClosedWorkflowExecutions -> Maybe ExecutionTimeFilter)
-> (CountClosedWorkflowExecutions
    -> Maybe ExecutionTimeFilter -> CountClosedWorkflowExecutions)
-> Lens
     CountClosedWorkflowExecutions
     CountClosedWorkflowExecutions
     (Maybe ExecutionTimeFilter)
     (Maybe ExecutionTimeFilter)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CountClosedWorkflowExecutions' {Maybe ExecutionTimeFilter
startTimeFilter :: Maybe ExecutionTimeFilter
$sel:startTimeFilter:CountClosedWorkflowExecutions' :: CountClosedWorkflowExecutions -> Maybe ExecutionTimeFilter
startTimeFilter} -> Maybe ExecutionTimeFilter
startTimeFilter) (\s :: CountClosedWorkflowExecutions
s@CountClosedWorkflowExecutions' {} Maybe ExecutionTimeFilter
a -> CountClosedWorkflowExecutions
s {$sel:startTimeFilter:CountClosedWorkflowExecutions' :: Maybe ExecutionTimeFilter
startTimeFilter = Maybe ExecutionTimeFilter
a} :: CountClosedWorkflowExecutions)

-- | The name of the domain containing the workflow executions to count.
countClosedWorkflowExecutions_domain :: Lens.Lens' CountClosedWorkflowExecutions Prelude.Text
countClosedWorkflowExecutions_domain :: (Text -> f Text)
-> CountClosedWorkflowExecutions -> f CountClosedWorkflowExecutions
countClosedWorkflowExecutions_domain = (CountClosedWorkflowExecutions -> Text)
-> (CountClosedWorkflowExecutions
    -> Text -> CountClosedWorkflowExecutions)
-> Lens
     CountClosedWorkflowExecutions
     CountClosedWorkflowExecutions
     Text
     Text
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CountClosedWorkflowExecutions' {Text
domain :: Text
$sel:domain:CountClosedWorkflowExecutions' :: CountClosedWorkflowExecutions -> Text
domain} -> Text
domain) (\s :: CountClosedWorkflowExecutions
s@CountClosedWorkflowExecutions' {} Text
a -> CountClosedWorkflowExecutions
s {$sel:domain:CountClosedWorkflowExecutions' :: Text
domain = Text
a} :: CountClosedWorkflowExecutions)

instance
  Core.AWSRequest
    CountClosedWorkflowExecutions
  where
  type
    AWSResponse CountClosedWorkflowExecutions =
      WorkflowExecutionCount
  request :: CountClosedWorkflowExecutions
-> Request CountClosedWorkflowExecutions
request = Service
-> CountClosedWorkflowExecutions
-> Request CountClosedWorkflowExecutions
forall a. (ToRequest a, ToJSON a) => Service -> a -> Request a
Request.postJSON Service
defaultService
  response :: Logger
-> Service
-> Proxy CountClosedWorkflowExecutions
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse CountClosedWorkflowExecutions)))
response =
    (Int
 -> ResponseHeaders
 -> Object
 -> Either String (AWSResponse CountClosedWorkflowExecutions))
-> Logger
-> Service
-> Proxy CountClosedWorkflowExecutions
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse CountClosedWorkflowExecutions)))
forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> Object -> Either String (AWSResponse a))
-> Logger
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveJSON
      (\Int
s ResponseHeaders
h Object
x -> Object -> Either String WorkflowExecutionCount
forall a. FromJSON a => Object -> Either String a
Core.eitherParseJSON Object
x)

instance
  Prelude.Hashable
    CountClosedWorkflowExecutions

instance Prelude.NFData CountClosedWorkflowExecutions

instance Core.ToHeaders CountClosedWorkflowExecutions where
  toHeaders :: CountClosedWorkflowExecutions -> ResponseHeaders
toHeaders =
    ResponseHeaders -> CountClosedWorkflowExecutions -> ResponseHeaders
forall a b. a -> b -> a
Prelude.const
      ( [ResponseHeaders] -> ResponseHeaders
forall a. Monoid a => [a] -> a
Prelude.mconcat
          [ HeaderName
"X-Amz-Target"
              HeaderName -> ByteString -> ResponseHeaders
forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Core.=# ( ByteString
"SimpleWorkflowService.CountClosedWorkflowExecutions" ::
                          Prelude.ByteString
                      ),
            HeaderName
"Content-Type"
              HeaderName -> ByteString -> ResponseHeaders
forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Core.=# ( ByteString
"application/x-amz-json-1.0" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Core.ToJSON CountClosedWorkflowExecutions where
  toJSON :: CountClosedWorkflowExecutions -> Value
toJSON CountClosedWorkflowExecutions' {Maybe CloseStatusFilter
Maybe ExecutionTimeFilter
Maybe TagFilter
Maybe WorkflowExecutionFilter
Maybe WorkflowTypeFilter
Text
domain :: Text
startTimeFilter :: Maybe ExecutionTimeFilter
tagFilter :: Maybe TagFilter
closeTimeFilter :: Maybe ExecutionTimeFilter
typeFilter :: Maybe WorkflowTypeFilter
closeStatusFilter :: Maybe CloseStatusFilter
executionFilter :: Maybe WorkflowExecutionFilter
$sel:domain:CountClosedWorkflowExecutions' :: CountClosedWorkflowExecutions -> Text
$sel:startTimeFilter:CountClosedWorkflowExecutions' :: CountClosedWorkflowExecutions -> Maybe ExecutionTimeFilter
$sel:tagFilter:CountClosedWorkflowExecutions' :: CountClosedWorkflowExecutions -> Maybe TagFilter
$sel:closeTimeFilter:CountClosedWorkflowExecutions' :: CountClosedWorkflowExecutions -> Maybe ExecutionTimeFilter
$sel:typeFilter:CountClosedWorkflowExecutions' :: CountClosedWorkflowExecutions -> Maybe WorkflowTypeFilter
$sel:closeStatusFilter:CountClosedWorkflowExecutions' :: CountClosedWorkflowExecutions -> Maybe CloseStatusFilter
$sel:executionFilter:CountClosedWorkflowExecutions' :: CountClosedWorkflowExecutions -> Maybe WorkflowExecutionFilter
..} =
    [Pair] -> Value
Core.object
      ( [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Text
"executionFilter" Text -> WorkflowExecutionFilter -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (WorkflowExecutionFilter -> Pair)
-> Maybe WorkflowExecutionFilter -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe WorkflowExecutionFilter
executionFilter,
            (Text
"closeStatusFilter" Text -> CloseStatusFilter -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (CloseStatusFilter -> Pair)
-> Maybe CloseStatusFilter -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe CloseStatusFilter
closeStatusFilter,
            (Text
"typeFilter" Text -> WorkflowTypeFilter -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (WorkflowTypeFilter -> Pair)
-> Maybe WorkflowTypeFilter -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe WorkflowTypeFilter
typeFilter,
            (Text
"closeTimeFilter" Text -> ExecutionTimeFilter -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (ExecutionTimeFilter -> Pair)
-> Maybe ExecutionTimeFilter -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe ExecutionTimeFilter
closeTimeFilter,
            (Text
"tagFilter" Text -> TagFilter -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (TagFilter -> Pair) -> Maybe TagFilter -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe TagFilter
tagFilter,
            (Text
"startTimeFilter" Text -> ExecutionTimeFilter -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (ExecutionTimeFilter -> Pair)
-> Maybe ExecutionTimeFilter -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe ExecutionTimeFilter
startTimeFilter,
            Pair -> Maybe Pair
forall a. a -> Maybe a
Prelude.Just (Text
"domain" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..= Text
domain)
          ]
      )

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

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