{-# 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.CloudWatchEvents.Types.Target
-- 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.CloudWatchEvents.Types.Target where

import Amazonka.CloudWatchEvents.Types.BatchParameters
import Amazonka.CloudWatchEvents.Types.DeadLetterConfig
import Amazonka.CloudWatchEvents.Types.EcsParameters
import Amazonka.CloudWatchEvents.Types.HttpParameters
import Amazonka.CloudWatchEvents.Types.InputTransformer
import Amazonka.CloudWatchEvents.Types.KinesisParameters
import Amazonka.CloudWatchEvents.Types.RedshiftDataParameters
import Amazonka.CloudWatchEvents.Types.RetryPolicy
import Amazonka.CloudWatchEvents.Types.RunCommandParameters
import Amazonka.CloudWatchEvents.Types.SageMakerPipelineParameters
import Amazonka.CloudWatchEvents.Types.SqsParameters
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

-- | Targets are the resources to be invoked when a rule is triggered. For a
-- complete list of services and resources that can be set as a target, see
-- <https://docs.aws.amazon.com/eventbridge/latest/APIReference/API_PutTargets.html PutTargets>.
--
-- If you are setting the event bus of another account as the target, and
-- that account granted permission to your account through an organization
-- instead of directly by the account ID, then you must specify a @RoleArn@
-- with proper permissions in the @Target@ structure. For more information,
-- see
-- <https://docs.aws.amazon.com/eventbridge/latest/userguide/eventbridge-cross-account-event-delivery.html Sending and Receiving Events Between Amazon Web Services Accounts>
-- in the /Amazon EventBridge User Guide/.
--
-- /See:/ 'newTarget' smart constructor.
data Target = Target'
  { -- | If the event target is an Batch job, this contains the job definition,
    -- job name, and other parameters. For more information, see
    -- <https://docs.aws.amazon.com/batch/latest/userguide/jobs.html Jobs> in
    -- the /Batch User Guide/.
    Target -> Maybe BatchParameters
batchParameters :: Prelude.Maybe BatchParameters,
    -- | The @DeadLetterConfig@ that defines the target queue to send dead-letter
    -- queue events to.
    Target -> Maybe DeadLetterConfig
deadLetterConfig :: Prelude.Maybe DeadLetterConfig,
    -- | Contains the Amazon ECS task definition and task count to be used, if
    -- the event target is an Amazon ECS task. For more information about
    -- Amazon ECS tasks, see
    -- <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_defintions.html Task Definitions>
    -- in the /Amazon EC2 Container Service Developer Guide/.
    Target -> Maybe EcsParameters
ecsParameters :: Prelude.Maybe EcsParameters,
    -- | Contains the HTTP parameters to use when the target is a API Gateway
    -- REST endpoint or EventBridge ApiDestination.
    --
    -- If you specify an API Gateway REST API or EventBridge ApiDestination as
    -- a target, you can use this parameter to specify headers, path
    -- parameters, and query string keys\/values as part of your target
    -- invoking request. If you\'re using ApiDestinations, the corresponding
    -- Connection can also have these values configured. In case of any
    -- conflicting keys, values from the Connection take precedence.
    Target -> Maybe HttpParameters
httpParameters :: Prelude.Maybe HttpParameters,
    -- | Valid JSON text passed to the target. In this case, nothing from the
    -- event itself is passed to the target. For more information, see
    -- <http://www.rfc-editor.org/rfc/rfc7159.txt The JavaScript Object Notation (JSON) Data Interchange Format>.
    Target -> Maybe Text
input :: Prelude.Maybe Prelude.Text,
    -- | The value of the JSONPath that is used for extracting part of the
    -- matched event when passing it to the target. You must use JSON dot
    -- notation, not bracket notation. For more information about JSON paths,
    -- see <http://goessner.net/articles/JsonPath/ JSONPath>.
    Target -> Maybe Text
inputPath :: Prelude.Maybe Prelude.Text,
    -- | Settings to enable you to provide custom input to a target based on
    -- certain event data. You can extract one or more key-value pairs from the
    -- event and then use that data to send customized input to the target.
    Target -> Maybe InputTransformer
inputTransformer :: Prelude.Maybe InputTransformer,
    -- | The custom parameter you can use to control the shard assignment, when
    -- the target is a Kinesis data stream. If you do not include this
    -- parameter, the default is to use the @eventId@ as the partition key.
    Target -> Maybe KinesisParameters
kinesisParameters :: Prelude.Maybe KinesisParameters,
    -- | Contains the Amazon Redshift Data API parameters to use when the target
    -- is a Amazon Redshift cluster.
    --
    -- If you specify a Amazon Redshift Cluster as a Target, you can use this
    -- to specify parameters to invoke the Amazon Redshift Data API
    -- ExecuteStatement based on EventBridge events.
    Target -> Maybe RedshiftDataParameters
redshiftDataParameters :: Prelude.Maybe RedshiftDataParameters,
    -- | The @RetryPolicy@ object that contains the retry policy configuration to
    -- use for the dead-letter queue.
    Target -> Maybe RetryPolicy
retryPolicy :: Prelude.Maybe RetryPolicy,
    -- | The Amazon Resource Name (ARN) of the IAM role to be used for this
    -- target when the rule is triggered. If one rule triggers multiple
    -- targets, you can use a different IAM role for each target.
    Target -> Maybe Text
roleArn :: Prelude.Maybe Prelude.Text,
    -- | Parameters used when you are using the rule to invoke Amazon EC2 Run
    -- Command.
    Target -> Maybe RunCommandParameters
runCommandParameters :: Prelude.Maybe RunCommandParameters,
    -- | Contains the SageMaker Model Building Pipeline parameters to start
    -- execution of a SageMaker Model Building Pipeline.
    --
    -- If you specify a SageMaker Model Building Pipeline as a target, you can
    -- use this to specify parameters to start a pipeline execution based on
    -- EventBridge events.
    Target -> Maybe SageMakerPipelineParameters
sageMakerPipelineParameters :: Prelude.Maybe SageMakerPipelineParameters,
    -- | Contains the message group ID to use when the target is a FIFO queue.
    --
    -- If you specify an SQS FIFO queue as a target, the queue must have
    -- content-based deduplication enabled.
    Target -> Maybe SqsParameters
sqsParameters :: Prelude.Maybe SqsParameters,
    -- | The ID of the target within the specified rule. Use this ID to reference
    -- the target when updating the rule. We recommend using a memorable and
    -- unique string.
    Target -> Text
id :: Prelude.Text,
    -- | The Amazon Resource Name (ARN) of the target.
    Target -> Text
arn :: Prelude.Text
  }
  deriving (Target -> Target -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Target -> Target -> Bool
$c/= :: Target -> Target -> Bool
== :: Target -> Target -> Bool
$c== :: Target -> Target -> Bool
Prelude.Eq, ReadPrec [Target]
ReadPrec Target
Int -> ReadS Target
ReadS [Target]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Target]
$creadListPrec :: ReadPrec [Target]
readPrec :: ReadPrec Target
$creadPrec :: ReadPrec Target
readList :: ReadS [Target]
$creadList :: ReadS [Target]
readsPrec :: Int -> ReadS Target
$creadsPrec :: Int -> ReadS Target
Prelude.Read, Int -> Target -> ShowS
[Target] -> ShowS
Target -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Target] -> ShowS
$cshowList :: [Target] -> ShowS
show :: Target -> String
$cshow :: Target -> String
showsPrec :: Int -> Target -> ShowS
$cshowsPrec :: Int -> Target -> ShowS
Prelude.Show, forall x. Rep Target x -> Target
forall x. Target -> Rep Target x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Target x -> Target
$cfrom :: forall x. Target -> Rep Target x
Prelude.Generic)

-- |
-- Create a value of 'Target' 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:
--
-- 'batchParameters', 'target_batchParameters' - If the event target is an Batch job, this contains the job definition,
-- job name, and other parameters. For more information, see
-- <https://docs.aws.amazon.com/batch/latest/userguide/jobs.html Jobs> in
-- the /Batch User Guide/.
--
-- 'deadLetterConfig', 'target_deadLetterConfig' - The @DeadLetterConfig@ that defines the target queue to send dead-letter
-- queue events to.
--
-- 'ecsParameters', 'target_ecsParameters' - Contains the Amazon ECS task definition and task count to be used, if
-- the event target is an Amazon ECS task. For more information about
-- Amazon ECS tasks, see
-- <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_defintions.html Task Definitions>
-- in the /Amazon EC2 Container Service Developer Guide/.
--
-- 'httpParameters', 'target_httpParameters' - Contains the HTTP parameters to use when the target is a API Gateway
-- REST endpoint or EventBridge ApiDestination.
--
-- If you specify an API Gateway REST API or EventBridge ApiDestination as
-- a target, you can use this parameter to specify headers, path
-- parameters, and query string keys\/values as part of your target
-- invoking request. If you\'re using ApiDestinations, the corresponding
-- Connection can also have these values configured. In case of any
-- conflicting keys, values from the Connection take precedence.
--
-- 'input', 'target_input' - Valid JSON text passed to the target. In this case, nothing from the
-- event itself is passed to the target. For more information, see
-- <http://www.rfc-editor.org/rfc/rfc7159.txt The JavaScript Object Notation (JSON) Data Interchange Format>.
--
-- 'inputPath', 'target_inputPath' - The value of the JSONPath that is used for extracting part of the
-- matched event when passing it to the target. You must use JSON dot
-- notation, not bracket notation. For more information about JSON paths,
-- see <http://goessner.net/articles/JsonPath/ JSONPath>.
--
-- 'inputTransformer', 'target_inputTransformer' - Settings to enable you to provide custom input to a target based on
-- certain event data. You can extract one or more key-value pairs from the
-- event and then use that data to send customized input to the target.
--
-- 'kinesisParameters', 'target_kinesisParameters' - The custom parameter you can use to control the shard assignment, when
-- the target is a Kinesis data stream. If you do not include this
-- parameter, the default is to use the @eventId@ as the partition key.
--
-- 'redshiftDataParameters', 'target_redshiftDataParameters' - Contains the Amazon Redshift Data API parameters to use when the target
-- is a Amazon Redshift cluster.
--
-- If you specify a Amazon Redshift Cluster as a Target, you can use this
-- to specify parameters to invoke the Amazon Redshift Data API
-- ExecuteStatement based on EventBridge events.
--
-- 'retryPolicy', 'target_retryPolicy' - The @RetryPolicy@ object that contains the retry policy configuration to
-- use for the dead-letter queue.
--
-- 'roleArn', 'target_roleArn' - The Amazon Resource Name (ARN) of the IAM role to be used for this
-- target when the rule is triggered. If one rule triggers multiple
-- targets, you can use a different IAM role for each target.
--
-- 'runCommandParameters', 'target_runCommandParameters' - Parameters used when you are using the rule to invoke Amazon EC2 Run
-- Command.
--
-- 'sageMakerPipelineParameters', 'target_sageMakerPipelineParameters' - Contains the SageMaker Model Building Pipeline parameters to start
-- execution of a SageMaker Model Building Pipeline.
--
-- If you specify a SageMaker Model Building Pipeline as a target, you can
-- use this to specify parameters to start a pipeline execution based on
-- EventBridge events.
--
-- 'sqsParameters', 'target_sqsParameters' - Contains the message group ID to use when the target is a FIFO queue.
--
-- If you specify an SQS FIFO queue as a target, the queue must have
-- content-based deduplication enabled.
--
-- 'id', 'target_id' - The ID of the target within the specified rule. Use this ID to reference
-- the target when updating the rule. We recommend using a memorable and
-- unique string.
--
-- 'arn', 'target_arn' - The Amazon Resource Name (ARN) of the target.
newTarget ::
  -- | 'id'
  Prelude.Text ->
  -- | 'arn'
  Prelude.Text ->
  Target
newTarget :: Text -> Text -> Target
newTarget Text
pId_ Text
pArn_ =
  Target'
    { $sel:batchParameters:Target' :: Maybe BatchParameters
batchParameters = forall a. Maybe a
Prelude.Nothing,
      $sel:deadLetterConfig:Target' :: Maybe DeadLetterConfig
deadLetterConfig = forall a. Maybe a
Prelude.Nothing,
      $sel:ecsParameters:Target' :: Maybe EcsParameters
ecsParameters = forall a. Maybe a
Prelude.Nothing,
      $sel:httpParameters:Target' :: Maybe HttpParameters
httpParameters = forall a. Maybe a
Prelude.Nothing,
      $sel:input:Target' :: Maybe Text
input = forall a. Maybe a
Prelude.Nothing,
      $sel:inputPath:Target' :: Maybe Text
inputPath = forall a. Maybe a
Prelude.Nothing,
      $sel:inputTransformer:Target' :: Maybe InputTransformer
inputTransformer = forall a. Maybe a
Prelude.Nothing,
      $sel:kinesisParameters:Target' :: Maybe KinesisParameters
kinesisParameters = forall a. Maybe a
Prelude.Nothing,
      $sel:redshiftDataParameters:Target' :: Maybe RedshiftDataParameters
redshiftDataParameters = forall a. Maybe a
Prelude.Nothing,
      $sel:retryPolicy:Target' :: Maybe RetryPolicy
retryPolicy = forall a. Maybe a
Prelude.Nothing,
      $sel:roleArn:Target' :: Maybe Text
roleArn = forall a. Maybe a
Prelude.Nothing,
      $sel:runCommandParameters:Target' :: Maybe RunCommandParameters
runCommandParameters = forall a. Maybe a
Prelude.Nothing,
      $sel:sageMakerPipelineParameters:Target' :: Maybe SageMakerPipelineParameters
sageMakerPipelineParameters = forall a. Maybe a
Prelude.Nothing,
      $sel:sqsParameters:Target' :: Maybe SqsParameters
sqsParameters = forall a. Maybe a
Prelude.Nothing,
      $sel:id:Target' :: Text
id = Text
pId_,
      $sel:arn:Target' :: Text
arn = Text
pArn_
    }

-- | If the event target is an Batch job, this contains the job definition,
-- job name, and other parameters. For more information, see
-- <https://docs.aws.amazon.com/batch/latest/userguide/jobs.html Jobs> in
-- the /Batch User Guide/.
target_batchParameters :: Lens.Lens' Target (Prelude.Maybe BatchParameters)
target_batchParameters :: Lens' Target (Maybe BatchParameters)
target_batchParameters = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Target' {Maybe BatchParameters
batchParameters :: Maybe BatchParameters
$sel:batchParameters:Target' :: Target -> Maybe BatchParameters
batchParameters} -> Maybe BatchParameters
batchParameters) (\s :: Target
s@Target' {} Maybe BatchParameters
a -> Target
s {$sel:batchParameters:Target' :: Maybe BatchParameters
batchParameters = Maybe BatchParameters
a} :: Target)

-- | The @DeadLetterConfig@ that defines the target queue to send dead-letter
-- queue events to.
target_deadLetterConfig :: Lens.Lens' Target (Prelude.Maybe DeadLetterConfig)
target_deadLetterConfig :: Lens' Target (Maybe DeadLetterConfig)
target_deadLetterConfig = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Target' {Maybe DeadLetterConfig
deadLetterConfig :: Maybe DeadLetterConfig
$sel:deadLetterConfig:Target' :: Target -> Maybe DeadLetterConfig
deadLetterConfig} -> Maybe DeadLetterConfig
deadLetterConfig) (\s :: Target
s@Target' {} Maybe DeadLetterConfig
a -> Target
s {$sel:deadLetterConfig:Target' :: Maybe DeadLetterConfig
deadLetterConfig = Maybe DeadLetterConfig
a} :: Target)

-- | Contains the Amazon ECS task definition and task count to be used, if
-- the event target is an Amazon ECS task. For more information about
-- Amazon ECS tasks, see
-- <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_defintions.html Task Definitions>
-- in the /Amazon EC2 Container Service Developer Guide/.
target_ecsParameters :: Lens.Lens' Target (Prelude.Maybe EcsParameters)
target_ecsParameters :: Lens' Target (Maybe EcsParameters)
target_ecsParameters = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Target' {Maybe EcsParameters
ecsParameters :: Maybe EcsParameters
$sel:ecsParameters:Target' :: Target -> Maybe EcsParameters
ecsParameters} -> Maybe EcsParameters
ecsParameters) (\s :: Target
s@Target' {} Maybe EcsParameters
a -> Target
s {$sel:ecsParameters:Target' :: Maybe EcsParameters
ecsParameters = Maybe EcsParameters
a} :: Target)

-- | Contains the HTTP parameters to use when the target is a API Gateway
-- REST endpoint or EventBridge ApiDestination.
--
-- If you specify an API Gateway REST API or EventBridge ApiDestination as
-- a target, you can use this parameter to specify headers, path
-- parameters, and query string keys\/values as part of your target
-- invoking request. If you\'re using ApiDestinations, the corresponding
-- Connection can also have these values configured. In case of any
-- conflicting keys, values from the Connection take precedence.
target_httpParameters :: Lens.Lens' Target (Prelude.Maybe HttpParameters)
target_httpParameters :: Lens' Target (Maybe HttpParameters)
target_httpParameters = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Target' {Maybe HttpParameters
httpParameters :: Maybe HttpParameters
$sel:httpParameters:Target' :: Target -> Maybe HttpParameters
httpParameters} -> Maybe HttpParameters
httpParameters) (\s :: Target
s@Target' {} Maybe HttpParameters
a -> Target
s {$sel:httpParameters:Target' :: Maybe HttpParameters
httpParameters = Maybe HttpParameters
a} :: Target)

-- | Valid JSON text passed to the target. In this case, nothing from the
-- event itself is passed to the target. For more information, see
-- <http://www.rfc-editor.org/rfc/rfc7159.txt The JavaScript Object Notation (JSON) Data Interchange Format>.
target_input :: Lens.Lens' Target (Prelude.Maybe Prelude.Text)
target_input :: Lens' Target (Maybe Text)
target_input = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Target' {Maybe Text
input :: Maybe Text
$sel:input:Target' :: Target -> Maybe Text
input} -> Maybe Text
input) (\s :: Target
s@Target' {} Maybe Text
a -> Target
s {$sel:input:Target' :: Maybe Text
input = Maybe Text
a} :: Target)

-- | The value of the JSONPath that is used for extracting part of the
-- matched event when passing it to the target. You must use JSON dot
-- notation, not bracket notation. For more information about JSON paths,
-- see <http://goessner.net/articles/JsonPath/ JSONPath>.
target_inputPath :: Lens.Lens' Target (Prelude.Maybe Prelude.Text)
target_inputPath :: Lens' Target (Maybe Text)
target_inputPath = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Target' {Maybe Text
inputPath :: Maybe Text
$sel:inputPath:Target' :: Target -> Maybe Text
inputPath} -> Maybe Text
inputPath) (\s :: Target
s@Target' {} Maybe Text
a -> Target
s {$sel:inputPath:Target' :: Maybe Text
inputPath = Maybe Text
a} :: Target)

-- | Settings to enable you to provide custom input to a target based on
-- certain event data. You can extract one or more key-value pairs from the
-- event and then use that data to send customized input to the target.
target_inputTransformer :: Lens.Lens' Target (Prelude.Maybe InputTransformer)
target_inputTransformer :: Lens' Target (Maybe InputTransformer)
target_inputTransformer = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Target' {Maybe InputTransformer
inputTransformer :: Maybe InputTransformer
$sel:inputTransformer:Target' :: Target -> Maybe InputTransformer
inputTransformer} -> Maybe InputTransformer
inputTransformer) (\s :: Target
s@Target' {} Maybe InputTransformer
a -> Target
s {$sel:inputTransformer:Target' :: Maybe InputTransformer
inputTransformer = Maybe InputTransformer
a} :: Target)

-- | The custom parameter you can use to control the shard assignment, when
-- the target is a Kinesis data stream. If you do not include this
-- parameter, the default is to use the @eventId@ as the partition key.
target_kinesisParameters :: Lens.Lens' Target (Prelude.Maybe KinesisParameters)
target_kinesisParameters :: Lens' Target (Maybe KinesisParameters)
target_kinesisParameters = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Target' {Maybe KinesisParameters
kinesisParameters :: Maybe KinesisParameters
$sel:kinesisParameters:Target' :: Target -> Maybe KinesisParameters
kinesisParameters} -> Maybe KinesisParameters
kinesisParameters) (\s :: Target
s@Target' {} Maybe KinesisParameters
a -> Target
s {$sel:kinesisParameters:Target' :: Maybe KinesisParameters
kinesisParameters = Maybe KinesisParameters
a} :: Target)

-- | Contains the Amazon Redshift Data API parameters to use when the target
-- is a Amazon Redshift cluster.
--
-- If you specify a Amazon Redshift Cluster as a Target, you can use this
-- to specify parameters to invoke the Amazon Redshift Data API
-- ExecuteStatement based on EventBridge events.
target_redshiftDataParameters :: Lens.Lens' Target (Prelude.Maybe RedshiftDataParameters)
target_redshiftDataParameters :: Lens' Target (Maybe RedshiftDataParameters)
target_redshiftDataParameters = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Target' {Maybe RedshiftDataParameters
redshiftDataParameters :: Maybe RedshiftDataParameters
$sel:redshiftDataParameters:Target' :: Target -> Maybe RedshiftDataParameters
redshiftDataParameters} -> Maybe RedshiftDataParameters
redshiftDataParameters) (\s :: Target
s@Target' {} Maybe RedshiftDataParameters
a -> Target
s {$sel:redshiftDataParameters:Target' :: Maybe RedshiftDataParameters
redshiftDataParameters = Maybe RedshiftDataParameters
a} :: Target)

-- | The @RetryPolicy@ object that contains the retry policy configuration to
-- use for the dead-letter queue.
target_retryPolicy :: Lens.Lens' Target (Prelude.Maybe RetryPolicy)
target_retryPolicy :: Lens' Target (Maybe RetryPolicy)
target_retryPolicy = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Target' {Maybe RetryPolicy
retryPolicy :: Maybe RetryPolicy
$sel:retryPolicy:Target' :: Target -> Maybe RetryPolicy
retryPolicy} -> Maybe RetryPolicy
retryPolicy) (\s :: Target
s@Target' {} Maybe RetryPolicy
a -> Target
s {$sel:retryPolicy:Target' :: Maybe RetryPolicy
retryPolicy = Maybe RetryPolicy
a} :: Target)

-- | The Amazon Resource Name (ARN) of the IAM role to be used for this
-- target when the rule is triggered. If one rule triggers multiple
-- targets, you can use a different IAM role for each target.
target_roleArn :: Lens.Lens' Target (Prelude.Maybe Prelude.Text)
target_roleArn :: Lens' Target (Maybe Text)
target_roleArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Target' {Maybe Text
roleArn :: Maybe Text
$sel:roleArn:Target' :: Target -> Maybe Text
roleArn} -> Maybe Text
roleArn) (\s :: Target
s@Target' {} Maybe Text
a -> Target
s {$sel:roleArn:Target' :: Maybe Text
roleArn = Maybe Text
a} :: Target)

-- | Parameters used when you are using the rule to invoke Amazon EC2 Run
-- Command.
target_runCommandParameters :: Lens.Lens' Target (Prelude.Maybe RunCommandParameters)
target_runCommandParameters :: Lens' Target (Maybe RunCommandParameters)
target_runCommandParameters = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Target' {Maybe RunCommandParameters
runCommandParameters :: Maybe RunCommandParameters
$sel:runCommandParameters:Target' :: Target -> Maybe RunCommandParameters
runCommandParameters} -> Maybe RunCommandParameters
runCommandParameters) (\s :: Target
s@Target' {} Maybe RunCommandParameters
a -> Target
s {$sel:runCommandParameters:Target' :: Maybe RunCommandParameters
runCommandParameters = Maybe RunCommandParameters
a} :: Target)

-- | Contains the SageMaker Model Building Pipeline parameters to start
-- execution of a SageMaker Model Building Pipeline.
--
-- If you specify a SageMaker Model Building Pipeline as a target, you can
-- use this to specify parameters to start a pipeline execution based on
-- EventBridge events.
target_sageMakerPipelineParameters :: Lens.Lens' Target (Prelude.Maybe SageMakerPipelineParameters)
target_sageMakerPipelineParameters :: Lens' Target (Maybe SageMakerPipelineParameters)
target_sageMakerPipelineParameters = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Target' {Maybe SageMakerPipelineParameters
sageMakerPipelineParameters :: Maybe SageMakerPipelineParameters
$sel:sageMakerPipelineParameters:Target' :: Target -> Maybe SageMakerPipelineParameters
sageMakerPipelineParameters} -> Maybe SageMakerPipelineParameters
sageMakerPipelineParameters) (\s :: Target
s@Target' {} Maybe SageMakerPipelineParameters
a -> Target
s {$sel:sageMakerPipelineParameters:Target' :: Maybe SageMakerPipelineParameters
sageMakerPipelineParameters = Maybe SageMakerPipelineParameters
a} :: Target)

-- | Contains the message group ID to use when the target is a FIFO queue.
--
-- If you specify an SQS FIFO queue as a target, the queue must have
-- content-based deduplication enabled.
target_sqsParameters :: Lens.Lens' Target (Prelude.Maybe SqsParameters)
target_sqsParameters :: Lens' Target (Maybe SqsParameters)
target_sqsParameters = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Target' {Maybe SqsParameters
sqsParameters :: Maybe SqsParameters
$sel:sqsParameters:Target' :: Target -> Maybe SqsParameters
sqsParameters} -> Maybe SqsParameters
sqsParameters) (\s :: Target
s@Target' {} Maybe SqsParameters
a -> Target
s {$sel:sqsParameters:Target' :: Maybe SqsParameters
sqsParameters = Maybe SqsParameters
a} :: Target)

-- | The ID of the target within the specified rule. Use this ID to reference
-- the target when updating the rule. We recommend using a memorable and
-- unique string.
target_id :: Lens.Lens' Target Prelude.Text
target_id :: Lens' Target Text
target_id = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Target' {Text
id :: Text
$sel:id:Target' :: Target -> Text
id} -> Text
id) (\s :: Target
s@Target' {} Text
a -> Target
s {$sel:id:Target' :: Text
id = Text
a} :: Target)

-- | The Amazon Resource Name (ARN) of the target.
target_arn :: Lens.Lens' Target Prelude.Text
target_arn :: Lens' Target Text
target_arn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Target' {Text
arn :: Text
$sel:arn:Target' :: Target -> Text
arn} -> Text
arn) (\s :: Target
s@Target' {} Text
a -> Target
s {$sel:arn:Target' :: Text
arn = Text
a} :: Target)

instance Data.FromJSON Target where
  parseJSON :: Value -> Parser Target
parseJSON =
    forall a. String -> (Object -> Parser a) -> Value -> Parser a
Data.withObject
      String
"Target"
      ( \Object
x ->
          Maybe BatchParameters
-> Maybe DeadLetterConfig
-> Maybe EcsParameters
-> Maybe HttpParameters
-> Maybe Text
-> Maybe Text
-> Maybe InputTransformer
-> Maybe KinesisParameters
-> Maybe RedshiftDataParameters
-> Maybe RetryPolicy
-> Maybe Text
-> Maybe RunCommandParameters
-> Maybe SageMakerPipelineParameters
-> Maybe SqsParameters
-> Text
-> Text
-> Target
Target'
            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
"BatchParameters")
            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
"DeadLetterConfig")
            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
"EcsParameters")
            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
"HttpParameters")
            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
"Input")
            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
"InputPath")
            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
"InputTransformer")
            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
"KinesisParameters")
            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
"RedshiftDataParameters")
            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
"RetryPolicy")
            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
"RoleArn")
            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
"RunCommandParameters")
            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
"SageMakerPipelineParameters")
            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
"SqsParameters")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser a
Data..: Key
"Id")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser a
Data..: Key
"Arn")
      )

instance Prelude.Hashable Target where
  hashWithSalt :: Int -> Target -> Int
hashWithSalt Int
_salt Target' {Maybe Text
Maybe BatchParameters
Maybe DeadLetterConfig
Maybe HttpParameters
Maybe InputTransformer
Maybe KinesisParameters
Maybe RedshiftDataParameters
Maybe RetryPolicy
Maybe RunCommandParameters
Maybe SageMakerPipelineParameters
Maybe SqsParameters
Maybe EcsParameters
Text
arn :: Text
id :: Text
sqsParameters :: Maybe SqsParameters
sageMakerPipelineParameters :: Maybe SageMakerPipelineParameters
runCommandParameters :: Maybe RunCommandParameters
roleArn :: Maybe Text
retryPolicy :: Maybe RetryPolicy
redshiftDataParameters :: Maybe RedshiftDataParameters
kinesisParameters :: Maybe KinesisParameters
inputTransformer :: Maybe InputTransformer
inputPath :: Maybe Text
input :: Maybe Text
httpParameters :: Maybe HttpParameters
ecsParameters :: Maybe EcsParameters
deadLetterConfig :: Maybe DeadLetterConfig
batchParameters :: Maybe BatchParameters
$sel:arn:Target' :: Target -> Text
$sel:id:Target' :: Target -> Text
$sel:sqsParameters:Target' :: Target -> Maybe SqsParameters
$sel:sageMakerPipelineParameters:Target' :: Target -> Maybe SageMakerPipelineParameters
$sel:runCommandParameters:Target' :: Target -> Maybe RunCommandParameters
$sel:roleArn:Target' :: Target -> Maybe Text
$sel:retryPolicy:Target' :: Target -> Maybe RetryPolicy
$sel:redshiftDataParameters:Target' :: Target -> Maybe RedshiftDataParameters
$sel:kinesisParameters:Target' :: Target -> Maybe KinesisParameters
$sel:inputTransformer:Target' :: Target -> Maybe InputTransformer
$sel:inputPath:Target' :: Target -> Maybe Text
$sel:input:Target' :: Target -> Maybe Text
$sel:httpParameters:Target' :: Target -> Maybe HttpParameters
$sel:ecsParameters:Target' :: Target -> Maybe EcsParameters
$sel:deadLetterConfig:Target' :: Target -> Maybe DeadLetterConfig
$sel:batchParameters:Target' :: Target -> Maybe BatchParameters
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe BatchParameters
batchParameters
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe DeadLetterConfig
deadLetterConfig
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe EcsParameters
ecsParameters
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe HttpParameters
httpParameters
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
input
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
inputPath
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe InputTransformer
inputTransformer
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe KinesisParameters
kinesisParameters
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe RedshiftDataParameters
redshiftDataParameters
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe RetryPolicy
retryPolicy
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
roleArn
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe RunCommandParameters
runCommandParameters
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe SageMakerPipelineParameters
sageMakerPipelineParameters
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe SqsParameters
sqsParameters
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
id
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
arn

instance Prelude.NFData Target where
  rnf :: Target -> ()
rnf Target' {Maybe Text
Maybe BatchParameters
Maybe DeadLetterConfig
Maybe HttpParameters
Maybe InputTransformer
Maybe KinesisParameters
Maybe RedshiftDataParameters
Maybe RetryPolicy
Maybe RunCommandParameters
Maybe SageMakerPipelineParameters
Maybe SqsParameters
Maybe EcsParameters
Text
arn :: Text
id :: Text
sqsParameters :: Maybe SqsParameters
sageMakerPipelineParameters :: Maybe SageMakerPipelineParameters
runCommandParameters :: Maybe RunCommandParameters
roleArn :: Maybe Text
retryPolicy :: Maybe RetryPolicy
redshiftDataParameters :: Maybe RedshiftDataParameters
kinesisParameters :: Maybe KinesisParameters
inputTransformer :: Maybe InputTransformer
inputPath :: Maybe Text
input :: Maybe Text
httpParameters :: Maybe HttpParameters
ecsParameters :: Maybe EcsParameters
deadLetterConfig :: Maybe DeadLetterConfig
batchParameters :: Maybe BatchParameters
$sel:arn:Target' :: Target -> Text
$sel:id:Target' :: Target -> Text
$sel:sqsParameters:Target' :: Target -> Maybe SqsParameters
$sel:sageMakerPipelineParameters:Target' :: Target -> Maybe SageMakerPipelineParameters
$sel:runCommandParameters:Target' :: Target -> Maybe RunCommandParameters
$sel:roleArn:Target' :: Target -> Maybe Text
$sel:retryPolicy:Target' :: Target -> Maybe RetryPolicy
$sel:redshiftDataParameters:Target' :: Target -> Maybe RedshiftDataParameters
$sel:kinesisParameters:Target' :: Target -> Maybe KinesisParameters
$sel:inputTransformer:Target' :: Target -> Maybe InputTransformer
$sel:inputPath:Target' :: Target -> Maybe Text
$sel:input:Target' :: Target -> Maybe Text
$sel:httpParameters:Target' :: Target -> Maybe HttpParameters
$sel:ecsParameters:Target' :: Target -> Maybe EcsParameters
$sel:deadLetterConfig:Target' :: Target -> Maybe DeadLetterConfig
$sel:batchParameters:Target' :: Target -> Maybe BatchParameters
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe BatchParameters
batchParameters
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe DeadLetterConfig
deadLetterConfig
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe EcsParameters
ecsParameters
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe HttpParameters
httpParameters
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
input
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
inputPath
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe InputTransformer
inputTransformer
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe KinesisParameters
kinesisParameters
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe RedshiftDataParameters
redshiftDataParameters
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe RetryPolicy
retryPolicy
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
roleArn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe RunCommandParameters
runCommandParameters
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe SageMakerPipelineParameters
sageMakerPipelineParameters
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe SqsParameters
sqsParameters
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
id
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
arn

instance Data.ToJSON Target where
  toJSON :: Target -> Value
toJSON Target' {Maybe Text
Maybe BatchParameters
Maybe DeadLetterConfig
Maybe HttpParameters
Maybe InputTransformer
Maybe KinesisParameters
Maybe RedshiftDataParameters
Maybe RetryPolicy
Maybe RunCommandParameters
Maybe SageMakerPipelineParameters
Maybe SqsParameters
Maybe EcsParameters
Text
arn :: Text
id :: Text
sqsParameters :: Maybe SqsParameters
sageMakerPipelineParameters :: Maybe SageMakerPipelineParameters
runCommandParameters :: Maybe RunCommandParameters
roleArn :: Maybe Text
retryPolicy :: Maybe RetryPolicy
redshiftDataParameters :: Maybe RedshiftDataParameters
kinesisParameters :: Maybe KinesisParameters
inputTransformer :: Maybe InputTransformer
inputPath :: Maybe Text
input :: Maybe Text
httpParameters :: Maybe HttpParameters
ecsParameters :: Maybe EcsParameters
deadLetterConfig :: Maybe DeadLetterConfig
batchParameters :: Maybe BatchParameters
$sel:arn:Target' :: Target -> Text
$sel:id:Target' :: Target -> Text
$sel:sqsParameters:Target' :: Target -> Maybe SqsParameters
$sel:sageMakerPipelineParameters:Target' :: Target -> Maybe SageMakerPipelineParameters
$sel:runCommandParameters:Target' :: Target -> Maybe RunCommandParameters
$sel:roleArn:Target' :: Target -> Maybe Text
$sel:retryPolicy:Target' :: Target -> Maybe RetryPolicy
$sel:redshiftDataParameters:Target' :: Target -> Maybe RedshiftDataParameters
$sel:kinesisParameters:Target' :: Target -> Maybe KinesisParameters
$sel:inputTransformer:Target' :: Target -> Maybe InputTransformer
$sel:inputPath:Target' :: Target -> Maybe Text
$sel:input:Target' :: Target -> Maybe Text
$sel:httpParameters:Target' :: Target -> Maybe HttpParameters
$sel:ecsParameters:Target' :: Target -> Maybe EcsParameters
$sel:deadLetterConfig:Target' :: Target -> Maybe DeadLetterConfig
$sel:batchParameters:Target' :: Target -> Maybe BatchParameters
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"BatchParameters" 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 BatchParameters
batchParameters,
            (Key
"DeadLetterConfig" 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 DeadLetterConfig
deadLetterConfig,
            (Key
"EcsParameters" 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 EcsParameters
ecsParameters,
            (Key
"HttpParameters" 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 HttpParameters
httpParameters,
            (Key
"Input" 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 Text
input,
            (Key
"InputPath" 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 Text
inputPath,
            (Key
"InputTransformer" 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 InputTransformer
inputTransformer,
            (Key
"KinesisParameters" 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 KinesisParameters
kinesisParameters,
            (Key
"RedshiftDataParameters" 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 RedshiftDataParameters
redshiftDataParameters,
            (Key
"RetryPolicy" 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 RetryPolicy
retryPolicy,
            (Key
"RoleArn" 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 Text
roleArn,
            (Key
"RunCommandParameters" 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 RunCommandParameters
runCommandParameters,
            (Key
"SageMakerPipelineParameters" 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 SageMakerPipelineParameters
sageMakerPipelineParameters,
            (Key
"SqsParameters" 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 SqsParameters
sqsParameters,
            forall a. a -> Maybe a
Prelude.Just (Key
"Id" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
id),
            forall a. a -> Maybe a
Prelude.Just (Key
"Arn" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
arn)
          ]
      )