{-# 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.LookoutMetrics.CreateMetricSet
-- 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 a dataset.
module Amazonka.LookoutMetrics.CreateMetricSet
  ( -- * Creating a Request
    CreateMetricSet (..),
    newCreateMetricSet,

    -- * Request Lenses
    createMetricSet_dimensionFilterList,
    createMetricSet_dimensionList,
    createMetricSet_metricSetDescription,
    createMetricSet_metricSetFrequency,
    createMetricSet_offset,
    createMetricSet_tags,
    createMetricSet_timestampColumn,
    createMetricSet_timezone,
    createMetricSet_anomalyDetectorArn,
    createMetricSet_metricSetName,
    createMetricSet_metricList,
    createMetricSet_metricSource,

    -- * Destructuring the Response
    CreateMetricSetResponse (..),
    newCreateMetricSetResponse,

    -- * Response Lenses
    createMetricSetResponse_metricSetArn,
    createMetricSetResponse_httpStatus,
  )
where

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

-- | /See:/ 'newCreateMetricSet' smart constructor.
data CreateMetricSet = CreateMetricSet'
  { -- | A list of filters that specify which data is kept for anomaly detection.
    CreateMetricSet -> Maybe [MetricSetDimensionFilter]
dimensionFilterList :: Prelude.Maybe [MetricSetDimensionFilter],
    -- | A list of the fields you want to treat as dimensions.
    CreateMetricSet -> Maybe (NonEmpty Text)
dimensionList :: Prelude.Maybe (Prelude.NonEmpty Prelude.Text),
    -- | A description of the dataset you are creating.
    CreateMetricSet -> Maybe Text
metricSetDescription :: Prelude.Maybe Prelude.Text,
    -- | The frequency with which the source data will be analyzed for anomalies.
    CreateMetricSet -> Maybe Frequency
metricSetFrequency :: Prelude.Maybe Frequency,
    -- | After an interval ends, the amount of seconds that the detector waits
    -- before importing data. Offset is only supported for S3, Redshift, Athena
    -- and datasources.
    CreateMetricSet -> Maybe Natural
offset :: Prelude.Maybe Prelude.Natural,
    -- | A list of
    -- <https://docs.aws.amazon.com/lookoutmetrics/latest/dev/detectors-tags.html tags>
    -- to apply to the dataset.
    CreateMetricSet -> Maybe (HashMap Text Text)
tags :: Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text),
    -- | Contains information about the column used for tracking time in your
    -- source data.
    CreateMetricSet -> Maybe TimestampColumn
timestampColumn :: Prelude.Maybe TimestampColumn,
    -- | The time zone in which your source data was recorded.
    CreateMetricSet -> Maybe Text
timezone :: Prelude.Maybe Prelude.Text,
    -- | The ARN of the anomaly detector that will use the dataset.
    CreateMetricSet -> Text
anomalyDetectorArn :: Prelude.Text,
    -- | The name of the dataset.
    CreateMetricSet -> Text
metricSetName :: Prelude.Text,
    -- | A list of metrics that the dataset will contain.
    CreateMetricSet -> NonEmpty Metric
metricList :: Prelude.NonEmpty Metric,
    -- | Contains information about how the source data should be interpreted.
    CreateMetricSet -> MetricSource
metricSource :: MetricSource
  }
  deriving (CreateMetricSet -> CreateMetricSet -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateMetricSet -> CreateMetricSet -> Bool
$c/= :: CreateMetricSet -> CreateMetricSet -> Bool
== :: CreateMetricSet -> CreateMetricSet -> Bool
$c== :: CreateMetricSet -> CreateMetricSet -> Bool
Prelude.Eq, ReadPrec [CreateMetricSet]
ReadPrec CreateMetricSet
Int -> ReadS CreateMetricSet
ReadS [CreateMetricSet]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateMetricSet]
$creadListPrec :: ReadPrec [CreateMetricSet]
readPrec :: ReadPrec CreateMetricSet
$creadPrec :: ReadPrec CreateMetricSet
readList :: ReadS [CreateMetricSet]
$creadList :: ReadS [CreateMetricSet]
readsPrec :: Int -> ReadS CreateMetricSet
$creadsPrec :: Int -> ReadS CreateMetricSet
Prelude.Read, Int -> CreateMetricSet -> ShowS
[CreateMetricSet] -> ShowS
CreateMetricSet -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateMetricSet] -> ShowS
$cshowList :: [CreateMetricSet] -> ShowS
show :: CreateMetricSet -> String
$cshow :: CreateMetricSet -> String
showsPrec :: Int -> CreateMetricSet -> ShowS
$cshowsPrec :: Int -> CreateMetricSet -> ShowS
Prelude.Show, forall x. Rep CreateMetricSet x -> CreateMetricSet
forall x. CreateMetricSet -> Rep CreateMetricSet x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateMetricSet x -> CreateMetricSet
$cfrom :: forall x. CreateMetricSet -> Rep CreateMetricSet x
Prelude.Generic)

-- |
-- Create a value of 'CreateMetricSet' 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:
--
-- 'dimensionFilterList', 'createMetricSet_dimensionFilterList' - A list of filters that specify which data is kept for anomaly detection.
--
-- 'dimensionList', 'createMetricSet_dimensionList' - A list of the fields you want to treat as dimensions.
--
-- 'metricSetDescription', 'createMetricSet_metricSetDescription' - A description of the dataset you are creating.
--
-- 'metricSetFrequency', 'createMetricSet_metricSetFrequency' - The frequency with which the source data will be analyzed for anomalies.
--
-- 'offset', 'createMetricSet_offset' - After an interval ends, the amount of seconds that the detector waits
-- before importing data. Offset is only supported for S3, Redshift, Athena
-- and datasources.
--
-- 'tags', 'createMetricSet_tags' - A list of
-- <https://docs.aws.amazon.com/lookoutmetrics/latest/dev/detectors-tags.html tags>
-- to apply to the dataset.
--
-- 'timestampColumn', 'createMetricSet_timestampColumn' - Contains information about the column used for tracking time in your
-- source data.
--
-- 'timezone', 'createMetricSet_timezone' - The time zone in which your source data was recorded.
--
-- 'anomalyDetectorArn', 'createMetricSet_anomalyDetectorArn' - The ARN of the anomaly detector that will use the dataset.
--
-- 'metricSetName', 'createMetricSet_metricSetName' - The name of the dataset.
--
-- 'metricList', 'createMetricSet_metricList' - A list of metrics that the dataset will contain.
--
-- 'metricSource', 'createMetricSet_metricSource' - Contains information about how the source data should be interpreted.
newCreateMetricSet ::
  -- | 'anomalyDetectorArn'
  Prelude.Text ->
  -- | 'metricSetName'
  Prelude.Text ->
  -- | 'metricList'
  Prelude.NonEmpty Metric ->
  -- | 'metricSource'
  MetricSource ->
  CreateMetricSet
newCreateMetricSet :: Text -> Text -> NonEmpty Metric -> MetricSource -> CreateMetricSet
newCreateMetricSet
  Text
pAnomalyDetectorArn_
  Text
pMetricSetName_
  NonEmpty Metric
pMetricList_
  MetricSource
pMetricSource_ =
    CreateMetricSet'
      { $sel:dimensionFilterList:CreateMetricSet' :: Maybe [MetricSetDimensionFilter]
dimensionFilterList =
          forall a. Maybe a
Prelude.Nothing,
        $sel:dimensionList:CreateMetricSet' :: Maybe (NonEmpty Text)
dimensionList = forall a. Maybe a
Prelude.Nothing,
        $sel:metricSetDescription:CreateMetricSet' :: Maybe Text
metricSetDescription = forall a. Maybe a
Prelude.Nothing,
        $sel:metricSetFrequency:CreateMetricSet' :: Maybe Frequency
metricSetFrequency = forall a. Maybe a
Prelude.Nothing,
        $sel:offset:CreateMetricSet' :: Maybe Natural
offset = forall a. Maybe a
Prelude.Nothing,
        $sel:tags:CreateMetricSet' :: Maybe (HashMap Text Text)
tags = forall a. Maybe a
Prelude.Nothing,
        $sel:timestampColumn:CreateMetricSet' :: Maybe TimestampColumn
timestampColumn = forall a. Maybe a
Prelude.Nothing,
        $sel:timezone:CreateMetricSet' :: Maybe Text
timezone = forall a. Maybe a
Prelude.Nothing,
        $sel:anomalyDetectorArn:CreateMetricSet' :: Text
anomalyDetectorArn = Text
pAnomalyDetectorArn_,
        $sel:metricSetName:CreateMetricSet' :: Text
metricSetName = Text
pMetricSetName_,
        $sel:metricList:CreateMetricSet' :: NonEmpty Metric
metricList = 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 Metric
pMetricList_,
        $sel:metricSource:CreateMetricSet' :: MetricSource
metricSource = MetricSource
pMetricSource_
      }

-- | A list of filters that specify which data is kept for anomaly detection.
createMetricSet_dimensionFilterList :: Lens.Lens' CreateMetricSet (Prelude.Maybe [MetricSetDimensionFilter])
createMetricSet_dimensionFilterList :: Lens' CreateMetricSet (Maybe [MetricSetDimensionFilter])
createMetricSet_dimensionFilterList = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateMetricSet' {Maybe [MetricSetDimensionFilter]
dimensionFilterList :: Maybe [MetricSetDimensionFilter]
$sel:dimensionFilterList:CreateMetricSet' :: CreateMetricSet -> Maybe [MetricSetDimensionFilter]
dimensionFilterList} -> Maybe [MetricSetDimensionFilter]
dimensionFilterList) (\s :: CreateMetricSet
s@CreateMetricSet' {} Maybe [MetricSetDimensionFilter]
a -> CreateMetricSet
s {$sel:dimensionFilterList:CreateMetricSet' :: Maybe [MetricSetDimensionFilter]
dimensionFilterList = Maybe [MetricSetDimensionFilter]
a} :: CreateMetricSet) 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

-- | A list of the fields you want to treat as dimensions.
createMetricSet_dimensionList :: Lens.Lens' CreateMetricSet (Prelude.Maybe (Prelude.NonEmpty Prelude.Text))
createMetricSet_dimensionList :: Lens' CreateMetricSet (Maybe (NonEmpty Text))
createMetricSet_dimensionList = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateMetricSet' {Maybe (NonEmpty Text)
dimensionList :: Maybe (NonEmpty Text)
$sel:dimensionList:CreateMetricSet' :: CreateMetricSet -> Maybe (NonEmpty Text)
dimensionList} -> Maybe (NonEmpty Text)
dimensionList) (\s :: CreateMetricSet
s@CreateMetricSet' {} Maybe (NonEmpty Text)
a -> CreateMetricSet
s {$sel:dimensionList:CreateMetricSet' :: Maybe (NonEmpty Text)
dimensionList = Maybe (NonEmpty Text)
a} :: CreateMetricSet) 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

-- | A description of the dataset you are creating.
createMetricSet_metricSetDescription :: Lens.Lens' CreateMetricSet (Prelude.Maybe Prelude.Text)
createMetricSet_metricSetDescription :: Lens' CreateMetricSet (Maybe Text)
createMetricSet_metricSetDescription = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateMetricSet' {Maybe Text
metricSetDescription :: Maybe Text
$sel:metricSetDescription:CreateMetricSet' :: CreateMetricSet -> Maybe Text
metricSetDescription} -> Maybe Text
metricSetDescription) (\s :: CreateMetricSet
s@CreateMetricSet' {} Maybe Text
a -> CreateMetricSet
s {$sel:metricSetDescription:CreateMetricSet' :: Maybe Text
metricSetDescription = Maybe Text
a} :: CreateMetricSet)

-- | The frequency with which the source data will be analyzed for anomalies.
createMetricSet_metricSetFrequency :: Lens.Lens' CreateMetricSet (Prelude.Maybe Frequency)
createMetricSet_metricSetFrequency :: Lens' CreateMetricSet (Maybe Frequency)
createMetricSet_metricSetFrequency = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateMetricSet' {Maybe Frequency
metricSetFrequency :: Maybe Frequency
$sel:metricSetFrequency:CreateMetricSet' :: CreateMetricSet -> Maybe Frequency
metricSetFrequency} -> Maybe Frequency
metricSetFrequency) (\s :: CreateMetricSet
s@CreateMetricSet' {} Maybe Frequency
a -> CreateMetricSet
s {$sel:metricSetFrequency:CreateMetricSet' :: Maybe Frequency
metricSetFrequency = Maybe Frequency
a} :: CreateMetricSet)

-- | After an interval ends, the amount of seconds that the detector waits
-- before importing data. Offset is only supported for S3, Redshift, Athena
-- and datasources.
createMetricSet_offset :: Lens.Lens' CreateMetricSet (Prelude.Maybe Prelude.Natural)
createMetricSet_offset :: Lens' CreateMetricSet (Maybe Natural)
createMetricSet_offset = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateMetricSet' {Maybe Natural
offset :: Maybe Natural
$sel:offset:CreateMetricSet' :: CreateMetricSet -> Maybe Natural
offset} -> Maybe Natural
offset) (\s :: CreateMetricSet
s@CreateMetricSet' {} Maybe Natural
a -> CreateMetricSet
s {$sel:offset:CreateMetricSet' :: Maybe Natural
offset = Maybe Natural
a} :: CreateMetricSet)

-- | A list of
-- <https://docs.aws.amazon.com/lookoutmetrics/latest/dev/detectors-tags.html tags>
-- to apply to the dataset.
createMetricSet_tags :: Lens.Lens' CreateMetricSet (Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text))
createMetricSet_tags :: Lens' CreateMetricSet (Maybe (HashMap Text Text))
createMetricSet_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateMetricSet' {Maybe (HashMap Text Text)
tags :: Maybe (HashMap Text Text)
$sel:tags:CreateMetricSet' :: CreateMetricSet -> Maybe (HashMap Text Text)
tags} -> Maybe (HashMap Text Text)
tags) (\s :: CreateMetricSet
s@CreateMetricSet' {} Maybe (HashMap Text Text)
a -> CreateMetricSet
s {$sel:tags:CreateMetricSet' :: Maybe (HashMap Text Text)
tags = Maybe (HashMap Text Text)
a} :: CreateMetricSet) 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

-- | Contains information about the column used for tracking time in your
-- source data.
createMetricSet_timestampColumn :: Lens.Lens' CreateMetricSet (Prelude.Maybe TimestampColumn)
createMetricSet_timestampColumn :: Lens' CreateMetricSet (Maybe TimestampColumn)
createMetricSet_timestampColumn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateMetricSet' {Maybe TimestampColumn
timestampColumn :: Maybe TimestampColumn
$sel:timestampColumn:CreateMetricSet' :: CreateMetricSet -> Maybe TimestampColumn
timestampColumn} -> Maybe TimestampColumn
timestampColumn) (\s :: CreateMetricSet
s@CreateMetricSet' {} Maybe TimestampColumn
a -> CreateMetricSet
s {$sel:timestampColumn:CreateMetricSet' :: Maybe TimestampColumn
timestampColumn = Maybe TimestampColumn
a} :: CreateMetricSet)

-- | The time zone in which your source data was recorded.
createMetricSet_timezone :: Lens.Lens' CreateMetricSet (Prelude.Maybe Prelude.Text)
createMetricSet_timezone :: Lens' CreateMetricSet (Maybe Text)
createMetricSet_timezone = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateMetricSet' {Maybe Text
timezone :: Maybe Text
$sel:timezone:CreateMetricSet' :: CreateMetricSet -> Maybe Text
timezone} -> Maybe Text
timezone) (\s :: CreateMetricSet
s@CreateMetricSet' {} Maybe Text
a -> CreateMetricSet
s {$sel:timezone:CreateMetricSet' :: Maybe Text
timezone = Maybe Text
a} :: CreateMetricSet)

-- | The ARN of the anomaly detector that will use the dataset.
createMetricSet_anomalyDetectorArn :: Lens.Lens' CreateMetricSet Prelude.Text
createMetricSet_anomalyDetectorArn :: Lens' CreateMetricSet Text
createMetricSet_anomalyDetectorArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateMetricSet' {Text
anomalyDetectorArn :: Text
$sel:anomalyDetectorArn:CreateMetricSet' :: CreateMetricSet -> Text
anomalyDetectorArn} -> Text
anomalyDetectorArn) (\s :: CreateMetricSet
s@CreateMetricSet' {} Text
a -> CreateMetricSet
s {$sel:anomalyDetectorArn:CreateMetricSet' :: Text
anomalyDetectorArn = Text
a} :: CreateMetricSet)

-- | The name of the dataset.
createMetricSet_metricSetName :: Lens.Lens' CreateMetricSet Prelude.Text
createMetricSet_metricSetName :: Lens' CreateMetricSet Text
createMetricSet_metricSetName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateMetricSet' {Text
metricSetName :: Text
$sel:metricSetName:CreateMetricSet' :: CreateMetricSet -> Text
metricSetName} -> Text
metricSetName) (\s :: CreateMetricSet
s@CreateMetricSet' {} Text
a -> CreateMetricSet
s {$sel:metricSetName:CreateMetricSet' :: Text
metricSetName = Text
a} :: CreateMetricSet)

-- | A list of metrics that the dataset will contain.
createMetricSet_metricList :: Lens.Lens' CreateMetricSet (Prelude.NonEmpty Metric)
createMetricSet_metricList :: Lens' CreateMetricSet (NonEmpty Metric)
createMetricSet_metricList = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateMetricSet' {NonEmpty Metric
metricList :: NonEmpty Metric
$sel:metricList:CreateMetricSet' :: CreateMetricSet -> NonEmpty Metric
metricList} -> NonEmpty Metric
metricList) (\s :: CreateMetricSet
s@CreateMetricSet' {} NonEmpty Metric
a -> CreateMetricSet
s {$sel:metricList:CreateMetricSet' :: NonEmpty Metric
metricList = NonEmpty Metric
a} :: CreateMetricSet) 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

-- | Contains information about how the source data should be interpreted.
createMetricSet_metricSource :: Lens.Lens' CreateMetricSet MetricSource
createMetricSet_metricSource :: Lens' CreateMetricSet MetricSource
createMetricSet_metricSource = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateMetricSet' {MetricSource
metricSource :: MetricSource
$sel:metricSource:CreateMetricSet' :: CreateMetricSet -> MetricSource
metricSource} -> MetricSource
metricSource) (\s :: CreateMetricSet
s@CreateMetricSet' {} MetricSource
a -> CreateMetricSet
s {$sel:metricSource:CreateMetricSet' :: MetricSource
metricSource = MetricSource
a} :: CreateMetricSet)

instance Core.AWSRequest CreateMetricSet where
  type
    AWSResponse CreateMetricSet =
      CreateMetricSetResponse
  request :: (Service -> Service) -> CreateMetricSet -> Request CreateMetricSet
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 CreateMetricSet
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse CreateMetricSet)))
response =
    forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> Object -> Either String (AWSResponse a))
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveJSON
      ( \Int
s ResponseHeaders
h Object
x ->
          Maybe Text -> Int -> CreateMetricSetResponse
CreateMetricSetResponse'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"MetricSetArn")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (forall (f :: * -> *) a. Applicative f => a -> f a
Prelude.pure (forall a. Enum a => a -> Int
Prelude.fromEnum Int
s))
      )

instance Prelude.Hashable CreateMetricSet where
  hashWithSalt :: Int -> CreateMetricSet -> Int
hashWithSalt Int
_salt CreateMetricSet' {Maybe Natural
Maybe [MetricSetDimensionFilter]
Maybe (NonEmpty Text)
Maybe Text
Maybe (HashMap Text Text)
Maybe Frequency
Maybe TimestampColumn
NonEmpty Metric
Text
MetricSource
metricSource :: MetricSource
metricList :: NonEmpty Metric
metricSetName :: Text
anomalyDetectorArn :: Text
timezone :: Maybe Text
timestampColumn :: Maybe TimestampColumn
tags :: Maybe (HashMap Text Text)
offset :: Maybe Natural
metricSetFrequency :: Maybe Frequency
metricSetDescription :: Maybe Text
dimensionList :: Maybe (NonEmpty Text)
dimensionFilterList :: Maybe [MetricSetDimensionFilter]
$sel:metricSource:CreateMetricSet' :: CreateMetricSet -> MetricSource
$sel:metricList:CreateMetricSet' :: CreateMetricSet -> NonEmpty Metric
$sel:metricSetName:CreateMetricSet' :: CreateMetricSet -> Text
$sel:anomalyDetectorArn:CreateMetricSet' :: CreateMetricSet -> Text
$sel:timezone:CreateMetricSet' :: CreateMetricSet -> Maybe Text
$sel:timestampColumn:CreateMetricSet' :: CreateMetricSet -> Maybe TimestampColumn
$sel:tags:CreateMetricSet' :: CreateMetricSet -> Maybe (HashMap Text Text)
$sel:offset:CreateMetricSet' :: CreateMetricSet -> Maybe Natural
$sel:metricSetFrequency:CreateMetricSet' :: CreateMetricSet -> Maybe Frequency
$sel:metricSetDescription:CreateMetricSet' :: CreateMetricSet -> Maybe Text
$sel:dimensionList:CreateMetricSet' :: CreateMetricSet -> Maybe (NonEmpty Text)
$sel:dimensionFilterList:CreateMetricSet' :: CreateMetricSet -> Maybe [MetricSetDimensionFilter]
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [MetricSetDimensionFilter]
dimensionFilterList
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (NonEmpty Text)
dimensionList
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
metricSetDescription
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Frequency
metricSetFrequency
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Natural
offset
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (HashMap Text Text)
tags
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe TimestampColumn
timestampColumn
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
timezone
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
anomalyDetectorArn
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
metricSetName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` NonEmpty Metric
metricList
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` MetricSource
metricSource

instance Prelude.NFData CreateMetricSet where
  rnf :: CreateMetricSet -> ()
rnf CreateMetricSet' {Maybe Natural
Maybe [MetricSetDimensionFilter]
Maybe (NonEmpty Text)
Maybe Text
Maybe (HashMap Text Text)
Maybe Frequency
Maybe TimestampColumn
NonEmpty Metric
Text
MetricSource
metricSource :: MetricSource
metricList :: NonEmpty Metric
metricSetName :: Text
anomalyDetectorArn :: Text
timezone :: Maybe Text
timestampColumn :: Maybe TimestampColumn
tags :: Maybe (HashMap Text Text)
offset :: Maybe Natural
metricSetFrequency :: Maybe Frequency
metricSetDescription :: Maybe Text
dimensionList :: Maybe (NonEmpty Text)
dimensionFilterList :: Maybe [MetricSetDimensionFilter]
$sel:metricSource:CreateMetricSet' :: CreateMetricSet -> MetricSource
$sel:metricList:CreateMetricSet' :: CreateMetricSet -> NonEmpty Metric
$sel:metricSetName:CreateMetricSet' :: CreateMetricSet -> Text
$sel:anomalyDetectorArn:CreateMetricSet' :: CreateMetricSet -> Text
$sel:timezone:CreateMetricSet' :: CreateMetricSet -> Maybe Text
$sel:timestampColumn:CreateMetricSet' :: CreateMetricSet -> Maybe TimestampColumn
$sel:tags:CreateMetricSet' :: CreateMetricSet -> Maybe (HashMap Text Text)
$sel:offset:CreateMetricSet' :: CreateMetricSet -> Maybe Natural
$sel:metricSetFrequency:CreateMetricSet' :: CreateMetricSet -> Maybe Frequency
$sel:metricSetDescription:CreateMetricSet' :: CreateMetricSet -> Maybe Text
$sel:dimensionList:CreateMetricSet' :: CreateMetricSet -> Maybe (NonEmpty Text)
$sel:dimensionFilterList:CreateMetricSet' :: CreateMetricSet -> Maybe [MetricSetDimensionFilter]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [MetricSetDimensionFilter]
dimensionFilterList
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe (NonEmpty Text)
dimensionList
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
metricSetDescription
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Frequency
metricSetFrequency
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Natural
offset
      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 Maybe TimestampColumn
timestampColumn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
timezone
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
anomalyDetectorArn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
metricSetName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf NonEmpty Metric
metricList
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf MetricSource
metricSource

instance Data.ToHeaders CreateMetricSet where
  toHeaders :: CreateMetricSet -> 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 CreateMetricSet where
  toJSON :: CreateMetricSet -> Value
toJSON CreateMetricSet' {Maybe Natural
Maybe [MetricSetDimensionFilter]
Maybe (NonEmpty Text)
Maybe Text
Maybe (HashMap Text Text)
Maybe Frequency
Maybe TimestampColumn
NonEmpty Metric
Text
MetricSource
metricSource :: MetricSource
metricList :: NonEmpty Metric
metricSetName :: Text
anomalyDetectorArn :: Text
timezone :: Maybe Text
timestampColumn :: Maybe TimestampColumn
tags :: Maybe (HashMap Text Text)
offset :: Maybe Natural
metricSetFrequency :: Maybe Frequency
metricSetDescription :: Maybe Text
dimensionList :: Maybe (NonEmpty Text)
dimensionFilterList :: Maybe [MetricSetDimensionFilter]
$sel:metricSource:CreateMetricSet' :: CreateMetricSet -> MetricSource
$sel:metricList:CreateMetricSet' :: CreateMetricSet -> NonEmpty Metric
$sel:metricSetName:CreateMetricSet' :: CreateMetricSet -> Text
$sel:anomalyDetectorArn:CreateMetricSet' :: CreateMetricSet -> Text
$sel:timezone:CreateMetricSet' :: CreateMetricSet -> Maybe Text
$sel:timestampColumn:CreateMetricSet' :: CreateMetricSet -> Maybe TimestampColumn
$sel:tags:CreateMetricSet' :: CreateMetricSet -> Maybe (HashMap Text Text)
$sel:offset:CreateMetricSet' :: CreateMetricSet -> Maybe Natural
$sel:metricSetFrequency:CreateMetricSet' :: CreateMetricSet -> Maybe Frequency
$sel:metricSetDescription:CreateMetricSet' :: CreateMetricSet -> Maybe Text
$sel:dimensionList:CreateMetricSet' :: CreateMetricSet -> Maybe (NonEmpty Text)
$sel:dimensionFilterList:CreateMetricSet' :: CreateMetricSet -> Maybe [MetricSetDimensionFilter]
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"DimensionFilterList" 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 [MetricSetDimensionFilter]
dimensionFilterList,
            (Key
"DimensionList" 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 (NonEmpty Text)
dimensionList,
            (Key
"MetricSetDescription" 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
metricSetDescription,
            (Key
"MetricSetFrequency" 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 Frequency
metricSetFrequency,
            (Key
"Offset" 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
offset,
            (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,
            (Key
"TimestampColumn" 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 TimestampColumn
timestampColumn,
            (Key
"Timezone" 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
timezone,
            forall a. a -> Maybe a
Prelude.Just
              (Key
"AnomalyDetectorArn" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
anomalyDetectorArn),
            forall a. a -> Maybe a
Prelude.Just (Key
"MetricSetName" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
metricSetName),
            forall a. a -> Maybe a
Prelude.Just (Key
"MetricList" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= NonEmpty Metric
metricList),
            forall a. a -> Maybe a
Prelude.Just (Key
"MetricSource" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= MetricSource
metricSource)
          ]
      )

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

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

-- | /See:/ 'newCreateMetricSetResponse' smart constructor.
data CreateMetricSetResponse = CreateMetricSetResponse'
  { -- | The ARN of the dataset.
    CreateMetricSetResponse -> Maybe Text
metricSetArn :: Prelude.Maybe Prelude.Text,
    -- | The response's http status code.
    CreateMetricSetResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (CreateMetricSetResponse -> CreateMetricSetResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateMetricSetResponse -> CreateMetricSetResponse -> Bool
$c/= :: CreateMetricSetResponse -> CreateMetricSetResponse -> Bool
== :: CreateMetricSetResponse -> CreateMetricSetResponse -> Bool
$c== :: CreateMetricSetResponse -> CreateMetricSetResponse -> Bool
Prelude.Eq, ReadPrec [CreateMetricSetResponse]
ReadPrec CreateMetricSetResponse
Int -> ReadS CreateMetricSetResponse
ReadS [CreateMetricSetResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateMetricSetResponse]
$creadListPrec :: ReadPrec [CreateMetricSetResponse]
readPrec :: ReadPrec CreateMetricSetResponse
$creadPrec :: ReadPrec CreateMetricSetResponse
readList :: ReadS [CreateMetricSetResponse]
$creadList :: ReadS [CreateMetricSetResponse]
readsPrec :: Int -> ReadS CreateMetricSetResponse
$creadsPrec :: Int -> ReadS CreateMetricSetResponse
Prelude.Read, Int -> CreateMetricSetResponse -> ShowS
[CreateMetricSetResponse] -> ShowS
CreateMetricSetResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateMetricSetResponse] -> ShowS
$cshowList :: [CreateMetricSetResponse] -> ShowS
show :: CreateMetricSetResponse -> String
$cshow :: CreateMetricSetResponse -> String
showsPrec :: Int -> CreateMetricSetResponse -> ShowS
$cshowsPrec :: Int -> CreateMetricSetResponse -> ShowS
Prelude.Show, forall x. Rep CreateMetricSetResponse x -> CreateMetricSetResponse
forall x. CreateMetricSetResponse -> Rep CreateMetricSetResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateMetricSetResponse x -> CreateMetricSetResponse
$cfrom :: forall x. CreateMetricSetResponse -> Rep CreateMetricSetResponse x
Prelude.Generic)

-- |
-- Create a value of 'CreateMetricSetResponse' 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:
--
-- 'metricSetArn', 'createMetricSetResponse_metricSetArn' - The ARN of the dataset.
--
-- 'httpStatus', 'createMetricSetResponse_httpStatus' - The response's http status code.
newCreateMetricSetResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  CreateMetricSetResponse
newCreateMetricSetResponse :: Int -> CreateMetricSetResponse
newCreateMetricSetResponse Int
pHttpStatus_ =
  CreateMetricSetResponse'
    { $sel:metricSetArn:CreateMetricSetResponse' :: Maybe Text
metricSetArn =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:CreateMetricSetResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The ARN of the dataset.
createMetricSetResponse_metricSetArn :: Lens.Lens' CreateMetricSetResponse (Prelude.Maybe Prelude.Text)
createMetricSetResponse_metricSetArn :: Lens' CreateMetricSetResponse (Maybe Text)
createMetricSetResponse_metricSetArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateMetricSetResponse' {Maybe Text
metricSetArn :: Maybe Text
$sel:metricSetArn:CreateMetricSetResponse' :: CreateMetricSetResponse -> Maybe Text
metricSetArn} -> Maybe Text
metricSetArn) (\s :: CreateMetricSetResponse
s@CreateMetricSetResponse' {} Maybe Text
a -> CreateMetricSetResponse
s {$sel:metricSetArn:CreateMetricSetResponse' :: Maybe Text
metricSetArn = Maybe Text
a} :: CreateMetricSetResponse)

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

instance Prelude.NFData CreateMetricSetResponse where
  rnf :: CreateMetricSetResponse -> ()
rnf CreateMetricSetResponse' {Int
Maybe Text
httpStatus :: Int
metricSetArn :: Maybe Text
$sel:httpStatus:CreateMetricSetResponse' :: CreateMetricSetResponse -> Int
$sel:metricSetArn:CreateMetricSetResponse' :: CreateMetricSetResponse -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
metricSetArn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus