{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
{-# OPTIONS_GHC -fno-warn-unused-matches #-}

-- Derived from AWS service descriptions, licensed under Apache 2.0.

-- |
-- Module      : Amazonka.DataBrew.Types.Dataset
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
module Amazonka.DataBrew.Types.Dataset where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import Amazonka.DataBrew.Types.FormatOptions
import Amazonka.DataBrew.Types.Input
import Amazonka.DataBrew.Types.InputFormat
import Amazonka.DataBrew.Types.PathOptions
import Amazonka.DataBrew.Types.Source
import qualified Amazonka.Prelude as Prelude

-- | Represents a dataset that can be processed by DataBrew.
--
-- /See:/ 'newDataset' smart constructor.
data Dataset = Dataset'
  { -- | The ID of the Amazon Web Services account that owns the dataset.
    Dataset -> Maybe Text
accountId :: Prelude.Maybe Prelude.Text,
    -- | The date and time that the dataset was created.
    Dataset -> Maybe POSIX
createDate :: Prelude.Maybe Data.POSIX,
    -- | The Amazon Resource Name (ARN) of the user who created the dataset.
    Dataset -> Maybe Text
createdBy :: Prelude.Maybe Prelude.Text,
    -- | The file format of a dataset that is created from an Amazon S3 file or
    -- folder.
    Dataset -> Maybe InputFormat
format :: Prelude.Maybe InputFormat,
    -- | A set of options that define how DataBrew interprets the data in the
    -- dataset.
    Dataset -> Maybe FormatOptions
formatOptions :: Prelude.Maybe FormatOptions,
    -- | The Amazon Resource Name (ARN) of the user who last modified the
    -- dataset.
    Dataset -> Maybe Text
lastModifiedBy :: Prelude.Maybe Prelude.Text,
    -- | The last modification date and time of the dataset.
    Dataset -> Maybe POSIX
lastModifiedDate :: Prelude.Maybe Data.POSIX,
    -- | A set of options that defines how DataBrew interprets an Amazon S3 path
    -- of the dataset.
    Dataset -> Maybe PathOptions
pathOptions :: Prelude.Maybe PathOptions,
    -- | The unique Amazon Resource Name (ARN) for the dataset.
    Dataset -> Maybe Text
resourceArn :: Prelude.Maybe Prelude.Text,
    -- | The location of the data for the dataset, either Amazon S3 or the Glue
    -- Data Catalog.
    Dataset -> Maybe Source
source :: Prelude.Maybe Source,
    -- | Metadata tags that have been applied to the dataset.
    Dataset -> Maybe (HashMap Text Text)
tags :: Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text),
    -- | The unique name of the dataset.
    Dataset -> Text
name :: Prelude.Text,
    -- | Information on how DataBrew can find the dataset, in either the Glue
    -- Data Catalog or Amazon S3.
    Dataset -> Input
input :: Input
  }
  deriving (Dataset -> Dataset -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Dataset -> Dataset -> Bool
$c/= :: Dataset -> Dataset -> Bool
== :: Dataset -> Dataset -> Bool
$c== :: Dataset -> Dataset -> Bool
Prelude.Eq, ReadPrec [Dataset]
ReadPrec Dataset
Int -> ReadS Dataset
ReadS [Dataset]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Dataset]
$creadListPrec :: ReadPrec [Dataset]
readPrec :: ReadPrec Dataset
$creadPrec :: ReadPrec Dataset
readList :: ReadS [Dataset]
$creadList :: ReadS [Dataset]
readsPrec :: Int -> ReadS Dataset
$creadsPrec :: Int -> ReadS Dataset
Prelude.Read, Int -> Dataset -> ShowS
[Dataset] -> ShowS
Dataset -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Dataset] -> ShowS
$cshowList :: [Dataset] -> ShowS
show :: Dataset -> String
$cshow :: Dataset -> String
showsPrec :: Int -> Dataset -> ShowS
$cshowsPrec :: Int -> Dataset -> ShowS
Prelude.Show, forall x. Rep Dataset x -> Dataset
forall x. Dataset -> Rep Dataset x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Dataset x -> Dataset
$cfrom :: forall x. Dataset -> Rep Dataset x
Prelude.Generic)

-- |
-- Create a value of 'Dataset' 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:
--
-- 'accountId', 'dataset_accountId' - The ID of the Amazon Web Services account that owns the dataset.
--
-- 'createDate', 'dataset_createDate' - The date and time that the dataset was created.
--
-- 'createdBy', 'dataset_createdBy' - The Amazon Resource Name (ARN) of the user who created the dataset.
--
-- 'format', 'dataset_format' - The file format of a dataset that is created from an Amazon S3 file or
-- folder.
--
-- 'formatOptions', 'dataset_formatOptions' - A set of options that define how DataBrew interprets the data in the
-- dataset.
--
-- 'lastModifiedBy', 'dataset_lastModifiedBy' - The Amazon Resource Name (ARN) of the user who last modified the
-- dataset.
--
-- 'lastModifiedDate', 'dataset_lastModifiedDate' - The last modification date and time of the dataset.
--
-- 'pathOptions', 'dataset_pathOptions' - A set of options that defines how DataBrew interprets an Amazon S3 path
-- of the dataset.
--
-- 'resourceArn', 'dataset_resourceArn' - The unique Amazon Resource Name (ARN) for the dataset.
--
-- 'source', 'dataset_source' - The location of the data for the dataset, either Amazon S3 or the Glue
-- Data Catalog.
--
-- 'tags', 'dataset_tags' - Metadata tags that have been applied to the dataset.
--
-- 'name', 'dataset_name' - The unique name of the dataset.
--
-- 'input', 'dataset_input' - Information on how DataBrew can find the dataset, in either the Glue
-- Data Catalog or Amazon S3.
newDataset ::
  -- | 'name'
  Prelude.Text ->
  -- | 'input'
  Input ->
  Dataset
newDataset :: Text -> Input -> Dataset
newDataset Text
pName_ Input
pInput_ =
  Dataset'
    { $sel:accountId:Dataset' :: Maybe Text
accountId = forall a. Maybe a
Prelude.Nothing,
      $sel:createDate:Dataset' :: Maybe POSIX
createDate = forall a. Maybe a
Prelude.Nothing,
      $sel:createdBy:Dataset' :: Maybe Text
createdBy = forall a. Maybe a
Prelude.Nothing,
      $sel:format:Dataset' :: Maybe InputFormat
format = forall a. Maybe a
Prelude.Nothing,
      $sel:formatOptions:Dataset' :: Maybe FormatOptions
formatOptions = forall a. Maybe a
Prelude.Nothing,
      $sel:lastModifiedBy:Dataset' :: Maybe Text
lastModifiedBy = forall a. Maybe a
Prelude.Nothing,
      $sel:lastModifiedDate:Dataset' :: Maybe POSIX
lastModifiedDate = forall a. Maybe a
Prelude.Nothing,
      $sel:pathOptions:Dataset' :: Maybe PathOptions
pathOptions = forall a. Maybe a
Prelude.Nothing,
      $sel:resourceArn:Dataset' :: Maybe Text
resourceArn = forall a. Maybe a
Prelude.Nothing,
      $sel:source:Dataset' :: Maybe Source
source = forall a. Maybe a
Prelude.Nothing,
      $sel:tags:Dataset' :: Maybe (HashMap Text Text)
tags = forall a. Maybe a
Prelude.Nothing,
      $sel:name:Dataset' :: Text
name = Text
pName_,
      $sel:input:Dataset' :: Input
input = Input
pInput_
    }

-- | The ID of the Amazon Web Services account that owns the dataset.
dataset_accountId :: Lens.Lens' Dataset (Prelude.Maybe Prelude.Text)
dataset_accountId :: Lens' Dataset (Maybe Text)
dataset_accountId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Dataset' {Maybe Text
accountId :: Maybe Text
$sel:accountId:Dataset' :: Dataset -> Maybe Text
accountId} -> Maybe Text
accountId) (\s :: Dataset
s@Dataset' {} Maybe Text
a -> Dataset
s {$sel:accountId:Dataset' :: Maybe Text
accountId = Maybe Text
a} :: Dataset)

-- | The date and time that the dataset was created.
dataset_createDate :: Lens.Lens' Dataset (Prelude.Maybe Prelude.UTCTime)
dataset_createDate :: Lens' Dataset (Maybe UTCTime)
dataset_createDate = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Dataset' {Maybe POSIX
createDate :: Maybe POSIX
$sel:createDate:Dataset' :: Dataset -> Maybe POSIX
createDate} -> Maybe POSIX
createDate) (\s :: Dataset
s@Dataset' {} Maybe POSIX
a -> Dataset
s {$sel:createDate:Dataset' :: Maybe POSIX
createDate = Maybe POSIX
a} :: Dataset) 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 (a :: Format). Iso' (Time a) UTCTime
Data._Time

-- | The Amazon Resource Name (ARN) of the user who created the dataset.
dataset_createdBy :: Lens.Lens' Dataset (Prelude.Maybe Prelude.Text)
dataset_createdBy :: Lens' Dataset (Maybe Text)
dataset_createdBy = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Dataset' {Maybe Text
createdBy :: Maybe Text
$sel:createdBy:Dataset' :: Dataset -> Maybe Text
createdBy} -> Maybe Text
createdBy) (\s :: Dataset
s@Dataset' {} Maybe Text
a -> Dataset
s {$sel:createdBy:Dataset' :: Maybe Text
createdBy = Maybe Text
a} :: Dataset)

-- | The file format of a dataset that is created from an Amazon S3 file or
-- folder.
dataset_format :: Lens.Lens' Dataset (Prelude.Maybe InputFormat)
dataset_format :: Lens' Dataset (Maybe InputFormat)
dataset_format = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Dataset' {Maybe InputFormat
format :: Maybe InputFormat
$sel:format:Dataset' :: Dataset -> Maybe InputFormat
format} -> Maybe InputFormat
format) (\s :: Dataset
s@Dataset' {} Maybe InputFormat
a -> Dataset
s {$sel:format:Dataset' :: Maybe InputFormat
format = Maybe InputFormat
a} :: Dataset)

-- | A set of options that define how DataBrew interprets the data in the
-- dataset.
dataset_formatOptions :: Lens.Lens' Dataset (Prelude.Maybe FormatOptions)
dataset_formatOptions :: Lens' Dataset (Maybe FormatOptions)
dataset_formatOptions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Dataset' {Maybe FormatOptions
formatOptions :: Maybe FormatOptions
$sel:formatOptions:Dataset' :: Dataset -> Maybe FormatOptions
formatOptions} -> Maybe FormatOptions
formatOptions) (\s :: Dataset
s@Dataset' {} Maybe FormatOptions
a -> Dataset
s {$sel:formatOptions:Dataset' :: Maybe FormatOptions
formatOptions = Maybe FormatOptions
a} :: Dataset)

-- | The Amazon Resource Name (ARN) of the user who last modified the
-- dataset.
dataset_lastModifiedBy :: Lens.Lens' Dataset (Prelude.Maybe Prelude.Text)
dataset_lastModifiedBy :: Lens' Dataset (Maybe Text)
dataset_lastModifiedBy = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Dataset' {Maybe Text
lastModifiedBy :: Maybe Text
$sel:lastModifiedBy:Dataset' :: Dataset -> Maybe Text
lastModifiedBy} -> Maybe Text
lastModifiedBy) (\s :: Dataset
s@Dataset' {} Maybe Text
a -> Dataset
s {$sel:lastModifiedBy:Dataset' :: Maybe Text
lastModifiedBy = Maybe Text
a} :: Dataset)

-- | The last modification date and time of the dataset.
dataset_lastModifiedDate :: Lens.Lens' Dataset (Prelude.Maybe Prelude.UTCTime)
dataset_lastModifiedDate :: Lens' Dataset (Maybe UTCTime)
dataset_lastModifiedDate = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Dataset' {Maybe POSIX
lastModifiedDate :: Maybe POSIX
$sel:lastModifiedDate:Dataset' :: Dataset -> Maybe POSIX
lastModifiedDate} -> Maybe POSIX
lastModifiedDate) (\s :: Dataset
s@Dataset' {} Maybe POSIX
a -> Dataset
s {$sel:lastModifiedDate:Dataset' :: Maybe POSIX
lastModifiedDate = Maybe POSIX
a} :: Dataset) 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 (a :: Format). Iso' (Time a) UTCTime
Data._Time

-- | A set of options that defines how DataBrew interprets an Amazon S3 path
-- of the dataset.
dataset_pathOptions :: Lens.Lens' Dataset (Prelude.Maybe PathOptions)
dataset_pathOptions :: Lens' Dataset (Maybe PathOptions)
dataset_pathOptions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Dataset' {Maybe PathOptions
pathOptions :: Maybe PathOptions
$sel:pathOptions:Dataset' :: Dataset -> Maybe PathOptions
pathOptions} -> Maybe PathOptions
pathOptions) (\s :: Dataset
s@Dataset' {} Maybe PathOptions
a -> Dataset
s {$sel:pathOptions:Dataset' :: Maybe PathOptions
pathOptions = Maybe PathOptions
a} :: Dataset)

-- | The unique Amazon Resource Name (ARN) for the dataset.
dataset_resourceArn :: Lens.Lens' Dataset (Prelude.Maybe Prelude.Text)
dataset_resourceArn :: Lens' Dataset (Maybe Text)
dataset_resourceArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Dataset' {Maybe Text
resourceArn :: Maybe Text
$sel:resourceArn:Dataset' :: Dataset -> Maybe Text
resourceArn} -> Maybe Text
resourceArn) (\s :: Dataset
s@Dataset' {} Maybe Text
a -> Dataset
s {$sel:resourceArn:Dataset' :: Maybe Text
resourceArn = Maybe Text
a} :: Dataset)

-- | The location of the data for the dataset, either Amazon S3 or the Glue
-- Data Catalog.
dataset_source :: Lens.Lens' Dataset (Prelude.Maybe Source)
dataset_source :: Lens' Dataset (Maybe Source)
dataset_source = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Dataset' {Maybe Source
source :: Maybe Source
$sel:source:Dataset' :: Dataset -> Maybe Source
source} -> Maybe Source
source) (\s :: Dataset
s@Dataset' {} Maybe Source
a -> Dataset
s {$sel:source:Dataset' :: Maybe Source
source = Maybe Source
a} :: Dataset)

-- | Metadata tags that have been applied to the dataset.
dataset_tags :: Lens.Lens' Dataset (Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text))
dataset_tags :: Lens' Dataset (Maybe (HashMap Text Text))
dataset_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Dataset' {Maybe (HashMap Text Text)
tags :: Maybe (HashMap Text Text)
$sel:tags:Dataset' :: Dataset -> Maybe (HashMap Text Text)
tags} -> Maybe (HashMap Text Text)
tags) (\s :: Dataset
s@Dataset' {} Maybe (HashMap Text Text)
a -> Dataset
s {$sel:tags:Dataset' :: Maybe (HashMap Text Text)
tags = Maybe (HashMap Text Text)
a} :: Dataset) 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

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

-- | Information on how DataBrew can find the dataset, in either the Glue
-- Data Catalog or Amazon S3.
dataset_input :: Lens.Lens' Dataset Input
dataset_input :: Lens' Dataset Input
dataset_input = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Dataset' {Input
input :: Input
$sel:input:Dataset' :: Dataset -> Input
input} -> Input
input) (\s :: Dataset
s@Dataset' {} Input
a -> Dataset
s {$sel:input:Dataset' :: Input
input = Input
a} :: Dataset)

instance Data.FromJSON Dataset where
  parseJSON :: Value -> Parser Dataset
parseJSON =
    forall a. String -> (Object -> Parser a) -> Value -> Parser a
Data.withObject
      String
"Dataset"
      ( \Object
x ->
          Maybe Text
-> Maybe POSIX
-> Maybe Text
-> Maybe InputFormat
-> Maybe FormatOptions
-> Maybe Text
-> Maybe POSIX
-> Maybe PathOptions
-> Maybe Text
-> Maybe Source
-> Maybe (HashMap Text Text)
-> Text
-> Input
-> Dataset
Dataset'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"AccountId")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"CreateDate")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"CreatedBy")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"Format")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"FormatOptions")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"LastModifiedBy")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"LastModifiedDate")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"PathOptions")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"ResourceArn")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"Source")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"Tags" forall a. Parser (Maybe a) -> a -> Parser a
Data..!= forall a. Monoid a => a
Prelude.mempty)
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser a
Data..: Key
"Name")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser a
Data..: Key
"Input")
      )

instance Prelude.Hashable Dataset where
  hashWithSalt :: Int -> Dataset -> Int
hashWithSalt Int
_salt Dataset' {Maybe Text
Maybe (HashMap Text Text)
Maybe POSIX
Maybe InputFormat
Maybe FormatOptions
Maybe PathOptions
Maybe Source
Text
Input
input :: Input
name :: Text
tags :: Maybe (HashMap Text Text)
source :: Maybe Source
resourceArn :: Maybe Text
pathOptions :: Maybe PathOptions
lastModifiedDate :: Maybe POSIX
lastModifiedBy :: Maybe Text
formatOptions :: Maybe FormatOptions
format :: Maybe InputFormat
createdBy :: Maybe Text
createDate :: Maybe POSIX
accountId :: Maybe Text
$sel:input:Dataset' :: Dataset -> Input
$sel:name:Dataset' :: Dataset -> Text
$sel:tags:Dataset' :: Dataset -> Maybe (HashMap Text Text)
$sel:source:Dataset' :: Dataset -> Maybe Source
$sel:resourceArn:Dataset' :: Dataset -> Maybe Text
$sel:pathOptions:Dataset' :: Dataset -> Maybe PathOptions
$sel:lastModifiedDate:Dataset' :: Dataset -> Maybe POSIX
$sel:lastModifiedBy:Dataset' :: Dataset -> Maybe Text
$sel:formatOptions:Dataset' :: Dataset -> Maybe FormatOptions
$sel:format:Dataset' :: Dataset -> Maybe InputFormat
$sel:createdBy:Dataset' :: Dataset -> Maybe Text
$sel:createDate:Dataset' :: Dataset -> Maybe POSIX
$sel:accountId:Dataset' :: Dataset -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
accountId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe POSIX
createDate
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
createdBy
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe InputFormat
format
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe FormatOptions
formatOptions
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
lastModifiedBy
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe POSIX
lastModifiedDate
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe PathOptions
pathOptions
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
resourceArn
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Source
source
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (HashMap Text Text)
tags
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
name
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Input
input

instance Prelude.NFData Dataset where
  rnf :: Dataset -> ()
rnf Dataset' {Maybe Text
Maybe (HashMap Text Text)
Maybe POSIX
Maybe InputFormat
Maybe FormatOptions
Maybe PathOptions
Maybe Source
Text
Input
input :: Input
name :: Text
tags :: Maybe (HashMap Text Text)
source :: Maybe Source
resourceArn :: Maybe Text
pathOptions :: Maybe PathOptions
lastModifiedDate :: Maybe POSIX
lastModifiedBy :: Maybe Text
formatOptions :: Maybe FormatOptions
format :: Maybe InputFormat
createdBy :: Maybe Text
createDate :: Maybe POSIX
accountId :: Maybe Text
$sel:input:Dataset' :: Dataset -> Input
$sel:name:Dataset' :: Dataset -> Text
$sel:tags:Dataset' :: Dataset -> Maybe (HashMap Text Text)
$sel:source:Dataset' :: Dataset -> Maybe Source
$sel:resourceArn:Dataset' :: Dataset -> Maybe Text
$sel:pathOptions:Dataset' :: Dataset -> Maybe PathOptions
$sel:lastModifiedDate:Dataset' :: Dataset -> Maybe POSIX
$sel:lastModifiedBy:Dataset' :: Dataset -> Maybe Text
$sel:formatOptions:Dataset' :: Dataset -> Maybe FormatOptions
$sel:format:Dataset' :: Dataset -> Maybe InputFormat
$sel:createdBy:Dataset' :: Dataset -> Maybe Text
$sel:createDate:Dataset' :: Dataset -> Maybe POSIX
$sel:accountId:Dataset' :: Dataset -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
accountId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe POSIX
createDate
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
createdBy
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe InputFormat
format
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe FormatOptions
formatOptions
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
lastModifiedBy
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe POSIX
lastModifiedDate
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe PathOptions
pathOptions
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
resourceArn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Source
source
      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 Text
name
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Input
input