{-# 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.KinesisAnalytics.Types.InputDescription
-- 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.KinesisAnalytics.Types.InputDescription where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import Amazonka.KinesisAnalytics.Types.InputParallelism
import Amazonka.KinesisAnalytics.Types.InputProcessingConfigurationDescription
import Amazonka.KinesisAnalytics.Types.InputStartingPositionConfiguration
import Amazonka.KinesisAnalytics.Types.KinesisFirehoseInputDescription
import Amazonka.KinesisAnalytics.Types.KinesisStreamsInputDescription
import Amazonka.KinesisAnalytics.Types.SourceSchema
import qualified Amazonka.Prelude as Prelude

-- | Describes the application input configuration. For more information, see
-- <https://docs.aws.amazon.com/kinesisanalytics/latest/dev/how-it-works-input.html Configuring Application Input>.
--
-- /See:/ 'newInputDescription' smart constructor.
data InputDescription = InputDescription'
  { -- | Returns the in-application stream names that are mapped to the stream
    -- source.
    InputDescription -> Maybe [Text]
inAppStreamNames :: Prelude.Maybe [Prelude.Text],
    -- | Input ID associated with the application input. This is the ID that
    -- Amazon Kinesis Analytics assigns to each input configuration you add to
    -- your application.
    InputDescription -> Maybe Text
inputId :: Prelude.Maybe Prelude.Text,
    -- | Describes the configured parallelism (number of in-application streams
    -- mapped to the streaming source).
    InputDescription -> Maybe InputParallelism
inputParallelism :: Prelude.Maybe InputParallelism,
    -- | The description of the preprocessor that executes on records in this
    -- input before the application\'s code is run.
    InputDescription -> Maybe InputProcessingConfigurationDescription
inputProcessingConfigurationDescription :: Prelude.Maybe InputProcessingConfigurationDescription,
    -- | Describes the format of the data in the streaming source, and how each
    -- data element maps to corresponding columns in the in-application stream
    -- that is being created.
    InputDescription -> Maybe SourceSchema
inputSchema :: Prelude.Maybe SourceSchema,
    -- | Point at which the application is configured to read from the input
    -- stream.
    InputDescription -> Maybe InputStartingPositionConfiguration
inputStartingPositionConfiguration :: Prelude.Maybe InputStartingPositionConfiguration,
    -- | If an Amazon Kinesis Firehose delivery stream is configured as a
    -- streaming source, provides the delivery stream\'s ARN and an IAM role
    -- that enables Amazon Kinesis Analytics to access the stream on your
    -- behalf.
    InputDescription -> Maybe KinesisFirehoseInputDescription
kinesisFirehoseInputDescription :: Prelude.Maybe KinesisFirehoseInputDescription,
    -- | If an Amazon Kinesis stream is configured as streaming source, provides
    -- Amazon Kinesis stream\'s Amazon Resource Name (ARN) and an IAM role that
    -- enables Amazon Kinesis Analytics to access the stream on your behalf.
    InputDescription -> Maybe KinesisStreamsInputDescription
kinesisStreamsInputDescription :: Prelude.Maybe KinesisStreamsInputDescription,
    -- | In-application name prefix.
    InputDescription -> Maybe Text
namePrefix :: Prelude.Maybe Prelude.Text
  }
  deriving (InputDescription -> InputDescription -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: InputDescription -> InputDescription -> Bool
$c/= :: InputDescription -> InputDescription -> Bool
== :: InputDescription -> InputDescription -> Bool
$c== :: InputDescription -> InputDescription -> Bool
Prelude.Eq, ReadPrec [InputDescription]
ReadPrec InputDescription
Int -> ReadS InputDescription
ReadS [InputDescription]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [InputDescription]
$creadListPrec :: ReadPrec [InputDescription]
readPrec :: ReadPrec InputDescription
$creadPrec :: ReadPrec InputDescription
readList :: ReadS [InputDescription]
$creadList :: ReadS [InputDescription]
readsPrec :: Int -> ReadS InputDescription
$creadsPrec :: Int -> ReadS InputDescription
Prelude.Read, Int -> InputDescription -> ShowS
[InputDescription] -> ShowS
InputDescription -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [InputDescription] -> ShowS
$cshowList :: [InputDescription] -> ShowS
show :: InputDescription -> String
$cshow :: InputDescription -> String
showsPrec :: Int -> InputDescription -> ShowS
$cshowsPrec :: Int -> InputDescription -> ShowS
Prelude.Show, forall x. Rep InputDescription x -> InputDescription
forall x. InputDescription -> Rep InputDescription x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep InputDescription x -> InputDescription
$cfrom :: forall x. InputDescription -> Rep InputDescription x
Prelude.Generic)

-- |
-- Create a value of 'InputDescription' 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:
--
-- 'inAppStreamNames', 'inputDescription_inAppStreamNames' - Returns the in-application stream names that are mapped to the stream
-- source.
--
-- 'inputId', 'inputDescription_inputId' - Input ID associated with the application input. This is the ID that
-- Amazon Kinesis Analytics assigns to each input configuration you add to
-- your application.
--
-- 'inputParallelism', 'inputDescription_inputParallelism' - Describes the configured parallelism (number of in-application streams
-- mapped to the streaming source).
--
-- 'inputProcessingConfigurationDescription', 'inputDescription_inputProcessingConfigurationDescription' - The description of the preprocessor that executes on records in this
-- input before the application\'s code is run.
--
-- 'inputSchema', 'inputDescription_inputSchema' - Describes the format of the data in the streaming source, and how each
-- data element maps to corresponding columns in the in-application stream
-- that is being created.
--
-- 'inputStartingPositionConfiguration', 'inputDescription_inputStartingPositionConfiguration' - Point at which the application is configured to read from the input
-- stream.
--
-- 'kinesisFirehoseInputDescription', 'inputDescription_kinesisFirehoseInputDescription' - If an Amazon Kinesis Firehose delivery stream is configured as a
-- streaming source, provides the delivery stream\'s ARN and an IAM role
-- that enables Amazon Kinesis Analytics to access the stream on your
-- behalf.
--
-- 'kinesisStreamsInputDescription', 'inputDescription_kinesisStreamsInputDescription' - If an Amazon Kinesis stream is configured as streaming source, provides
-- Amazon Kinesis stream\'s Amazon Resource Name (ARN) and an IAM role that
-- enables Amazon Kinesis Analytics to access the stream on your behalf.
--
-- 'namePrefix', 'inputDescription_namePrefix' - In-application name prefix.
newInputDescription ::
  InputDescription
newInputDescription :: InputDescription
newInputDescription =
  InputDescription'
    { $sel:inAppStreamNames:InputDescription' :: Maybe [Text]
inAppStreamNames =
        forall a. Maybe a
Prelude.Nothing,
      $sel:inputId:InputDescription' :: Maybe Text
inputId = forall a. Maybe a
Prelude.Nothing,
      $sel:inputParallelism:InputDescription' :: Maybe InputParallelism
inputParallelism = forall a. Maybe a
Prelude.Nothing,
      $sel:inputProcessingConfigurationDescription:InputDescription' :: Maybe InputProcessingConfigurationDescription
inputProcessingConfigurationDescription =
        forall a. Maybe a
Prelude.Nothing,
      $sel:inputSchema:InputDescription' :: Maybe SourceSchema
inputSchema = forall a. Maybe a
Prelude.Nothing,
      $sel:inputStartingPositionConfiguration:InputDescription' :: Maybe InputStartingPositionConfiguration
inputStartingPositionConfiguration = forall a. Maybe a
Prelude.Nothing,
      $sel:kinesisFirehoseInputDescription:InputDescription' :: Maybe KinesisFirehoseInputDescription
kinesisFirehoseInputDescription = forall a. Maybe a
Prelude.Nothing,
      $sel:kinesisStreamsInputDescription:InputDescription' :: Maybe KinesisStreamsInputDescription
kinesisStreamsInputDescription = forall a. Maybe a
Prelude.Nothing,
      $sel:namePrefix:InputDescription' :: Maybe Text
namePrefix = forall a. Maybe a
Prelude.Nothing
    }

-- | Returns the in-application stream names that are mapped to the stream
-- source.
inputDescription_inAppStreamNames :: Lens.Lens' InputDescription (Prelude.Maybe [Prelude.Text])
inputDescription_inAppStreamNames :: Lens' InputDescription (Maybe [Text])
inputDescription_inAppStreamNames = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\InputDescription' {Maybe [Text]
inAppStreamNames :: Maybe [Text]
$sel:inAppStreamNames:InputDescription' :: InputDescription -> Maybe [Text]
inAppStreamNames} -> Maybe [Text]
inAppStreamNames) (\s :: InputDescription
s@InputDescription' {} Maybe [Text]
a -> InputDescription
s {$sel:inAppStreamNames:InputDescription' :: Maybe [Text]
inAppStreamNames = Maybe [Text]
a} :: InputDescription) 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

-- | Input ID associated with the application input. This is the ID that
-- Amazon Kinesis Analytics assigns to each input configuration you add to
-- your application.
inputDescription_inputId :: Lens.Lens' InputDescription (Prelude.Maybe Prelude.Text)
inputDescription_inputId :: Lens' InputDescription (Maybe Text)
inputDescription_inputId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\InputDescription' {Maybe Text
inputId :: Maybe Text
$sel:inputId:InputDescription' :: InputDescription -> Maybe Text
inputId} -> Maybe Text
inputId) (\s :: InputDescription
s@InputDescription' {} Maybe Text
a -> InputDescription
s {$sel:inputId:InputDescription' :: Maybe Text
inputId = Maybe Text
a} :: InputDescription)

-- | Describes the configured parallelism (number of in-application streams
-- mapped to the streaming source).
inputDescription_inputParallelism :: Lens.Lens' InputDescription (Prelude.Maybe InputParallelism)
inputDescription_inputParallelism :: Lens' InputDescription (Maybe InputParallelism)
inputDescription_inputParallelism = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\InputDescription' {Maybe InputParallelism
inputParallelism :: Maybe InputParallelism
$sel:inputParallelism:InputDescription' :: InputDescription -> Maybe InputParallelism
inputParallelism} -> Maybe InputParallelism
inputParallelism) (\s :: InputDescription
s@InputDescription' {} Maybe InputParallelism
a -> InputDescription
s {$sel:inputParallelism:InputDescription' :: Maybe InputParallelism
inputParallelism = Maybe InputParallelism
a} :: InputDescription)

-- | The description of the preprocessor that executes on records in this
-- input before the application\'s code is run.
inputDescription_inputProcessingConfigurationDescription :: Lens.Lens' InputDescription (Prelude.Maybe InputProcessingConfigurationDescription)
inputDescription_inputProcessingConfigurationDescription :: Lens'
  InputDescription (Maybe InputProcessingConfigurationDescription)
inputDescription_inputProcessingConfigurationDescription = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\InputDescription' {Maybe InputProcessingConfigurationDescription
inputProcessingConfigurationDescription :: Maybe InputProcessingConfigurationDescription
$sel:inputProcessingConfigurationDescription:InputDescription' :: InputDescription -> Maybe InputProcessingConfigurationDescription
inputProcessingConfigurationDescription} -> Maybe InputProcessingConfigurationDescription
inputProcessingConfigurationDescription) (\s :: InputDescription
s@InputDescription' {} Maybe InputProcessingConfigurationDescription
a -> InputDescription
s {$sel:inputProcessingConfigurationDescription:InputDescription' :: Maybe InputProcessingConfigurationDescription
inputProcessingConfigurationDescription = Maybe InputProcessingConfigurationDescription
a} :: InputDescription)

-- | Describes the format of the data in the streaming source, and how each
-- data element maps to corresponding columns in the in-application stream
-- that is being created.
inputDescription_inputSchema :: Lens.Lens' InputDescription (Prelude.Maybe SourceSchema)
inputDescription_inputSchema :: Lens' InputDescription (Maybe SourceSchema)
inputDescription_inputSchema = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\InputDescription' {Maybe SourceSchema
inputSchema :: Maybe SourceSchema
$sel:inputSchema:InputDescription' :: InputDescription -> Maybe SourceSchema
inputSchema} -> Maybe SourceSchema
inputSchema) (\s :: InputDescription
s@InputDescription' {} Maybe SourceSchema
a -> InputDescription
s {$sel:inputSchema:InputDescription' :: Maybe SourceSchema
inputSchema = Maybe SourceSchema
a} :: InputDescription)

-- | Point at which the application is configured to read from the input
-- stream.
inputDescription_inputStartingPositionConfiguration :: Lens.Lens' InputDescription (Prelude.Maybe InputStartingPositionConfiguration)
inputDescription_inputStartingPositionConfiguration :: Lens' InputDescription (Maybe InputStartingPositionConfiguration)
inputDescription_inputStartingPositionConfiguration = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\InputDescription' {Maybe InputStartingPositionConfiguration
inputStartingPositionConfiguration :: Maybe InputStartingPositionConfiguration
$sel:inputStartingPositionConfiguration:InputDescription' :: InputDescription -> Maybe InputStartingPositionConfiguration
inputStartingPositionConfiguration} -> Maybe InputStartingPositionConfiguration
inputStartingPositionConfiguration) (\s :: InputDescription
s@InputDescription' {} Maybe InputStartingPositionConfiguration
a -> InputDescription
s {$sel:inputStartingPositionConfiguration:InputDescription' :: Maybe InputStartingPositionConfiguration
inputStartingPositionConfiguration = Maybe InputStartingPositionConfiguration
a} :: InputDescription)

-- | If an Amazon Kinesis Firehose delivery stream is configured as a
-- streaming source, provides the delivery stream\'s ARN and an IAM role
-- that enables Amazon Kinesis Analytics to access the stream on your
-- behalf.
inputDescription_kinesisFirehoseInputDescription :: Lens.Lens' InputDescription (Prelude.Maybe KinesisFirehoseInputDescription)
inputDescription_kinesisFirehoseInputDescription :: Lens' InputDescription (Maybe KinesisFirehoseInputDescription)
inputDescription_kinesisFirehoseInputDescription = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\InputDescription' {Maybe KinesisFirehoseInputDescription
kinesisFirehoseInputDescription :: Maybe KinesisFirehoseInputDescription
$sel:kinesisFirehoseInputDescription:InputDescription' :: InputDescription -> Maybe KinesisFirehoseInputDescription
kinesisFirehoseInputDescription} -> Maybe KinesisFirehoseInputDescription
kinesisFirehoseInputDescription) (\s :: InputDescription
s@InputDescription' {} Maybe KinesisFirehoseInputDescription
a -> InputDescription
s {$sel:kinesisFirehoseInputDescription:InputDescription' :: Maybe KinesisFirehoseInputDescription
kinesisFirehoseInputDescription = Maybe KinesisFirehoseInputDescription
a} :: InputDescription)

-- | If an Amazon Kinesis stream is configured as streaming source, provides
-- Amazon Kinesis stream\'s Amazon Resource Name (ARN) and an IAM role that
-- enables Amazon Kinesis Analytics to access the stream on your behalf.
inputDescription_kinesisStreamsInputDescription :: Lens.Lens' InputDescription (Prelude.Maybe KinesisStreamsInputDescription)
inputDescription_kinesisStreamsInputDescription :: Lens' InputDescription (Maybe KinesisStreamsInputDescription)
inputDescription_kinesisStreamsInputDescription = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\InputDescription' {Maybe KinesisStreamsInputDescription
kinesisStreamsInputDescription :: Maybe KinesisStreamsInputDescription
$sel:kinesisStreamsInputDescription:InputDescription' :: InputDescription -> Maybe KinesisStreamsInputDescription
kinesisStreamsInputDescription} -> Maybe KinesisStreamsInputDescription
kinesisStreamsInputDescription) (\s :: InputDescription
s@InputDescription' {} Maybe KinesisStreamsInputDescription
a -> InputDescription
s {$sel:kinesisStreamsInputDescription:InputDescription' :: Maybe KinesisStreamsInputDescription
kinesisStreamsInputDescription = Maybe KinesisStreamsInputDescription
a} :: InputDescription)

-- | In-application name prefix.
inputDescription_namePrefix :: Lens.Lens' InputDescription (Prelude.Maybe Prelude.Text)
inputDescription_namePrefix :: Lens' InputDescription (Maybe Text)
inputDescription_namePrefix = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\InputDescription' {Maybe Text
namePrefix :: Maybe Text
$sel:namePrefix:InputDescription' :: InputDescription -> Maybe Text
namePrefix} -> Maybe Text
namePrefix) (\s :: InputDescription
s@InputDescription' {} Maybe Text
a -> InputDescription
s {$sel:namePrefix:InputDescription' :: Maybe Text
namePrefix = Maybe Text
a} :: InputDescription)

instance Data.FromJSON InputDescription where
  parseJSON :: Value -> Parser InputDescription
parseJSON =
    forall a. String -> (Object -> Parser a) -> Value -> Parser a
Data.withObject
      String
"InputDescription"
      ( \Object
x ->
          Maybe [Text]
-> Maybe Text
-> Maybe InputParallelism
-> Maybe InputProcessingConfigurationDescription
-> Maybe SourceSchema
-> Maybe InputStartingPositionConfiguration
-> Maybe KinesisFirehoseInputDescription
-> Maybe KinesisStreamsInputDescription
-> Maybe Text
-> InputDescription
InputDescription'
            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
"InAppStreamNames"
                            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 (Maybe a)
Data..:? Key
"InputId")
            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
"InputParallelism")
            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
"InputProcessingConfigurationDescription"
                        )
            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
"InputSchema")
            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
"InputStartingPositionConfiguration")
            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
"KinesisFirehoseInputDescription")
            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
"KinesisStreamsInputDescription")
            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
"NamePrefix")
      )

instance Prelude.Hashable InputDescription where
  hashWithSalt :: Int -> InputDescription -> Int
hashWithSalt Int
_salt InputDescription' {Maybe [Text]
Maybe Text
Maybe InputParallelism
Maybe InputProcessingConfigurationDescription
Maybe InputStartingPositionConfiguration
Maybe KinesisFirehoseInputDescription
Maybe KinesisStreamsInputDescription
Maybe SourceSchema
namePrefix :: Maybe Text
kinesisStreamsInputDescription :: Maybe KinesisStreamsInputDescription
kinesisFirehoseInputDescription :: Maybe KinesisFirehoseInputDescription
inputStartingPositionConfiguration :: Maybe InputStartingPositionConfiguration
inputSchema :: Maybe SourceSchema
inputProcessingConfigurationDescription :: Maybe InputProcessingConfigurationDescription
inputParallelism :: Maybe InputParallelism
inputId :: Maybe Text
inAppStreamNames :: Maybe [Text]
$sel:namePrefix:InputDescription' :: InputDescription -> Maybe Text
$sel:kinesisStreamsInputDescription:InputDescription' :: InputDescription -> Maybe KinesisStreamsInputDescription
$sel:kinesisFirehoseInputDescription:InputDescription' :: InputDescription -> Maybe KinesisFirehoseInputDescription
$sel:inputStartingPositionConfiguration:InputDescription' :: InputDescription -> Maybe InputStartingPositionConfiguration
$sel:inputSchema:InputDescription' :: InputDescription -> Maybe SourceSchema
$sel:inputProcessingConfigurationDescription:InputDescription' :: InputDescription -> Maybe InputProcessingConfigurationDescription
$sel:inputParallelism:InputDescription' :: InputDescription -> Maybe InputParallelism
$sel:inputId:InputDescription' :: InputDescription -> Maybe Text
$sel:inAppStreamNames:InputDescription' :: InputDescription -> Maybe [Text]
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Text]
inAppStreamNames
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
inputId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe InputParallelism
inputParallelism
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe InputProcessingConfigurationDescription
inputProcessingConfigurationDescription
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe SourceSchema
inputSchema
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe InputStartingPositionConfiguration
inputStartingPositionConfiguration
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe KinesisFirehoseInputDescription
kinesisFirehoseInputDescription
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe KinesisStreamsInputDescription
kinesisStreamsInputDescription
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
namePrefix

instance Prelude.NFData InputDescription where
  rnf :: InputDescription -> ()
rnf InputDescription' {Maybe [Text]
Maybe Text
Maybe InputParallelism
Maybe InputProcessingConfigurationDescription
Maybe InputStartingPositionConfiguration
Maybe KinesisFirehoseInputDescription
Maybe KinesisStreamsInputDescription
Maybe SourceSchema
namePrefix :: Maybe Text
kinesisStreamsInputDescription :: Maybe KinesisStreamsInputDescription
kinesisFirehoseInputDescription :: Maybe KinesisFirehoseInputDescription
inputStartingPositionConfiguration :: Maybe InputStartingPositionConfiguration
inputSchema :: Maybe SourceSchema
inputProcessingConfigurationDescription :: Maybe InputProcessingConfigurationDescription
inputParallelism :: Maybe InputParallelism
inputId :: Maybe Text
inAppStreamNames :: Maybe [Text]
$sel:namePrefix:InputDescription' :: InputDescription -> Maybe Text
$sel:kinesisStreamsInputDescription:InputDescription' :: InputDescription -> Maybe KinesisStreamsInputDescription
$sel:kinesisFirehoseInputDescription:InputDescription' :: InputDescription -> Maybe KinesisFirehoseInputDescription
$sel:inputStartingPositionConfiguration:InputDescription' :: InputDescription -> Maybe InputStartingPositionConfiguration
$sel:inputSchema:InputDescription' :: InputDescription -> Maybe SourceSchema
$sel:inputProcessingConfigurationDescription:InputDescription' :: InputDescription -> Maybe InputProcessingConfigurationDescription
$sel:inputParallelism:InputDescription' :: InputDescription -> Maybe InputParallelism
$sel:inputId:InputDescription' :: InputDescription -> Maybe Text
$sel:inAppStreamNames:InputDescription' :: InputDescription -> Maybe [Text]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [Text]
inAppStreamNames
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
inputId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe InputParallelism
inputParallelism
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe InputProcessingConfigurationDescription
inputProcessingConfigurationDescription
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe SourceSchema
inputSchema
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe InputStartingPositionConfiguration
inputStartingPositionConfiguration
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe KinesisFirehoseInputDescription
kinesisFirehoseInputDescription
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe KinesisStreamsInputDescription
kinesisStreamsInputDescription
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
namePrefix