{-# 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.IoTAnalytics.CreateDataset
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Used to create a dataset. A dataset stores data retrieved from a data
-- store by applying a @queryAction@ (a SQL query) or a @containerAction@
-- (executing a containerized application). This operation creates the
-- skeleton of a dataset. The dataset can be populated manually by calling
-- @CreateDatasetContent@ or automatically according to a trigger you
-- specify.
module Amazonka.IoTAnalytics.CreateDataset
  ( -- * Creating a Request
    CreateDataset (..),
    newCreateDataset,

    -- * Request Lenses
    createDataset_contentDeliveryRules,
    createDataset_lateDataRules,
    createDataset_retentionPeriod,
    createDataset_tags,
    createDataset_triggers,
    createDataset_versioningConfiguration,
    createDataset_datasetName,
    createDataset_actions,

    -- * Destructuring the Response
    CreateDatasetResponse (..),
    newCreateDatasetResponse,

    -- * Response Lenses
    createDatasetResponse_datasetArn,
    createDatasetResponse_datasetName,
    createDatasetResponse_retentionPeriod,
    createDatasetResponse_httpStatus,
  )
where

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

-- | /See:/ 'newCreateDataset' smart constructor.
data CreateDataset = CreateDataset'
  { -- | When dataset contents are created, they are delivered to destinations
    -- specified here.
    CreateDataset -> Maybe [DatasetContentDeliveryRule]
contentDeliveryRules :: Prelude.Maybe [DatasetContentDeliveryRule],
    -- | A list of data rules that send notifications to CloudWatch, when data
    -- arrives late. To specify @lateDataRules@, the dataset must use a
    -- <https://docs.aws.amazon.com/iotanalytics/latest/APIReference/API_DeltaTime.html DeltaTimer>
    -- filter.
    CreateDataset -> Maybe (NonEmpty LateDataRule)
lateDataRules :: Prelude.Maybe (Prelude.NonEmpty LateDataRule),
    -- | Optional. How long, in days, versions of dataset contents are kept for
    -- the dataset. If not specified or set to @null@, versions of dataset
    -- contents are retained for at most 90 days. The number of versions of
    -- dataset contents retained is determined by the @versioningConfiguration@
    -- parameter. For more information, see
    -- <https://docs.aws.amazon.com/iotanalytics/latest/userguide/getting-started.html#aws-iot-analytics-dataset-versions Keeping Multiple Versions of IoT Analytics datasets>
    -- in the /IoT Analytics User Guide/.
    CreateDataset -> Maybe RetentionPeriod
retentionPeriod :: Prelude.Maybe RetentionPeriod,
    -- | Metadata which can be used to manage the dataset.
    CreateDataset -> Maybe (NonEmpty Tag)
tags :: Prelude.Maybe (Prelude.NonEmpty Tag),
    -- | A list of triggers. A trigger causes dataset contents to be populated at
    -- a specified time interval or when another dataset\'s contents are
    -- created. The list of triggers can be empty or contain up to five
    -- @DataSetTrigger@ objects.
    CreateDataset -> Maybe [DatasetTrigger]
triggers :: Prelude.Maybe [DatasetTrigger],
    -- | Optional. How many versions of dataset contents are kept. If not
    -- specified or set to null, only the latest version plus the latest
    -- succeeded version (if they are different) are kept for the time period
    -- specified by the @retentionPeriod@ parameter. For more information, see
    -- <https://docs.aws.amazon.com/iotanalytics/latest/userguide/getting-started.html#aws-iot-analytics-dataset-versions Keeping Multiple Versions of IoT Analytics datasets>
    -- in the /IoT Analytics User Guide/.
    CreateDataset -> Maybe VersioningConfiguration
versioningConfiguration :: Prelude.Maybe VersioningConfiguration,
    -- | The name of the dataset.
    CreateDataset -> Text
datasetName :: Prelude.Text,
    -- | A list of actions that create the dataset contents.
    CreateDataset -> NonEmpty DatasetAction
actions :: Prelude.NonEmpty DatasetAction
  }
  deriving (CreateDataset -> CreateDataset -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateDataset -> CreateDataset -> Bool
$c/= :: CreateDataset -> CreateDataset -> Bool
== :: CreateDataset -> CreateDataset -> Bool
$c== :: CreateDataset -> CreateDataset -> Bool
Prelude.Eq, ReadPrec [CreateDataset]
ReadPrec CreateDataset
Int -> ReadS CreateDataset
ReadS [CreateDataset]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateDataset]
$creadListPrec :: ReadPrec [CreateDataset]
readPrec :: ReadPrec CreateDataset
$creadPrec :: ReadPrec CreateDataset
readList :: ReadS [CreateDataset]
$creadList :: ReadS [CreateDataset]
readsPrec :: Int -> ReadS CreateDataset
$creadsPrec :: Int -> ReadS CreateDataset
Prelude.Read, Int -> CreateDataset -> ShowS
[CreateDataset] -> ShowS
CreateDataset -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateDataset] -> ShowS
$cshowList :: [CreateDataset] -> ShowS
show :: CreateDataset -> String
$cshow :: CreateDataset -> String
showsPrec :: Int -> CreateDataset -> ShowS
$cshowsPrec :: Int -> CreateDataset -> ShowS
Prelude.Show, forall x. Rep CreateDataset x -> CreateDataset
forall x. CreateDataset -> Rep CreateDataset x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateDataset x -> CreateDataset
$cfrom :: forall x. CreateDataset -> Rep CreateDataset x
Prelude.Generic)

-- |
-- Create a value of 'CreateDataset' 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:
--
-- 'contentDeliveryRules', 'createDataset_contentDeliveryRules' - When dataset contents are created, they are delivered to destinations
-- specified here.
--
-- 'lateDataRules', 'createDataset_lateDataRules' - A list of data rules that send notifications to CloudWatch, when data
-- arrives late. To specify @lateDataRules@, the dataset must use a
-- <https://docs.aws.amazon.com/iotanalytics/latest/APIReference/API_DeltaTime.html DeltaTimer>
-- filter.
--
-- 'retentionPeriod', 'createDataset_retentionPeriod' - Optional. How long, in days, versions of dataset contents are kept for
-- the dataset. If not specified or set to @null@, versions of dataset
-- contents are retained for at most 90 days. The number of versions of
-- dataset contents retained is determined by the @versioningConfiguration@
-- parameter. For more information, see
-- <https://docs.aws.amazon.com/iotanalytics/latest/userguide/getting-started.html#aws-iot-analytics-dataset-versions Keeping Multiple Versions of IoT Analytics datasets>
-- in the /IoT Analytics User Guide/.
--
-- 'tags', 'createDataset_tags' - Metadata which can be used to manage the dataset.
--
-- 'triggers', 'createDataset_triggers' - A list of triggers. A trigger causes dataset contents to be populated at
-- a specified time interval or when another dataset\'s contents are
-- created. The list of triggers can be empty or contain up to five
-- @DataSetTrigger@ objects.
--
-- 'versioningConfiguration', 'createDataset_versioningConfiguration' - Optional. How many versions of dataset contents are kept. If not
-- specified or set to null, only the latest version plus the latest
-- succeeded version (if they are different) are kept for the time period
-- specified by the @retentionPeriod@ parameter. For more information, see
-- <https://docs.aws.amazon.com/iotanalytics/latest/userguide/getting-started.html#aws-iot-analytics-dataset-versions Keeping Multiple Versions of IoT Analytics datasets>
-- in the /IoT Analytics User Guide/.
--
-- 'datasetName', 'createDataset_datasetName' - The name of the dataset.
--
-- 'actions', 'createDataset_actions' - A list of actions that create the dataset contents.
newCreateDataset ::
  -- | 'datasetName'
  Prelude.Text ->
  -- | 'actions'
  Prelude.NonEmpty DatasetAction ->
  CreateDataset
newCreateDataset :: Text -> NonEmpty DatasetAction -> CreateDataset
newCreateDataset Text
pDatasetName_ NonEmpty DatasetAction
pActions_ =
  CreateDataset'
    { $sel:contentDeliveryRules:CreateDataset' :: Maybe [DatasetContentDeliveryRule]
contentDeliveryRules =
        forall a. Maybe a
Prelude.Nothing,
      $sel:lateDataRules:CreateDataset' :: Maybe (NonEmpty LateDataRule)
lateDataRules = forall a. Maybe a
Prelude.Nothing,
      $sel:retentionPeriod:CreateDataset' :: Maybe RetentionPeriod
retentionPeriod = forall a. Maybe a
Prelude.Nothing,
      $sel:tags:CreateDataset' :: Maybe (NonEmpty Tag)
tags = forall a. Maybe a
Prelude.Nothing,
      $sel:triggers:CreateDataset' :: Maybe [DatasetTrigger]
triggers = forall a. Maybe a
Prelude.Nothing,
      $sel:versioningConfiguration:CreateDataset' :: Maybe VersioningConfiguration
versioningConfiguration = forall a. Maybe a
Prelude.Nothing,
      $sel:datasetName:CreateDataset' :: Text
datasetName = Text
pDatasetName_,
      $sel:actions:CreateDataset' :: NonEmpty DatasetAction
actions = 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 DatasetAction
pActions_
    }

-- | When dataset contents are created, they are delivered to destinations
-- specified here.
createDataset_contentDeliveryRules :: Lens.Lens' CreateDataset (Prelude.Maybe [DatasetContentDeliveryRule])
createDataset_contentDeliveryRules :: Lens' CreateDataset (Maybe [DatasetContentDeliveryRule])
createDataset_contentDeliveryRules = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateDataset' {Maybe [DatasetContentDeliveryRule]
contentDeliveryRules :: Maybe [DatasetContentDeliveryRule]
$sel:contentDeliveryRules:CreateDataset' :: CreateDataset -> Maybe [DatasetContentDeliveryRule]
contentDeliveryRules} -> Maybe [DatasetContentDeliveryRule]
contentDeliveryRules) (\s :: CreateDataset
s@CreateDataset' {} Maybe [DatasetContentDeliveryRule]
a -> CreateDataset
s {$sel:contentDeliveryRules:CreateDataset' :: Maybe [DatasetContentDeliveryRule]
contentDeliveryRules = Maybe [DatasetContentDeliveryRule]
a} :: CreateDataset) 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 data rules that send notifications to CloudWatch, when data
-- arrives late. To specify @lateDataRules@, the dataset must use a
-- <https://docs.aws.amazon.com/iotanalytics/latest/APIReference/API_DeltaTime.html DeltaTimer>
-- filter.
createDataset_lateDataRules :: Lens.Lens' CreateDataset (Prelude.Maybe (Prelude.NonEmpty LateDataRule))
createDataset_lateDataRules :: Lens' CreateDataset (Maybe (NonEmpty LateDataRule))
createDataset_lateDataRules = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateDataset' {Maybe (NonEmpty LateDataRule)
lateDataRules :: Maybe (NonEmpty LateDataRule)
$sel:lateDataRules:CreateDataset' :: CreateDataset -> Maybe (NonEmpty LateDataRule)
lateDataRules} -> Maybe (NonEmpty LateDataRule)
lateDataRules) (\s :: CreateDataset
s@CreateDataset' {} Maybe (NonEmpty LateDataRule)
a -> CreateDataset
s {$sel:lateDataRules:CreateDataset' :: Maybe (NonEmpty LateDataRule)
lateDataRules = Maybe (NonEmpty LateDataRule)
a} :: CreateDataset) 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

-- | Optional. How long, in days, versions of dataset contents are kept for
-- the dataset. If not specified or set to @null@, versions of dataset
-- contents are retained for at most 90 days. The number of versions of
-- dataset contents retained is determined by the @versioningConfiguration@
-- parameter. For more information, see
-- <https://docs.aws.amazon.com/iotanalytics/latest/userguide/getting-started.html#aws-iot-analytics-dataset-versions Keeping Multiple Versions of IoT Analytics datasets>
-- in the /IoT Analytics User Guide/.
createDataset_retentionPeriod :: Lens.Lens' CreateDataset (Prelude.Maybe RetentionPeriod)
createDataset_retentionPeriod :: Lens' CreateDataset (Maybe RetentionPeriod)
createDataset_retentionPeriod = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateDataset' {Maybe RetentionPeriod
retentionPeriod :: Maybe RetentionPeriod
$sel:retentionPeriod:CreateDataset' :: CreateDataset -> Maybe RetentionPeriod
retentionPeriod} -> Maybe RetentionPeriod
retentionPeriod) (\s :: CreateDataset
s@CreateDataset' {} Maybe RetentionPeriod
a -> CreateDataset
s {$sel:retentionPeriod:CreateDataset' :: Maybe RetentionPeriod
retentionPeriod = Maybe RetentionPeriod
a} :: CreateDataset)

-- | Metadata which can be used to manage the dataset.
createDataset_tags :: Lens.Lens' CreateDataset (Prelude.Maybe (Prelude.NonEmpty Tag))
createDataset_tags :: Lens' CreateDataset (Maybe (NonEmpty Tag))
createDataset_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateDataset' {Maybe (NonEmpty Tag)
tags :: Maybe (NonEmpty Tag)
$sel:tags:CreateDataset' :: CreateDataset -> Maybe (NonEmpty Tag)
tags} -> Maybe (NonEmpty Tag)
tags) (\s :: CreateDataset
s@CreateDataset' {} Maybe (NonEmpty Tag)
a -> CreateDataset
s {$sel:tags:CreateDataset' :: Maybe (NonEmpty Tag)
tags = Maybe (NonEmpty Tag)
a} :: CreateDataset) 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 triggers. A trigger causes dataset contents to be populated at
-- a specified time interval or when another dataset\'s contents are
-- created. The list of triggers can be empty or contain up to five
-- @DataSetTrigger@ objects.
createDataset_triggers :: Lens.Lens' CreateDataset (Prelude.Maybe [DatasetTrigger])
createDataset_triggers :: Lens' CreateDataset (Maybe [DatasetTrigger])
createDataset_triggers = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateDataset' {Maybe [DatasetTrigger]
triggers :: Maybe [DatasetTrigger]
$sel:triggers:CreateDataset' :: CreateDataset -> Maybe [DatasetTrigger]
triggers} -> Maybe [DatasetTrigger]
triggers) (\s :: CreateDataset
s@CreateDataset' {} Maybe [DatasetTrigger]
a -> CreateDataset
s {$sel:triggers:CreateDataset' :: Maybe [DatasetTrigger]
triggers = Maybe [DatasetTrigger]
a} :: CreateDataset) 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

-- | Optional. How many versions of dataset contents are kept. If not
-- specified or set to null, only the latest version plus the latest
-- succeeded version (if they are different) are kept for the time period
-- specified by the @retentionPeriod@ parameter. For more information, see
-- <https://docs.aws.amazon.com/iotanalytics/latest/userguide/getting-started.html#aws-iot-analytics-dataset-versions Keeping Multiple Versions of IoT Analytics datasets>
-- in the /IoT Analytics User Guide/.
createDataset_versioningConfiguration :: Lens.Lens' CreateDataset (Prelude.Maybe VersioningConfiguration)
createDataset_versioningConfiguration :: Lens' CreateDataset (Maybe VersioningConfiguration)
createDataset_versioningConfiguration = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateDataset' {Maybe VersioningConfiguration
versioningConfiguration :: Maybe VersioningConfiguration
$sel:versioningConfiguration:CreateDataset' :: CreateDataset -> Maybe VersioningConfiguration
versioningConfiguration} -> Maybe VersioningConfiguration
versioningConfiguration) (\s :: CreateDataset
s@CreateDataset' {} Maybe VersioningConfiguration
a -> CreateDataset
s {$sel:versioningConfiguration:CreateDataset' :: Maybe VersioningConfiguration
versioningConfiguration = Maybe VersioningConfiguration
a} :: CreateDataset)

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

-- | A list of actions that create the dataset contents.
createDataset_actions :: Lens.Lens' CreateDataset (Prelude.NonEmpty DatasetAction)
createDataset_actions :: Lens' CreateDataset (NonEmpty DatasetAction)
createDataset_actions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateDataset' {NonEmpty DatasetAction
actions :: NonEmpty DatasetAction
$sel:actions:CreateDataset' :: CreateDataset -> NonEmpty DatasetAction
actions} -> NonEmpty DatasetAction
actions) (\s :: CreateDataset
s@CreateDataset' {} NonEmpty DatasetAction
a -> CreateDataset
s {$sel:actions:CreateDataset' :: NonEmpty DatasetAction
actions = NonEmpty DatasetAction
a} :: CreateDataset) 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 CreateDataset where
  type
    AWSResponse CreateDataset =
      CreateDatasetResponse
  request :: (Service -> Service) -> CreateDataset -> Request CreateDataset
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 CreateDataset
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse CreateDataset)))
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
-> Maybe Text
-> Maybe RetentionPeriod
-> Int
-> CreateDatasetResponse
CreateDatasetResponse'
            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
"datasetArn")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"datasetName")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"retentionPeriod")
            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 CreateDataset where
  hashWithSalt :: Int -> CreateDataset -> Int
hashWithSalt Int
_salt CreateDataset' {Maybe [DatasetContentDeliveryRule]
Maybe [DatasetTrigger]
Maybe (NonEmpty LateDataRule)
Maybe (NonEmpty Tag)
Maybe RetentionPeriod
Maybe VersioningConfiguration
NonEmpty DatasetAction
Text
actions :: NonEmpty DatasetAction
datasetName :: Text
versioningConfiguration :: Maybe VersioningConfiguration
triggers :: Maybe [DatasetTrigger]
tags :: Maybe (NonEmpty Tag)
retentionPeriod :: Maybe RetentionPeriod
lateDataRules :: Maybe (NonEmpty LateDataRule)
contentDeliveryRules :: Maybe [DatasetContentDeliveryRule]
$sel:actions:CreateDataset' :: CreateDataset -> NonEmpty DatasetAction
$sel:datasetName:CreateDataset' :: CreateDataset -> Text
$sel:versioningConfiguration:CreateDataset' :: CreateDataset -> Maybe VersioningConfiguration
$sel:triggers:CreateDataset' :: CreateDataset -> Maybe [DatasetTrigger]
$sel:tags:CreateDataset' :: CreateDataset -> Maybe (NonEmpty Tag)
$sel:retentionPeriod:CreateDataset' :: CreateDataset -> Maybe RetentionPeriod
$sel:lateDataRules:CreateDataset' :: CreateDataset -> Maybe (NonEmpty LateDataRule)
$sel:contentDeliveryRules:CreateDataset' :: CreateDataset -> Maybe [DatasetContentDeliveryRule]
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [DatasetContentDeliveryRule]
contentDeliveryRules
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (NonEmpty LateDataRule)
lateDataRules
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe RetentionPeriod
retentionPeriod
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (NonEmpty Tag)
tags
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [DatasetTrigger]
triggers
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe VersioningConfiguration
versioningConfiguration
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
datasetName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` NonEmpty DatasetAction
actions

instance Prelude.NFData CreateDataset where
  rnf :: CreateDataset -> ()
rnf CreateDataset' {Maybe [DatasetContentDeliveryRule]
Maybe [DatasetTrigger]
Maybe (NonEmpty LateDataRule)
Maybe (NonEmpty Tag)
Maybe RetentionPeriod
Maybe VersioningConfiguration
NonEmpty DatasetAction
Text
actions :: NonEmpty DatasetAction
datasetName :: Text
versioningConfiguration :: Maybe VersioningConfiguration
triggers :: Maybe [DatasetTrigger]
tags :: Maybe (NonEmpty Tag)
retentionPeriod :: Maybe RetentionPeriod
lateDataRules :: Maybe (NonEmpty LateDataRule)
contentDeliveryRules :: Maybe [DatasetContentDeliveryRule]
$sel:actions:CreateDataset' :: CreateDataset -> NonEmpty DatasetAction
$sel:datasetName:CreateDataset' :: CreateDataset -> Text
$sel:versioningConfiguration:CreateDataset' :: CreateDataset -> Maybe VersioningConfiguration
$sel:triggers:CreateDataset' :: CreateDataset -> Maybe [DatasetTrigger]
$sel:tags:CreateDataset' :: CreateDataset -> Maybe (NonEmpty Tag)
$sel:retentionPeriod:CreateDataset' :: CreateDataset -> Maybe RetentionPeriod
$sel:lateDataRules:CreateDataset' :: CreateDataset -> Maybe (NonEmpty LateDataRule)
$sel:contentDeliveryRules:CreateDataset' :: CreateDataset -> Maybe [DatasetContentDeliveryRule]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [DatasetContentDeliveryRule]
contentDeliveryRules
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe (NonEmpty LateDataRule)
lateDataRules
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe RetentionPeriod
retentionPeriod
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe (NonEmpty Tag)
tags
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [DatasetTrigger]
triggers
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe VersioningConfiguration
versioningConfiguration
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
datasetName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf NonEmpty DatasetAction
actions

instance Data.ToHeaders CreateDataset where
  toHeaders :: CreateDataset -> ResponseHeaders
toHeaders = forall a b. a -> b -> a
Prelude.const forall a. Monoid a => a
Prelude.mempty

instance Data.ToJSON CreateDataset where
  toJSON :: CreateDataset -> Value
toJSON CreateDataset' {Maybe [DatasetContentDeliveryRule]
Maybe [DatasetTrigger]
Maybe (NonEmpty LateDataRule)
Maybe (NonEmpty Tag)
Maybe RetentionPeriod
Maybe VersioningConfiguration
NonEmpty DatasetAction
Text
actions :: NonEmpty DatasetAction
datasetName :: Text
versioningConfiguration :: Maybe VersioningConfiguration
triggers :: Maybe [DatasetTrigger]
tags :: Maybe (NonEmpty Tag)
retentionPeriod :: Maybe RetentionPeriod
lateDataRules :: Maybe (NonEmpty LateDataRule)
contentDeliveryRules :: Maybe [DatasetContentDeliveryRule]
$sel:actions:CreateDataset' :: CreateDataset -> NonEmpty DatasetAction
$sel:datasetName:CreateDataset' :: CreateDataset -> Text
$sel:versioningConfiguration:CreateDataset' :: CreateDataset -> Maybe VersioningConfiguration
$sel:triggers:CreateDataset' :: CreateDataset -> Maybe [DatasetTrigger]
$sel:tags:CreateDataset' :: CreateDataset -> Maybe (NonEmpty Tag)
$sel:retentionPeriod:CreateDataset' :: CreateDataset -> Maybe RetentionPeriod
$sel:lateDataRules:CreateDataset' :: CreateDataset -> Maybe (NonEmpty LateDataRule)
$sel:contentDeliveryRules:CreateDataset' :: CreateDataset -> Maybe [DatasetContentDeliveryRule]
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"contentDeliveryRules" 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 [DatasetContentDeliveryRule]
contentDeliveryRules,
            (Key
"lateDataRules" 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 LateDataRule)
lateDataRules,
            (Key
"retentionPeriod" 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 RetentionPeriod
retentionPeriod,
            (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 (NonEmpty Tag)
tags,
            (Key
"triggers" 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 [DatasetTrigger]
triggers,
            (Key
"versioningConfiguration" 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 VersioningConfiguration
versioningConfiguration,
            forall a. a -> Maybe a
Prelude.Just (Key
"datasetName" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
datasetName),
            forall a. a -> Maybe a
Prelude.Just (Key
"actions" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= NonEmpty DatasetAction
actions)
          ]
      )

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

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

-- | /See:/ 'newCreateDatasetResponse' smart constructor.
data CreateDatasetResponse = CreateDatasetResponse'
  { -- | The ARN of the dataset.
    CreateDatasetResponse -> Maybe Text
datasetArn :: Prelude.Maybe Prelude.Text,
    -- | The name of the dataset.
    CreateDatasetResponse -> Maybe Text
datasetName :: Prelude.Maybe Prelude.Text,
    -- | How long, in days, dataset contents are kept for the dataset.
    CreateDatasetResponse -> Maybe RetentionPeriod
retentionPeriod :: Prelude.Maybe RetentionPeriod,
    -- | The response's http status code.
    CreateDatasetResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (CreateDatasetResponse -> CreateDatasetResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateDatasetResponse -> CreateDatasetResponse -> Bool
$c/= :: CreateDatasetResponse -> CreateDatasetResponse -> Bool
== :: CreateDatasetResponse -> CreateDatasetResponse -> Bool
$c== :: CreateDatasetResponse -> CreateDatasetResponse -> Bool
Prelude.Eq, ReadPrec [CreateDatasetResponse]
ReadPrec CreateDatasetResponse
Int -> ReadS CreateDatasetResponse
ReadS [CreateDatasetResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateDatasetResponse]
$creadListPrec :: ReadPrec [CreateDatasetResponse]
readPrec :: ReadPrec CreateDatasetResponse
$creadPrec :: ReadPrec CreateDatasetResponse
readList :: ReadS [CreateDatasetResponse]
$creadList :: ReadS [CreateDatasetResponse]
readsPrec :: Int -> ReadS CreateDatasetResponse
$creadsPrec :: Int -> ReadS CreateDatasetResponse
Prelude.Read, Int -> CreateDatasetResponse -> ShowS
[CreateDatasetResponse] -> ShowS
CreateDatasetResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateDatasetResponse] -> ShowS
$cshowList :: [CreateDatasetResponse] -> ShowS
show :: CreateDatasetResponse -> String
$cshow :: CreateDatasetResponse -> String
showsPrec :: Int -> CreateDatasetResponse -> ShowS
$cshowsPrec :: Int -> CreateDatasetResponse -> ShowS
Prelude.Show, forall x. Rep CreateDatasetResponse x -> CreateDatasetResponse
forall x. CreateDatasetResponse -> Rep CreateDatasetResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateDatasetResponse x -> CreateDatasetResponse
$cfrom :: forall x. CreateDatasetResponse -> Rep CreateDatasetResponse x
Prelude.Generic)

-- |
-- Create a value of 'CreateDatasetResponse' 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:
--
-- 'datasetArn', 'createDatasetResponse_datasetArn' - The ARN of the dataset.
--
-- 'datasetName', 'createDatasetResponse_datasetName' - The name of the dataset.
--
-- 'retentionPeriod', 'createDatasetResponse_retentionPeriod' - How long, in days, dataset contents are kept for the dataset.
--
-- 'httpStatus', 'createDatasetResponse_httpStatus' - The response's http status code.
newCreateDatasetResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  CreateDatasetResponse
newCreateDatasetResponse :: Int -> CreateDatasetResponse
newCreateDatasetResponse Int
pHttpStatus_ =
  CreateDatasetResponse'
    { $sel:datasetArn:CreateDatasetResponse' :: Maybe Text
datasetArn =
        forall a. Maybe a
Prelude.Nothing,
      $sel:datasetName:CreateDatasetResponse' :: Maybe Text
datasetName = forall a. Maybe a
Prelude.Nothing,
      $sel:retentionPeriod:CreateDatasetResponse' :: Maybe RetentionPeriod
retentionPeriod = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:CreateDatasetResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

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

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

-- | How long, in days, dataset contents are kept for the dataset.
createDatasetResponse_retentionPeriod :: Lens.Lens' CreateDatasetResponse (Prelude.Maybe RetentionPeriod)
createDatasetResponse_retentionPeriod :: Lens' CreateDatasetResponse (Maybe RetentionPeriod)
createDatasetResponse_retentionPeriod = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateDatasetResponse' {Maybe RetentionPeriod
retentionPeriod :: Maybe RetentionPeriod
$sel:retentionPeriod:CreateDatasetResponse' :: CreateDatasetResponse -> Maybe RetentionPeriod
retentionPeriod} -> Maybe RetentionPeriod
retentionPeriod) (\s :: CreateDatasetResponse
s@CreateDatasetResponse' {} Maybe RetentionPeriod
a -> CreateDatasetResponse
s {$sel:retentionPeriod:CreateDatasetResponse' :: Maybe RetentionPeriod
retentionPeriod = Maybe RetentionPeriod
a} :: CreateDatasetResponse)

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

instance Prelude.NFData CreateDatasetResponse where
  rnf :: CreateDatasetResponse -> ()
rnf CreateDatasetResponse' {Int
Maybe Text
Maybe RetentionPeriod
httpStatus :: Int
retentionPeriod :: Maybe RetentionPeriod
datasetName :: Maybe Text
datasetArn :: Maybe Text
$sel:httpStatus:CreateDatasetResponse' :: CreateDatasetResponse -> Int
$sel:retentionPeriod:CreateDatasetResponse' :: CreateDatasetResponse -> Maybe RetentionPeriod
$sel:datasetName:CreateDatasetResponse' :: CreateDatasetResponse -> Maybe Text
$sel:datasetArn:CreateDatasetResponse' :: CreateDatasetResponse -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
datasetArn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
datasetName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe RetentionPeriod
retentionPeriod
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus