{-# 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.Evidently.CreateExperiment
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Creates an Evidently /experiment/. Before you create an experiment, you
-- must create the feature to use for the experiment.
--
-- An experiment helps you make feature design decisions based on evidence
-- and data. An experiment can test as many as five variations at once.
-- Evidently collects experiment data and analyzes it by statistical
-- methods, and provides clear recommendations about which variations
-- perform better.
--
-- You can optionally specify a @segment@ to have the experiment consider
-- only certain audience types in the experiment, such as using only user
-- sessions from a certain location or who use a certain internet browser.
--
-- Don\'t use this operation to update an existing experiment. Instead, use
-- <https://docs.aws.amazon.com/cloudwatchevidently/latest/APIReference/API_UpdateExperiment.html UpdateExperiment>.
module Amazonka.Evidently.CreateExperiment
  ( -- * Creating a Request
    CreateExperiment (..),
    newCreateExperiment,

    -- * Request Lenses
    createExperiment_description,
    createExperiment_onlineAbConfig,
    createExperiment_randomizationSalt,
    createExperiment_samplingRate,
    createExperiment_segment,
    createExperiment_tags,
    createExperiment_metricGoals,
    createExperiment_name,
    createExperiment_project,
    createExperiment_treatments,

    -- * Destructuring the Response
    CreateExperimentResponse (..),
    newCreateExperimentResponse,

    -- * Response Lenses
    createExperimentResponse_httpStatus,
    createExperimentResponse_experiment,
  )
where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import Amazonka.Evidently.Types
import qualified Amazonka.Prelude as Prelude
import qualified Amazonka.Request as Request
import qualified Amazonka.Response as Response

-- | /See:/ 'newCreateExperiment' smart constructor.
data CreateExperiment = CreateExperiment'
  { -- | An optional description of the experiment.
    CreateExperiment -> Maybe Text
description :: Prelude.Maybe Prelude.Text,
    -- | A structure that contains the configuration of which variation to use as
    -- the \"control\" version. tThe \"control\" version is used for comparison
    -- with other variations. This structure also specifies how much experiment
    -- traffic is allocated to each variation.
    CreateExperiment -> Maybe OnlineAbConfig
onlineAbConfig :: Prelude.Maybe OnlineAbConfig,
    -- | When Evidently assigns a particular user session to an experiment, it
    -- must use a randomization ID to determine which variation the user
    -- session is served. This randomization ID is a combination of the entity
    -- ID and @randomizationSalt@. If you omit @randomizationSalt@, Evidently
    -- uses the experiment name as the @randomizationSalt@.
    CreateExperiment -> Maybe Text
randomizationSalt :: Prelude.Maybe Prelude.Text,
    -- | The portion of the available audience that you want to allocate to this
    -- experiment, in thousandths of a percent. The available audience is the
    -- total audience minus the audience that you have allocated to overrides
    -- or current launches of this feature.
    --
    -- This is represented in thousandths of a percent. For example, specify
    -- 10,000 to allocate 10% of the available audience.
    CreateExperiment -> Maybe Natural
samplingRate :: Prelude.Maybe Prelude.Natural,
    -- | Specifies an audience /segment/ to use in the experiment. When a segment
    -- is used in an experiment, only user sessions that match the segment
    -- pattern are used in the experiment.
    CreateExperiment -> Maybe Text
segment :: Prelude.Maybe Prelude.Text,
    -- | Assigns one or more tags (key-value pairs) to the experiment.
    --
    -- Tags can help you organize and categorize your resources. You can also
    -- use them to scope user permissions by granting a user permission to
    -- access or change only resources with certain tag values.
    --
    -- Tags don\'t have any semantic meaning to Amazon Web Services and are
    -- interpreted strictly as strings of characters.
    --
    -- >  <p>You can associate as many as 50 tags with an experiment.</p> <p>For more information, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html">Tagging Amazon Web Services resources</a>.</p>
    CreateExperiment -> Maybe (HashMap Text Text)
tags :: Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text),
    -- | An array of structures that defines the metrics used for the experiment,
    -- and whether a higher or lower value for each metric is the goal.
    CreateExperiment -> NonEmpty MetricGoalConfig
metricGoals :: Prelude.NonEmpty MetricGoalConfig,
    -- | A name for the new experiment.
    CreateExperiment -> Text
name :: Prelude.Text,
    -- | The name or ARN of the project that you want to create the new
    -- experiment in.
    CreateExperiment -> Text
project :: Prelude.Text,
    -- | An array of structures that describe the configuration of each feature
    -- variation used in the experiment.
    CreateExperiment -> [TreatmentConfig]
treatments :: [TreatmentConfig]
  }
  deriving (CreateExperiment -> CreateExperiment -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateExperiment -> CreateExperiment -> Bool
$c/= :: CreateExperiment -> CreateExperiment -> Bool
== :: CreateExperiment -> CreateExperiment -> Bool
$c== :: CreateExperiment -> CreateExperiment -> Bool
Prelude.Eq, ReadPrec [CreateExperiment]
ReadPrec CreateExperiment
Int -> ReadS CreateExperiment
ReadS [CreateExperiment]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateExperiment]
$creadListPrec :: ReadPrec [CreateExperiment]
readPrec :: ReadPrec CreateExperiment
$creadPrec :: ReadPrec CreateExperiment
readList :: ReadS [CreateExperiment]
$creadList :: ReadS [CreateExperiment]
readsPrec :: Int -> ReadS CreateExperiment
$creadsPrec :: Int -> ReadS CreateExperiment
Prelude.Read, Int -> CreateExperiment -> ShowS
[CreateExperiment] -> ShowS
CreateExperiment -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateExperiment] -> ShowS
$cshowList :: [CreateExperiment] -> ShowS
show :: CreateExperiment -> String
$cshow :: CreateExperiment -> String
showsPrec :: Int -> CreateExperiment -> ShowS
$cshowsPrec :: Int -> CreateExperiment -> ShowS
Prelude.Show, forall x. Rep CreateExperiment x -> CreateExperiment
forall x. CreateExperiment -> Rep CreateExperiment x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateExperiment x -> CreateExperiment
$cfrom :: forall x. CreateExperiment -> Rep CreateExperiment x
Prelude.Generic)

-- |
-- Create a value of 'CreateExperiment' 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:
--
-- 'description', 'createExperiment_description' - An optional description of the experiment.
--
-- 'onlineAbConfig', 'createExperiment_onlineAbConfig' - A structure that contains the configuration of which variation to use as
-- the \"control\" version. tThe \"control\" version is used for comparison
-- with other variations. This structure also specifies how much experiment
-- traffic is allocated to each variation.
--
-- 'randomizationSalt', 'createExperiment_randomizationSalt' - When Evidently assigns a particular user session to an experiment, it
-- must use a randomization ID to determine which variation the user
-- session is served. This randomization ID is a combination of the entity
-- ID and @randomizationSalt@. If you omit @randomizationSalt@, Evidently
-- uses the experiment name as the @randomizationSalt@.
--
-- 'samplingRate', 'createExperiment_samplingRate' - The portion of the available audience that you want to allocate to this
-- experiment, in thousandths of a percent. The available audience is the
-- total audience minus the audience that you have allocated to overrides
-- or current launches of this feature.
--
-- This is represented in thousandths of a percent. For example, specify
-- 10,000 to allocate 10% of the available audience.
--
-- 'segment', 'createExperiment_segment' - Specifies an audience /segment/ to use in the experiment. When a segment
-- is used in an experiment, only user sessions that match the segment
-- pattern are used in the experiment.
--
-- 'tags', 'createExperiment_tags' - Assigns one or more tags (key-value pairs) to the experiment.
--
-- Tags can help you organize and categorize your resources. You can also
-- use them to scope user permissions by granting a user permission to
-- access or change only resources with certain tag values.
--
-- Tags don\'t have any semantic meaning to Amazon Web Services and are
-- interpreted strictly as strings of characters.
--
-- >  <p>You can associate as many as 50 tags with an experiment.</p> <p>For more information, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html">Tagging Amazon Web Services resources</a>.</p>
--
-- 'metricGoals', 'createExperiment_metricGoals' - An array of structures that defines the metrics used for the experiment,
-- and whether a higher or lower value for each metric is the goal.
--
-- 'name', 'createExperiment_name' - A name for the new experiment.
--
-- 'project', 'createExperiment_project' - The name or ARN of the project that you want to create the new
-- experiment in.
--
-- 'treatments', 'createExperiment_treatments' - An array of structures that describe the configuration of each feature
-- variation used in the experiment.
newCreateExperiment ::
  -- | 'metricGoals'
  Prelude.NonEmpty MetricGoalConfig ->
  -- | 'name'
  Prelude.Text ->
  -- | 'project'
  Prelude.Text ->
  CreateExperiment
newCreateExperiment :: NonEmpty MetricGoalConfig -> Text -> Text -> CreateExperiment
newCreateExperiment NonEmpty MetricGoalConfig
pMetricGoals_ Text
pName_ Text
pProject_ =
  CreateExperiment'
    { $sel:description:CreateExperiment' :: Maybe Text
description = forall a. Maybe a
Prelude.Nothing,
      $sel:onlineAbConfig:CreateExperiment' :: Maybe OnlineAbConfig
onlineAbConfig = forall a. Maybe a
Prelude.Nothing,
      $sel:randomizationSalt:CreateExperiment' :: Maybe Text
randomizationSalt = forall a. Maybe a
Prelude.Nothing,
      $sel:samplingRate:CreateExperiment' :: Maybe Natural
samplingRate = forall a. Maybe a
Prelude.Nothing,
      $sel:segment:CreateExperiment' :: Maybe Text
segment = forall a. Maybe a
Prelude.Nothing,
      $sel:tags:CreateExperiment' :: Maybe (HashMap Text Text)
tags = forall a. Maybe a
Prelude.Nothing,
      $sel:metricGoals:CreateExperiment' :: NonEmpty MetricGoalConfig
metricGoals = forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced forall t b. AReview t b -> b -> t
Lens.# NonEmpty MetricGoalConfig
pMetricGoals_,
      $sel:name:CreateExperiment' :: Text
name = Text
pName_,
      $sel:project:CreateExperiment' :: Text
project = Text
pProject_,
      $sel:treatments:CreateExperiment' :: [TreatmentConfig]
treatments = forall a. Monoid a => a
Prelude.mempty
    }

-- | An optional description of the experiment.
createExperiment_description :: Lens.Lens' CreateExperiment (Prelude.Maybe Prelude.Text)
createExperiment_description :: Lens' CreateExperiment (Maybe Text)
createExperiment_description = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateExperiment' {Maybe Text
description :: Maybe Text
$sel:description:CreateExperiment' :: CreateExperiment -> Maybe Text
description} -> Maybe Text
description) (\s :: CreateExperiment
s@CreateExperiment' {} Maybe Text
a -> CreateExperiment
s {$sel:description:CreateExperiment' :: Maybe Text
description = Maybe Text
a} :: CreateExperiment)

-- | A structure that contains the configuration of which variation to use as
-- the \"control\" version. tThe \"control\" version is used for comparison
-- with other variations. This structure also specifies how much experiment
-- traffic is allocated to each variation.
createExperiment_onlineAbConfig :: Lens.Lens' CreateExperiment (Prelude.Maybe OnlineAbConfig)
createExperiment_onlineAbConfig :: Lens' CreateExperiment (Maybe OnlineAbConfig)
createExperiment_onlineAbConfig = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateExperiment' {Maybe OnlineAbConfig
onlineAbConfig :: Maybe OnlineAbConfig
$sel:onlineAbConfig:CreateExperiment' :: CreateExperiment -> Maybe OnlineAbConfig
onlineAbConfig} -> Maybe OnlineAbConfig
onlineAbConfig) (\s :: CreateExperiment
s@CreateExperiment' {} Maybe OnlineAbConfig
a -> CreateExperiment
s {$sel:onlineAbConfig:CreateExperiment' :: Maybe OnlineAbConfig
onlineAbConfig = Maybe OnlineAbConfig
a} :: CreateExperiment)

-- | When Evidently assigns a particular user session to an experiment, it
-- must use a randomization ID to determine which variation the user
-- session is served. This randomization ID is a combination of the entity
-- ID and @randomizationSalt@. If you omit @randomizationSalt@, Evidently
-- uses the experiment name as the @randomizationSalt@.
createExperiment_randomizationSalt :: Lens.Lens' CreateExperiment (Prelude.Maybe Prelude.Text)
createExperiment_randomizationSalt :: Lens' CreateExperiment (Maybe Text)
createExperiment_randomizationSalt = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateExperiment' {Maybe Text
randomizationSalt :: Maybe Text
$sel:randomizationSalt:CreateExperiment' :: CreateExperiment -> Maybe Text
randomizationSalt} -> Maybe Text
randomizationSalt) (\s :: CreateExperiment
s@CreateExperiment' {} Maybe Text
a -> CreateExperiment
s {$sel:randomizationSalt:CreateExperiment' :: Maybe Text
randomizationSalt = Maybe Text
a} :: CreateExperiment)

-- | The portion of the available audience that you want to allocate to this
-- experiment, in thousandths of a percent. The available audience is the
-- total audience minus the audience that you have allocated to overrides
-- or current launches of this feature.
--
-- This is represented in thousandths of a percent. For example, specify
-- 10,000 to allocate 10% of the available audience.
createExperiment_samplingRate :: Lens.Lens' CreateExperiment (Prelude.Maybe Prelude.Natural)
createExperiment_samplingRate :: Lens' CreateExperiment (Maybe Natural)
createExperiment_samplingRate = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateExperiment' {Maybe Natural
samplingRate :: Maybe Natural
$sel:samplingRate:CreateExperiment' :: CreateExperiment -> Maybe Natural
samplingRate} -> Maybe Natural
samplingRate) (\s :: CreateExperiment
s@CreateExperiment' {} Maybe Natural
a -> CreateExperiment
s {$sel:samplingRate:CreateExperiment' :: Maybe Natural
samplingRate = Maybe Natural
a} :: CreateExperiment)

-- | Specifies an audience /segment/ to use in the experiment. When a segment
-- is used in an experiment, only user sessions that match the segment
-- pattern are used in the experiment.
createExperiment_segment :: Lens.Lens' CreateExperiment (Prelude.Maybe Prelude.Text)
createExperiment_segment :: Lens' CreateExperiment (Maybe Text)
createExperiment_segment = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateExperiment' {Maybe Text
segment :: Maybe Text
$sel:segment:CreateExperiment' :: CreateExperiment -> Maybe Text
segment} -> Maybe Text
segment) (\s :: CreateExperiment
s@CreateExperiment' {} Maybe Text
a -> CreateExperiment
s {$sel:segment:CreateExperiment' :: Maybe Text
segment = Maybe Text
a} :: CreateExperiment)

-- | Assigns one or more tags (key-value pairs) to the experiment.
--
-- Tags can help you organize and categorize your resources. You can also
-- use them to scope user permissions by granting a user permission to
-- access or change only resources with certain tag values.
--
-- Tags don\'t have any semantic meaning to Amazon Web Services and are
-- interpreted strictly as strings of characters.
--
-- >  <p>You can associate as many as 50 tags with an experiment.</p> <p>For more information, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html">Tagging Amazon Web Services resources</a>.</p>
createExperiment_tags :: Lens.Lens' CreateExperiment (Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text))
createExperiment_tags :: Lens' CreateExperiment (Maybe (HashMap Text Text))
createExperiment_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateExperiment' {Maybe (HashMap Text Text)
tags :: Maybe (HashMap Text Text)
$sel:tags:CreateExperiment' :: CreateExperiment -> Maybe (HashMap Text Text)
tags} -> Maybe (HashMap Text Text)
tags) (\s :: CreateExperiment
s@CreateExperiment' {} Maybe (HashMap Text Text)
a -> CreateExperiment
s {$sel:tags:CreateExperiment' :: Maybe (HashMap Text Text)
tags = Maybe (HashMap Text Text)
a} :: CreateExperiment) 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

-- | An array of structures that defines the metrics used for the experiment,
-- and whether a higher or lower value for each metric is the goal.
createExperiment_metricGoals :: Lens.Lens' CreateExperiment (Prelude.NonEmpty MetricGoalConfig)
createExperiment_metricGoals :: Lens' CreateExperiment (NonEmpty MetricGoalConfig)
createExperiment_metricGoals = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateExperiment' {NonEmpty MetricGoalConfig
metricGoals :: NonEmpty MetricGoalConfig
$sel:metricGoals:CreateExperiment' :: CreateExperiment -> NonEmpty MetricGoalConfig
metricGoals} -> NonEmpty MetricGoalConfig
metricGoals) (\s :: CreateExperiment
s@CreateExperiment' {} NonEmpty MetricGoalConfig
a -> CreateExperiment
s {$sel:metricGoals:CreateExperiment' :: NonEmpty MetricGoalConfig
metricGoals = NonEmpty MetricGoalConfig
a} :: CreateExperiment) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | A name for the new experiment.
createExperiment_name :: Lens.Lens' CreateExperiment Prelude.Text
createExperiment_name :: Lens' CreateExperiment Text
createExperiment_name = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateExperiment' {Text
name :: Text
$sel:name:CreateExperiment' :: CreateExperiment -> Text
name} -> Text
name) (\s :: CreateExperiment
s@CreateExperiment' {} Text
a -> CreateExperiment
s {$sel:name:CreateExperiment' :: Text
name = Text
a} :: CreateExperiment)

-- | The name or ARN of the project that you want to create the new
-- experiment in.
createExperiment_project :: Lens.Lens' CreateExperiment Prelude.Text
createExperiment_project :: Lens' CreateExperiment Text
createExperiment_project = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateExperiment' {Text
project :: Text
$sel:project:CreateExperiment' :: CreateExperiment -> Text
project} -> Text
project) (\s :: CreateExperiment
s@CreateExperiment' {} Text
a -> CreateExperiment
s {$sel:project:CreateExperiment' :: Text
project = Text
a} :: CreateExperiment)

-- | An array of structures that describe the configuration of each feature
-- variation used in the experiment.
createExperiment_treatments :: Lens.Lens' CreateExperiment [TreatmentConfig]
createExperiment_treatments :: Lens' CreateExperiment [TreatmentConfig]
createExperiment_treatments = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateExperiment' {[TreatmentConfig]
treatments :: [TreatmentConfig]
$sel:treatments:CreateExperiment' :: CreateExperiment -> [TreatmentConfig]
treatments} -> [TreatmentConfig]
treatments) (\s :: CreateExperiment
s@CreateExperiment' {} [TreatmentConfig]
a -> CreateExperiment
s {$sel:treatments:CreateExperiment' :: [TreatmentConfig]
treatments = [TreatmentConfig]
a} :: CreateExperiment) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

instance Core.AWSRequest CreateExperiment where
  type
    AWSResponse CreateExperiment =
      CreateExperimentResponse
  request :: (Service -> Service)
-> CreateExperiment -> Request CreateExperiment
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 CreateExperiment
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse CreateExperiment)))
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 ->
          Int -> Experiment -> CreateExperimentResponse
CreateExperimentResponse'
            forall (f :: * -> *) a b. Functor 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))
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String a
Data..:> Key
"experiment")
      )

instance Prelude.Hashable CreateExperiment where
  hashWithSalt :: Int -> CreateExperiment -> Int
hashWithSalt Int
_salt CreateExperiment' {[TreatmentConfig]
Maybe Natural
Maybe Text
Maybe (HashMap Text Text)
Maybe OnlineAbConfig
NonEmpty MetricGoalConfig
Text
treatments :: [TreatmentConfig]
project :: Text
name :: Text
metricGoals :: NonEmpty MetricGoalConfig
tags :: Maybe (HashMap Text Text)
segment :: Maybe Text
samplingRate :: Maybe Natural
randomizationSalt :: Maybe Text
onlineAbConfig :: Maybe OnlineAbConfig
description :: Maybe Text
$sel:treatments:CreateExperiment' :: CreateExperiment -> [TreatmentConfig]
$sel:project:CreateExperiment' :: CreateExperiment -> Text
$sel:name:CreateExperiment' :: CreateExperiment -> Text
$sel:metricGoals:CreateExperiment' :: CreateExperiment -> NonEmpty MetricGoalConfig
$sel:tags:CreateExperiment' :: CreateExperiment -> Maybe (HashMap Text Text)
$sel:segment:CreateExperiment' :: CreateExperiment -> Maybe Text
$sel:samplingRate:CreateExperiment' :: CreateExperiment -> Maybe Natural
$sel:randomizationSalt:CreateExperiment' :: CreateExperiment -> Maybe Text
$sel:onlineAbConfig:CreateExperiment' :: CreateExperiment -> Maybe OnlineAbConfig
$sel:description:CreateExperiment' :: CreateExperiment -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
description
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe OnlineAbConfig
onlineAbConfig
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
randomizationSalt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Natural
samplingRate
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
segment
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (HashMap Text Text)
tags
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` NonEmpty MetricGoalConfig
metricGoals
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
name
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
project
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` [TreatmentConfig]
treatments

instance Prelude.NFData CreateExperiment where
  rnf :: CreateExperiment -> ()
rnf CreateExperiment' {[TreatmentConfig]
Maybe Natural
Maybe Text
Maybe (HashMap Text Text)
Maybe OnlineAbConfig
NonEmpty MetricGoalConfig
Text
treatments :: [TreatmentConfig]
project :: Text
name :: Text
metricGoals :: NonEmpty MetricGoalConfig
tags :: Maybe (HashMap Text Text)
segment :: Maybe Text
samplingRate :: Maybe Natural
randomizationSalt :: Maybe Text
onlineAbConfig :: Maybe OnlineAbConfig
description :: Maybe Text
$sel:treatments:CreateExperiment' :: CreateExperiment -> [TreatmentConfig]
$sel:project:CreateExperiment' :: CreateExperiment -> Text
$sel:name:CreateExperiment' :: CreateExperiment -> Text
$sel:metricGoals:CreateExperiment' :: CreateExperiment -> NonEmpty MetricGoalConfig
$sel:tags:CreateExperiment' :: CreateExperiment -> Maybe (HashMap Text Text)
$sel:segment:CreateExperiment' :: CreateExperiment -> Maybe Text
$sel:samplingRate:CreateExperiment' :: CreateExperiment -> Maybe Natural
$sel:randomizationSalt:CreateExperiment' :: CreateExperiment -> Maybe Text
$sel:onlineAbConfig:CreateExperiment' :: CreateExperiment -> Maybe OnlineAbConfig
$sel:description:CreateExperiment' :: CreateExperiment -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
description
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe OnlineAbConfig
onlineAbConfig
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
randomizationSalt
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Natural
samplingRate
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
segment
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe (HashMap Text Text)
tags
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf NonEmpty MetricGoalConfig
metricGoals
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
name
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
project
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf [TreatmentConfig]
treatments

instance Data.ToHeaders CreateExperiment where
  toHeaders :: CreateExperiment -> ResponseHeaders
toHeaders =
    forall a b. a -> b -> a
Prelude.const
      ( forall a. Monoid a => [a] -> a
Prelude.mconcat
          [ HeaderName
"Content-Type"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"application/x-amz-json-1.1" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Data.ToJSON CreateExperiment where
  toJSON :: CreateExperiment -> Value
toJSON CreateExperiment' {[TreatmentConfig]
Maybe Natural
Maybe Text
Maybe (HashMap Text Text)
Maybe OnlineAbConfig
NonEmpty MetricGoalConfig
Text
treatments :: [TreatmentConfig]
project :: Text
name :: Text
metricGoals :: NonEmpty MetricGoalConfig
tags :: Maybe (HashMap Text Text)
segment :: Maybe Text
samplingRate :: Maybe Natural
randomizationSalt :: Maybe Text
onlineAbConfig :: Maybe OnlineAbConfig
description :: Maybe Text
$sel:treatments:CreateExperiment' :: CreateExperiment -> [TreatmentConfig]
$sel:project:CreateExperiment' :: CreateExperiment -> Text
$sel:name:CreateExperiment' :: CreateExperiment -> Text
$sel:metricGoals:CreateExperiment' :: CreateExperiment -> NonEmpty MetricGoalConfig
$sel:tags:CreateExperiment' :: CreateExperiment -> Maybe (HashMap Text Text)
$sel:segment:CreateExperiment' :: CreateExperiment -> Maybe Text
$sel:samplingRate:CreateExperiment' :: CreateExperiment -> Maybe Natural
$sel:randomizationSalt:CreateExperiment' :: CreateExperiment -> Maybe Text
$sel:onlineAbConfig:CreateExperiment' :: CreateExperiment -> Maybe OnlineAbConfig
$sel:description:CreateExperiment' :: CreateExperiment -> Maybe Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"description" 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
description,
            (Key
"onlineAbConfig" 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 OnlineAbConfig
onlineAbConfig,
            (Key
"randomizationSalt" 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
randomizationSalt,
            (Key
"samplingRate" 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 Natural
samplingRate,
            (Key
"segment" 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
segment,
            (Key
"tags" 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 (HashMap Text Text)
tags,
            forall a. a -> Maybe a
Prelude.Just (Key
"metricGoals" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= NonEmpty MetricGoalConfig
metricGoals),
            forall a. a -> Maybe a
Prelude.Just (Key
"name" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
name),
            forall a. a -> Maybe a
Prelude.Just (Key
"treatments" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= [TreatmentConfig]
treatments)
          ]
      )

instance Data.ToPath CreateExperiment where
  toPath :: CreateExperiment -> ByteString
toPath CreateExperiment' {[TreatmentConfig]
Maybe Natural
Maybe Text
Maybe (HashMap Text Text)
Maybe OnlineAbConfig
NonEmpty MetricGoalConfig
Text
treatments :: [TreatmentConfig]
project :: Text
name :: Text
metricGoals :: NonEmpty MetricGoalConfig
tags :: Maybe (HashMap Text Text)
segment :: Maybe Text
samplingRate :: Maybe Natural
randomizationSalt :: Maybe Text
onlineAbConfig :: Maybe OnlineAbConfig
description :: Maybe Text
$sel:treatments:CreateExperiment' :: CreateExperiment -> [TreatmentConfig]
$sel:project:CreateExperiment' :: CreateExperiment -> Text
$sel:name:CreateExperiment' :: CreateExperiment -> Text
$sel:metricGoals:CreateExperiment' :: CreateExperiment -> NonEmpty MetricGoalConfig
$sel:tags:CreateExperiment' :: CreateExperiment -> Maybe (HashMap Text Text)
$sel:segment:CreateExperiment' :: CreateExperiment -> Maybe Text
$sel:samplingRate:CreateExperiment' :: CreateExperiment -> Maybe Natural
$sel:randomizationSalt:CreateExperiment' :: CreateExperiment -> Maybe Text
$sel:onlineAbConfig:CreateExperiment' :: CreateExperiment -> Maybe OnlineAbConfig
$sel:description:CreateExperiment' :: CreateExperiment -> Maybe Text
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ByteString
"/projects/", forall a. ToByteString a => a -> ByteString
Data.toBS Text
project, ByteString
"/experiments"]

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

-- | /See:/ 'newCreateExperimentResponse' smart constructor.
data CreateExperimentResponse = CreateExperimentResponse'
  { -- | The response's http status code.
    CreateExperimentResponse -> Int
httpStatus :: Prelude.Int,
    -- | A structure containing the configuration details of the experiment that
    -- you created.
    CreateExperimentResponse -> Experiment
experiment :: Experiment
  }
  deriving (CreateExperimentResponse -> CreateExperimentResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateExperimentResponse -> CreateExperimentResponse -> Bool
$c/= :: CreateExperimentResponse -> CreateExperimentResponse -> Bool
== :: CreateExperimentResponse -> CreateExperimentResponse -> Bool
$c== :: CreateExperimentResponse -> CreateExperimentResponse -> Bool
Prelude.Eq, ReadPrec [CreateExperimentResponse]
ReadPrec CreateExperimentResponse
Int -> ReadS CreateExperimentResponse
ReadS [CreateExperimentResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateExperimentResponse]
$creadListPrec :: ReadPrec [CreateExperimentResponse]
readPrec :: ReadPrec CreateExperimentResponse
$creadPrec :: ReadPrec CreateExperimentResponse
readList :: ReadS [CreateExperimentResponse]
$creadList :: ReadS [CreateExperimentResponse]
readsPrec :: Int -> ReadS CreateExperimentResponse
$creadsPrec :: Int -> ReadS CreateExperimentResponse
Prelude.Read, Int -> CreateExperimentResponse -> ShowS
[CreateExperimentResponse] -> ShowS
CreateExperimentResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateExperimentResponse] -> ShowS
$cshowList :: [CreateExperimentResponse] -> ShowS
show :: CreateExperimentResponse -> String
$cshow :: CreateExperimentResponse -> String
showsPrec :: Int -> CreateExperimentResponse -> ShowS
$cshowsPrec :: Int -> CreateExperimentResponse -> ShowS
Prelude.Show, forall x.
Rep CreateExperimentResponse x -> CreateExperimentResponse
forall x.
CreateExperimentResponse -> Rep CreateExperimentResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep CreateExperimentResponse x -> CreateExperimentResponse
$cfrom :: forall x.
CreateExperimentResponse -> Rep CreateExperimentResponse x
Prelude.Generic)

-- |
-- Create a value of 'CreateExperimentResponse' 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:
--
-- 'httpStatus', 'createExperimentResponse_httpStatus' - The response's http status code.
--
-- 'experiment', 'createExperimentResponse_experiment' - A structure containing the configuration details of the experiment that
-- you created.
newCreateExperimentResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  -- | 'experiment'
  Experiment ->
  CreateExperimentResponse
newCreateExperimentResponse :: Int -> Experiment -> CreateExperimentResponse
newCreateExperimentResponse Int
pHttpStatus_ Experiment
pExperiment_ =
  CreateExperimentResponse'
    { $sel:httpStatus:CreateExperimentResponse' :: Int
httpStatus =
        Int
pHttpStatus_,
      $sel:experiment:CreateExperimentResponse' :: Experiment
experiment = Experiment
pExperiment_
    }

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

-- | A structure containing the configuration details of the experiment that
-- you created.
createExperimentResponse_experiment :: Lens.Lens' CreateExperimentResponse Experiment
createExperimentResponse_experiment :: Lens' CreateExperimentResponse Experiment
createExperimentResponse_experiment = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateExperimentResponse' {Experiment
experiment :: Experiment
$sel:experiment:CreateExperimentResponse' :: CreateExperimentResponse -> Experiment
experiment} -> Experiment
experiment) (\s :: CreateExperimentResponse
s@CreateExperimentResponse' {} Experiment
a -> CreateExperimentResponse
s {$sel:experiment:CreateExperimentResponse' :: Experiment
experiment = Experiment
a} :: CreateExperimentResponse)

instance Prelude.NFData CreateExperimentResponse where
  rnf :: CreateExperimentResponse -> ()
rnf CreateExperimentResponse' {Int
Experiment
experiment :: Experiment
httpStatus :: Int
$sel:experiment:CreateExperimentResponse' :: CreateExperimentResponse -> Experiment
$sel:httpStatus:CreateExperimentResponse' :: CreateExperimentResponse -> Int
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Experiment
experiment