{-# 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.LookoutEquipment.CreateInferenceScheduler
-- 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 scheduled inference. Scheduling an inference is setting up a
-- continuous real-time inference plan to analyze new measurement data.
-- When setting up the schedule, you provide an S3 bucket location for the
-- input data, assign it a delimiter between separate entries in the data,
-- set an offset delay if desired, and set the frequency of inferencing.
-- You must also provide an S3 bucket location for the output data.
module Amazonka.LookoutEquipment.CreateInferenceScheduler
  ( -- * Creating a Request
    CreateInferenceScheduler (..),
    newCreateInferenceScheduler,

    -- * Request Lenses
    createInferenceScheduler_dataDelayOffsetInMinutes,
    createInferenceScheduler_serverSideKmsKeyId,
    createInferenceScheduler_tags,
    createInferenceScheduler_modelName,
    createInferenceScheduler_inferenceSchedulerName,
    createInferenceScheduler_dataUploadFrequency,
    createInferenceScheduler_dataInputConfiguration,
    createInferenceScheduler_dataOutputConfiguration,
    createInferenceScheduler_roleArn,
    createInferenceScheduler_clientToken,

    -- * Destructuring the Response
    CreateInferenceSchedulerResponse (..),
    newCreateInferenceSchedulerResponse,

    -- * Response Lenses
    createInferenceSchedulerResponse_inferenceSchedulerArn,
    createInferenceSchedulerResponse_inferenceSchedulerName,
    createInferenceSchedulerResponse_status,
    createInferenceSchedulerResponse_httpStatus,
  )
where

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

-- | /See:/ 'newCreateInferenceScheduler' smart constructor.
data CreateInferenceScheduler = CreateInferenceScheduler'
  { -- | The interval (in minutes) of planned delay at the start of each
    -- inference segment. For example, if inference is set to run every ten
    -- minutes, the delay is set to five minutes and the time is 09:08. The
    -- inference scheduler will wake up at the configured interval (which,
    -- without a delay configured, would be 09:10) plus the additional five
    -- minute delay time (so 09:15) to check your Amazon S3 bucket. The delay
    -- provides a buffer for you to upload data at the same frequency, so that
    -- you don\'t have to stop and restart the scheduler when uploading new
    -- data.
    --
    -- For more information, see
    -- <https://docs.aws.amazon.com/lookout-for-equipment/latest/ug/understanding-inference-process.html Understanding the inference process>.
    CreateInferenceScheduler -> Maybe Natural
dataDelayOffsetInMinutes :: Prelude.Maybe Prelude.Natural,
    -- | Provides the identifier of the KMS key used to encrypt inference
    -- scheduler data by Amazon Lookout for Equipment.
    CreateInferenceScheduler -> Maybe Text
serverSideKmsKeyId :: Prelude.Maybe Prelude.Text,
    -- | Any tags associated with the inference scheduler.
    CreateInferenceScheduler -> Maybe [Tag]
tags :: Prelude.Maybe [Tag],
    -- | The name of the previously trained ML model being used to create the
    -- inference scheduler.
    CreateInferenceScheduler -> Text
modelName :: Prelude.Text,
    -- | The name of the inference scheduler being created.
    CreateInferenceScheduler -> Text
inferenceSchedulerName :: Prelude.Text,
    -- | How often data is uploaded to the source Amazon S3 bucket for the input
    -- data. The value chosen is the length of time between data uploads. For
    -- instance, if you select 5 minutes, Amazon Lookout for Equipment will
    -- upload the real-time data to the source bucket once every 5 minutes.
    -- This frequency also determines how often Amazon Lookout for Equipment
    -- runs inference on your data.
    --
    -- For more information, see
    -- <https://docs.aws.amazon.com/lookout-for-equipment/latest/ug/understanding-inference-process.html Understanding the inference process>.
    CreateInferenceScheduler -> DataUploadFrequency
dataUploadFrequency :: DataUploadFrequency,
    -- | Specifies configuration information for the input data for the inference
    -- scheduler, including delimiter, format, and dataset location.
    CreateInferenceScheduler -> InferenceInputConfiguration
dataInputConfiguration :: InferenceInputConfiguration,
    -- | Specifies configuration information for the output results for the
    -- inference scheduler, including the S3 location for the output.
    CreateInferenceScheduler -> InferenceOutputConfiguration
dataOutputConfiguration :: InferenceOutputConfiguration,
    -- | The Amazon Resource Name (ARN) of a role with permission to access the
    -- data source being used for the inference.
    CreateInferenceScheduler -> Text
roleArn :: Prelude.Text,
    -- | A unique identifier for the request. If you do not set the client
    -- request token, Amazon Lookout for Equipment generates one.
    CreateInferenceScheduler -> Text
clientToken :: Prelude.Text
  }
  deriving (CreateInferenceScheduler -> CreateInferenceScheduler -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateInferenceScheduler -> CreateInferenceScheduler -> Bool
$c/= :: CreateInferenceScheduler -> CreateInferenceScheduler -> Bool
== :: CreateInferenceScheduler -> CreateInferenceScheduler -> Bool
$c== :: CreateInferenceScheduler -> CreateInferenceScheduler -> Bool
Prelude.Eq, ReadPrec [CreateInferenceScheduler]
ReadPrec CreateInferenceScheduler
Int -> ReadS CreateInferenceScheduler
ReadS [CreateInferenceScheduler]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateInferenceScheduler]
$creadListPrec :: ReadPrec [CreateInferenceScheduler]
readPrec :: ReadPrec CreateInferenceScheduler
$creadPrec :: ReadPrec CreateInferenceScheduler
readList :: ReadS [CreateInferenceScheduler]
$creadList :: ReadS [CreateInferenceScheduler]
readsPrec :: Int -> ReadS CreateInferenceScheduler
$creadsPrec :: Int -> ReadS CreateInferenceScheduler
Prelude.Read, Int -> CreateInferenceScheduler -> ShowS
[CreateInferenceScheduler] -> ShowS
CreateInferenceScheduler -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateInferenceScheduler] -> ShowS
$cshowList :: [CreateInferenceScheduler] -> ShowS
show :: CreateInferenceScheduler -> String
$cshow :: CreateInferenceScheduler -> String
showsPrec :: Int -> CreateInferenceScheduler -> ShowS
$cshowsPrec :: Int -> CreateInferenceScheduler -> ShowS
Prelude.Show, forall x.
Rep CreateInferenceScheduler x -> CreateInferenceScheduler
forall x.
CreateInferenceScheduler -> Rep CreateInferenceScheduler x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep CreateInferenceScheduler x -> CreateInferenceScheduler
$cfrom :: forall x.
CreateInferenceScheduler -> Rep CreateInferenceScheduler x
Prelude.Generic)

-- |
-- Create a value of 'CreateInferenceScheduler' 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:
--
-- 'dataDelayOffsetInMinutes', 'createInferenceScheduler_dataDelayOffsetInMinutes' - The interval (in minutes) of planned delay at the start of each
-- inference segment. For example, if inference is set to run every ten
-- minutes, the delay is set to five minutes and the time is 09:08. The
-- inference scheduler will wake up at the configured interval (which,
-- without a delay configured, would be 09:10) plus the additional five
-- minute delay time (so 09:15) to check your Amazon S3 bucket. The delay
-- provides a buffer for you to upload data at the same frequency, so that
-- you don\'t have to stop and restart the scheduler when uploading new
-- data.
--
-- For more information, see
-- <https://docs.aws.amazon.com/lookout-for-equipment/latest/ug/understanding-inference-process.html Understanding the inference process>.
--
-- 'serverSideKmsKeyId', 'createInferenceScheduler_serverSideKmsKeyId' - Provides the identifier of the KMS key used to encrypt inference
-- scheduler data by Amazon Lookout for Equipment.
--
-- 'tags', 'createInferenceScheduler_tags' - Any tags associated with the inference scheduler.
--
-- 'modelName', 'createInferenceScheduler_modelName' - The name of the previously trained ML model being used to create the
-- inference scheduler.
--
-- 'inferenceSchedulerName', 'createInferenceScheduler_inferenceSchedulerName' - The name of the inference scheduler being created.
--
-- 'dataUploadFrequency', 'createInferenceScheduler_dataUploadFrequency' - How often data is uploaded to the source Amazon S3 bucket for the input
-- data. The value chosen is the length of time between data uploads. For
-- instance, if you select 5 minutes, Amazon Lookout for Equipment will
-- upload the real-time data to the source bucket once every 5 minutes.
-- This frequency also determines how often Amazon Lookout for Equipment
-- runs inference on your data.
--
-- For more information, see
-- <https://docs.aws.amazon.com/lookout-for-equipment/latest/ug/understanding-inference-process.html Understanding the inference process>.
--
-- 'dataInputConfiguration', 'createInferenceScheduler_dataInputConfiguration' - Specifies configuration information for the input data for the inference
-- scheduler, including delimiter, format, and dataset location.
--
-- 'dataOutputConfiguration', 'createInferenceScheduler_dataOutputConfiguration' - Specifies configuration information for the output results for the
-- inference scheduler, including the S3 location for the output.
--
-- 'roleArn', 'createInferenceScheduler_roleArn' - The Amazon Resource Name (ARN) of a role with permission to access the
-- data source being used for the inference.
--
-- 'clientToken', 'createInferenceScheduler_clientToken' - A unique identifier for the request. If you do not set the client
-- request token, Amazon Lookout for Equipment generates one.
newCreateInferenceScheduler ::
  -- | 'modelName'
  Prelude.Text ->
  -- | 'inferenceSchedulerName'
  Prelude.Text ->
  -- | 'dataUploadFrequency'
  DataUploadFrequency ->
  -- | 'dataInputConfiguration'
  InferenceInputConfiguration ->
  -- | 'dataOutputConfiguration'
  InferenceOutputConfiguration ->
  -- | 'roleArn'
  Prelude.Text ->
  -- | 'clientToken'
  Prelude.Text ->
  CreateInferenceScheduler
newCreateInferenceScheduler :: Text
-> Text
-> DataUploadFrequency
-> InferenceInputConfiguration
-> InferenceOutputConfiguration
-> Text
-> Text
-> CreateInferenceScheduler
newCreateInferenceScheduler
  Text
pModelName_
  Text
pInferenceSchedulerName_
  DataUploadFrequency
pDataUploadFrequency_
  InferenceInputConfiguration
pDataInputConfiguration_
  InferenceOutputConfiguration
pDataOutputConfiguration_
  Text
pRoleArn_
  Text
pClientToken_ =
    CreateInferenceScheduler'
      { $sel:dataDelayOffsetInMinutes:CreateInferenceScheduler' :: Maybe Natural
dataDelayOffsetInMinutes =
          forall a. Maybe a
Prelude.Nothing,
        $sel:serverSideKmsKeyId:CreateInferenceScheduler' :: Maybe Text
serverSideKmsKeyId = forall a. Maybe a
Prelude.Nothing,
        $sel:tags:CreateInferenceScheduler' :: Maybe [Tag]
tags = forall a. Maybe a
Prelude.Nothing,
        $sel:modelName:CreateInferenceScheduler' :: Text
modelName = Text
pModelName_,
        $sel:inferenceSchedulerName:CreateInferenceScheduler' :: Text
inferenceSchedulerName = Text
pInferenceSchedulerName_,
        $sel:dataUploadFrequency:CreateInferenceScheduler' :: DataUploadFrequency
dataUploadFrequency = DataUploadFrequency
pDataUploadFrequency_,
        $sel:dataInputConfiguration:CreateInferenceScheduler' :: InferenceInputConfiguration
dataInputConfiguration = InferenceInputConfiguration
pDataInputConfiguration_,
        $sel:dataOutputConfiguration:CreateInferenceScheduler' :: InferenceOutputConfiguration
dataOutputConfiguration =
          InferenceOutputConfiguration
pDataOutputConfiguration_,
        $sel:roleArn:CreateInferenceScheduler' :: Text
roleArn = Text
pRoleArn_,
        $sel:clientToken:CreateInferenceScheduler' :: Text
clientToken = Text
pClientToken_
      }

-- | The interval (in minutes) of planned delay at the start of each
-- inference segment. For example, if inference is set to run every ten
-- minutes, the delay is set to five minutes and the time is 09:08. The
-- inference scheduler will wake up at the configured interval (which,
-- without a delay configured, would be 09:10) plus the additional five
-- minute delay time (so 09:15) to check your Amazon S3 bucket. The delay
-- provides a buffer for you to upload data at the same frequency, so that
-- you don\'t have to stop and restart the scheduler when uploading new
-- data.
--
-- For more information, see
-- <https://docs.aws.amazon.com/lookout-for-equipment/latest/ug/understanding-inference-process.html Understanding the inference process>.
createInferenceScheduler_dataDelayOffsetInMinutes :: Lens.Lens' CreateInferenceScheduler (Prelude.Maybe Prelude.Natural)
createInferenceScheduler_dataDelayOffsetInMinutes :: Lens' CreateInferenceScheduler (Maybe Natural)
createInferenceScheduler_dataDelayOffsetInMinutes = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateInferenceScheduler' {Maybe Natural
dataDelayOffsetInMinutes :: Maybe Natural
$sel:dataDelayOffsetInMinutes:CreateInferenceScheduler' :: CreateInferenceScheduler -> Maybe Natural
dataDelayOffsetInMinutes} -> Maybe Natural
dataDelayOffsetInMinutes) (\s :: CreateInferenceScheduler
s@CreateInferenceScheduler' {} Maybe Natural
a -> CreateInferenceScheduler
s {$sel:dataDelayOffsetInMinutes:CreateInferenceScheduler' :: Maybe Natural
dataDelayOffsetInMinutes = Maybe Natural
a} :: CreateInferenceScheduler)

-- | Provides the identifier of the KMS key used to encrypt inference
-- scheduler data by Amazon Lookout for Equipment.
createInferenceScheduler_serverSideKmsKeyId :: Lens.Lens' CreateInferenceScheduler (Prelude.Maybe Prelude.Text)
createInferenceScheduler_serverSideKmsKeyId :: Lens' CreateInferenceScheduler (Maybe Text)
createInferenceScheduler_serverSideKmsKeyId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateInferenceScheduler' {Maybe Text
serverSideKmsKeyId :: Maybe Text
$sel:serverSideKmsKeyId:CreateInferenceScheduler' :: CreateInferenceScheduler -> Maybe Text
serverSideKmsKeyId} -> Maybe Text
serverSideKmsKeyId) (\s :: CreateInferenceScheduler
s@CreateInferenceScheduler' {} Maybe Text
a -> CreateInferenceScheduler
s {$sel:serverSideKmsKeyId:CreateInferenceScheduler' :: Maybe Text
serverSideKmsKeyId = Maybe Text
a} :: CreateInferenceScheduler)

-- | Any tags associated with the inference scheduler.
createInferenceScheduler_tags :: Lens.Lens' CreateInferenceScheduler (Prelude.Maybe [Tag])
createInferenceScheduler_tags :: Lens' CreateInferenceScheduler (Maybe [Tag])
createInferenceScheduler_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateInferenceScheduler' {Maybe [Tag]
tags :: Maybe [Tag]
$sel:tags:CreateInferenceScheduler' :: CreateInferenceScheduler -> Maybe [Tag]
tags} -> Maybe [Tag]
tags) (\s :: CreateInferenceScheduler
s@CreateInferenceScheduler' {} Maybe [Tag]
a -> CreateInferenceScheduler
s {$sel:tags:CreateInferenceScheduler' :: Maybe [Tag]
tags = Maybe [Tag]
a} :: CreateInferenceScheduler) 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 name of the previously trained ML model being used to create the
-- inference scheduler.
createInferenceScheduler_modelName :: Lens.Lens' CreateInferenceScheduler Prelude.Text
createInferenceScheduler_modelName :: Lens' CreateInferenceScheduler Text
createInferenceScheduler_modelName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateInferenceScheduler' {Text
modelName :: Text
$sel:modelName:CreateInferenceScheduler' :: CreateInferenceScheduler -> Text
modelName} -> Text
modelName) (\s :: CreateInferenceScheduler
s@CreateInferenceScheduler' {} Text
a -> CreateInferenceScheduler
s {$sel:modelName:CreateInferenceScheduler' :: Text
modelName = Text
a} :: CreateInferenceScheduler)

-- | The name of the inference scheduler being created.
createInferenceScheduler_inferenceSchedulerName :: Lens.Lens' CreateInferenceScheduler Prelude.Text
createInferenceScheduler_inferenceSchedulerName :: Lens' CreateInferenceScheduler Text
createInferenceScheduler_inferenceSchedulerName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateInferenceScheduler' {Text
inferenceSchedulerName :: Text
$sel:inferenceSchedulerName:CreateInferenceScheduler' :: CreateInferenceScheduler -> Text
inferenceSchedulerName} -> Text
inferenceSchedulerName) (\s :: CreateInferenceScheduler
s@CreateInferenceScheduler' {} Text
a -> CreateInferenceScheduler
s {$sel:inferenceSchedulerName:CreateInferenceScheduler' :: Text
inferenceSchedulerName = Text
a} :: CreateInferenceScheduler)

-- | How often data is uploaded to the source Amazon S3 bucket for the input
-- data. The value chosen is the length of time between data uploads. For
-- instance, if you select 5 minutes, Amazon Lookout for Equipment will
-- upload the real-time data to the source bucket once every 5 minutes.
-- This frequency also determines how often Amazon Lookout for Equipment
-- runs inference on your data.
--
-- For more information, see
-- <https://docs.aws.amazon.com/lookout-for-equipment/latest/ug/understanding-inference-process.html Understanding the inference process>.
createInferenceScheduler_dataUploadFrequency :: Lens.Lens' CreateInferenceScheduler DataUploadFrequency
createInferenceScheduler_dataUploadFrequency :: Lens' CreateInferenceScheduler DataUploadFrequency
createInferenceScheduler_dataUploadFrequency = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateInferenceScheduler' {DataUploadFrequency
dataUploadFrequency :: DataUploadFrequency
$sel:dataUploadFrequency:CreateInferenceScheduler' :: CreateInferenceScheduler -> DataUploadFrequency
dataUploadFrequency} -> DataUploadFrequency
dataUploadFrequency) (\s :: CreateInferenceScheduler
s@CreateInferenceScheduler' {} DataUploadFrequency
a -> CreateInferenceScheduler
s {$sel:dataUploadFrequency:CreateInferenceScheduler' :: DataUploadFrequency
dataUploadFrequency = DataUploadFrequency
a} :: CreateInferenceScheduler)

-- | Specifies configuration information for the input data for the inference
-- scheduler, including delimiter, format, and dataset location.
createInferenceScheduler_dataInputConfiguration :: Lens.Lens' CreateInferenceScheduler InferenceInputConfiguration
createInferenceScheduler_dataInputConfiguration :: Lens' CreateInferenceScheduler InferenceInputConfiguration
createInferenceScheduler_dataInputConfiguration = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateInferenceScheduler' {InferenceInputConfiguration
dataInputConfiguration :: InferenceInputConfiguration
$sel:dataInputConfiguration:CreateInferenceScheduler' :: CreateInferenceScheduler -> InferenceInputConfiguration
dataInputConfiguration} -> InferenceInputConfiguration
dataInputConfiguration) (\s :: CreateInferenceScheduler
s@CreateInferenceScheduler' {} InferenceInputConfiguration
a -> CreateInferenceScheduler
s {$sel:dataInputConfiguration:CreateInferenceScheduler' :: InferenceInputConfiguration
dataInputConfiguration = InferenceInputConfiguration
a} :: CreateInferenceScheduler)

-- | Specifies configuration information for the output results for the
-- inference scheduler, including the S3 location for the output.
createInferenceScheduler_dataOutputConfiguration :: Lens.Lens' CreateInferenceScheduler InferenceOutputConfiguration
createInferenceScheduler_dataOutputConfiguration :: Lens' CreateInferenceScheduler InferenceOutputConfiguration
createInferenceScheduler_dataOutputConfiguration = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateInferenceScheduler' {InferenceOutputConfiguration
dataOutputConfiguration :: InferenceOutputConfiguration
$sel:dataOutputConfiguration:CreateInferenceScheduler' :: CreateInferenceScheduler -> InferenceOutputConfiguration
dataOutputConfiguration} -> InferenceOutputConfiguration
dataOutputConfiguration) (\s :: CreateInferenceScheduler
s@CreateInferenceScheduler' {} InferenceOutputConfiguration
a -> CreateInferenceScheduler
s {$sel:dataOutputConfiguration:CreateInferenceScheduler' :: InferenceOutputConfiguration
dataOutputConfiguration = InferenceOutputConfiguration
a} :: CreateInferenceScheduler)

-- | The Amazon Resource Name (ARN) of a role with permission to access the
-- data source being used for the inference.
createInferenceScheduler_roleArn :: Lens.Lens' CreateInferenceScheduler Prelude.Text
createInferenceScheduler_roleArn :: Lens' CreateInferenceScheduler Text
createInferenceScheduler_roleArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateInferenceScheduler' {Text
roleArn :: Text
$sel:roleArn:CreateInferenceScheduler' :: CreateInferenceScheduler -> Text
roleArn} -> Text
roleArn) (\s :: CreateInferenceScheduler
s@CreateInferenceScheduler' {} Text
a -> CreateInferenceScheduler
s {$sel:roleArn:CreateInferenceScheduler' :: Text
roleArn = Text
a} :: CreateInferenceScheduler)

-- | A unique identifier for the request. If you do not set the client
-- request token, Amazon Lookout for Equipment generates one.
createInferenceScheduler_clientToken :: Lens.Lens' CreateInferenceScheduler Prelude.Text
createInferenceScheduler_clientToken :: Lens' CreateInferenceScheduler Text
createInferenceScheduler_clientToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateInferenceScheduler' {Text
clientToken :: Text
$sel:clientToken:CreateInferenceScheduler' :: CreateInferenceScheduler -> Text
clientToken} -> Text
clientToken) (\s :: CreateInferenceScheduler
s@CreateInferenceScheduler' {} Text
a -> CreateInferenceScheduler
s {$sel:clientToken:CreateInferenceScheduler' :: Text
clientToken = Text
a} :: CreateInferenceScheduler)

instance Core.AWSRequest CreateInferenceScheduler where
  type
    AWSResponse CreateInferenceScheduler =
      CreateInferenceSchedulerResponse
  request :: (Service -> Service)
-> CreateInferenceScheduler -> Request CreateInferenceScheduler
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 CreateInferenceScheduler
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse CreateInferenceScheduler)))
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 InferenceSchedulerStatus
-> Int
-> CreateInferenceSchedulerResponse
CreateInferenceSchedulerResponse'
            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
"InferenceSchedulerArn")
            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
"InferenceSchedulerName")
            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
"Status")
            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 CreateInferenceScheduler where
  hashWithSalt :: Int -> CreateInferenceScheduler -> Int
hashWithSalt Int
_salt CreateInferenceScheduler' {Maybe Natural
Maybe [Tag]
Maybe Text
Text
DataUploadFrequency
InferenceInputConfiguration
InferenceOutputConfiguration
clientToken :: Text
roleArn :: Text
dataOutputConfiguration :: InferenceOutputConfiguration
dataInputConfiguration :: InferenceInputConfiguration
dataUploadFrequency :: DataUploadFrequency
inferenceSchedulerName :: Text
modelName :: Text
tags :: Maybe [Tag]
serverSideKmsKeyId :: Maybe Text
dataDelayOffsetInMinutes :: Maybe Natural
$sel:clientToken:CreateInferenceScheduler' :: CreateInferenceScheduler -> Text
$sel:roleArn:CreateInferenceScheduler' :: CreateInferenceScheduler -> Text
$sel:dataOutputConfiguration:CreateInferenceScheduler' :: CreateInferenceScheduler -> InferenceOutputConfiguration
$sel:dataInputConfiguration:CreateInferenceScheduler' :: CreateInferenceScheduler -> InferenceInputConfiguration
$sel:dataUploadFrequency:CreateInferenceScheduler' :: CreateInferenceScheduler -> DataUploadFrequency
$sel:inferenceSchedulerName:CreateInferenceScheduler' :: CreateInferenceScheduler -> Text
$sel:modelName:CreateInferenceScheduler' :: CreateInferenceScheduler -> Text
$sel:tags:CreateInferenceScheduler' :: CreateInferenceScheduler -> Maybe [Tag]
$sel:serverSideKmsKeyId:CreateInferenceScheduler' :: CreateInferenceScheduler -> Maybe Text
$sel:dataDelayOffsetInMinutes:CreateInferenceScheduler' :: CreateInferenceScheduler -> Maybe Natural
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Natural
dataDelayOffsetInMinutes
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
serverSideKmsKeyId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Tag]
tags
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
modelName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
inferenceSchedulerName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` DataUploadFrequency
dataUploadFrequency
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` InferenceInputConfiguration
dataInputConfiguration
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` InferenceOutputConfiguration
dataOutputConfiguration
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
roleArn
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
clientToken

instance Prelude.NFData CreateInferenceScheduler where
  rnf :: CreateInferenceScheduler -> ()
rnf CreateInferenceScheduler' {Maybe Natural
Maybe [Tag]
Maybe Text
Text
DataUploadFrequency
InferenceInputConfiguration
InferenceOutputConfiguration
clientToken :: Text
roleArn :: Text
dataOutputConfiguration :: InferenceOutputConfiguration
dataInputConfiguration :: InferenceInputConfiguration
dataUploadFrequency :: DataUploadFrequency
inferenceSchedulerName :: Text
modelName :: Text
tags :: Maybe [Tag]
serverSideKmsKeyId :: Maybe Text
dataDelayOffsetInMinutes :: Maybe Natural
$sel:clientToken:CreateInferenceScheduler' :: CreateInferenceScheduler -> Text
$sel:roleArn:CreateInferenceScheduler' :: CreateInferenceScheduler -> Text
$sel:dataOutputConfiguration:CreateInferenceScheduler' :: CreateInferenceScheduler -> InferenceOutputConfiguration
$sel:dataInputConfiguration:CreateInferenceScheduler' :: CreateInferenceScheduler -> InferenceInputConfiguration
$sel:dataUploadFrequency:CreateInferenceScheduler' :: CreateInferenceScheduler -> DataUploadFrequency
$sel:inferenceSchedulerName:CreateInferenceScheduler' :: CreateInferenceScheduler -> Text
$sel:modelName:CreateInferenceScheduler' :: CreateInferenceScheduler -> Text
$sel:tags:CreateInferenceScheduler' :: CreateInferenceScheduler -> Maybe [Tag]
$sel:serverSideKmsKeyId:CreateInferenceScheduler' :: CreateInferenceScheduler -> Maybe Text
$sel:dataDelayOffsetInMinutes:CreateInferenceScheduler' :: CreateInferenceScheduler -> Maybe Natural
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Natural
dataDelayOffsetInMinutes
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
serverSideKmsKeyId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Tag]
tags
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
modelName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
inferenceSchedulerName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf DataUploadFrequency
dataUploadFrequency
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf InferenceInputConfiguration
dataInputConfiguration
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf InferenceOutputConfiguration
dataOutputConfiguration
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
roleArn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
clientToken

instance Data.ToHeaders CreateInferenceScheduler where
  toHeaders :: CreateInferenceScheduler -> ResponseHeaders
toHeaders =
    forall a b. a -> b -> a
Prelude.const
      ( forall a. Monoid a => [a] -> a
Prelude.mconcat
          [ HeaderName
"X-Amz-Target"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"AWSLookoutEquipmentFrontendService.CreateInferenceScheduler" ::
                          Prelude.ByteString
                      ),
            HeaderName
"Content-Type"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"application/x-amz-json-1.0" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Data.ToJSON CreateInferenceScheduler where
  toJSON :: CreateInferenceScheduler -> Value
toJSON CreateInferenceScheduler' {Maybe Natural
Maybe [Tag]
Maybe Text
Text
DataUploadFrequency
InferenceInputConfiguration
InferenceOutputConfiguration
clientToken :: Text
roleArn :: Text
dataOutputConfiguration :: InferenceOutputConfiguration
dataInputConfiguration :: InferenceInputConfiguration
dataUploadFrequency :: DataUploadFrequency
inferenceSchedulerName :: Text
modelName :: Text
tags :: Maybe [Tag]
serverSideKmsKeyId :: Maybe Text
dataDelayOffsetInMinutes :: Maybe Natural
$sel:clientToken:CreateInferenceScheduler' :: CreateInferenceScheduler -> Text
$sel:roleArn:CreateInferenceScheduler' :: CreateInferenceScheduler -> Text
$sel:dataOutputConfiguration:CreateInferenceScheduler' :: CreateInferenceScheduler -> InferenceOutputConfiguration
$sel:dataInputConfiguration:CreateInferenceScheduler' :: CreateInferenceScheduler -> InferenceInputConfiguration
$sel:dataUploadFrequency:CreateInferenceScheduler' :: CreateInferenceScheduler -> DataUploadFrequency
$sel:inferenceSchedulerName:CreateInferenceScheduler' :: CreateInferenceScheduler -> Text
$sel:modelName:CreateInferenceScheduler' :: CreateInferenceScheduler -> Text
$sel:tags:CreateInferenceScheduler' :: CreateInferenceScheduler -> Maybe [Tag]
$sel:serverSideKmsKeyId:CreateInferenceScheduler' :: CreateInferenceScheduler -> Maybe Text
$sel:dataDelayOffsetInMinutes:CreateInferenceScheduler' :: CreateInferenceScheduler -> Maybe Natural
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"DataDelayOffsetInMinutes" 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
dataDelayOffsetInMinutes,
            (Key
"ServerSideKmsKeyId" 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
serverSideKmsKeyId,
            (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 [Tag]
tags,
            forall a. a -> Maybe a
Prelude.Just (Key
"ModelName" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
modelName),
            forall a. a -> Maybe a
Prelude.Just
              ( Key
"InferenceSchedulerName"
                  forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
inferenceSchedulerName
              ),
            forall a. a -> Maybe a
Prelude.Just
              (Key
"DataUploadFrequency" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= DataUploadFrequency
dataUploadFrequency),
            forall a. a -> Maybe a
Prelude.Just
              ( Key
"DataInputConfiguration"
                  forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= InferenceInputConfiguration
dataInputConfiguration
              ),
            forall a. a -> Maybe a
Prelude.Just
              ( Key
"DataOutputConfiguration"
                  forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= InferenceOutputConfiguration
dataOutputConfiguration
              ),
            forall a. a -> Maybe a
Prelude.Just (Key
"RoleArn" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
roleArn),
            forall a. a -> Maybe a
Prelude.Just (Key
"ClientToken" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
clientToken)
          ]
      )

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

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

-- | /See:/ 'newCreateInferenceSchedulerResponse' smart constructor.
data CreateInferenceSchedulerResponse = CreateInferenceSchedulerResponse'
  { -- | The Amazon Resource Name (ARN) of the inference scheduler being created.
    CreateInferenceSchedulerResponse -> Maybe Text
inferenceSchedulerArn :: Prelude.Maybe Prelude.Text,
    -- | The name of inference scheduler being created.
    CreateInferenceSchedulerResponse -> Maybe Text
inferenceSchedulerName :: Prelude.Maybe Prelude.Text,
    -- | Indicates the status of the @CreateInferenceScheduler@ operation.
    CreateInferenceSchedulerResponse -> Maybe InferenceSchedulerStatus
status :: Prelude.Maybe InferenceSchedulerStatus,
    -- | The response's http status code.
    CreateInferenceSchedulerResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (CreateInferenceSchedulerResponse
-> CreateInferenceSchedulerResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateInferenceSchedulerResponse
-> CreateInferenceSchedulerResponse -> Bool
$c/= :: CreateInferenceSchedulerResponse
-> CreateInferenceSchedulerResponse -> Bool
== :: CreateInferenceSchedulerResponse
-> CreateInferenceSchedulerResponse -> Bool
$c== :: CreateInferenceSchedulerResponse
-> CreateInferenceSchedulerResponse -> Bool
Prelude.Eq, ReadPrec [CreateInferenceSchedulerResponse]
ReadPrec CreateInferenceSchedulerResponse
Int -> ReadS CreateInferenceSchedulerResponse
ReadS [CreateInferenceSchedulerResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateInferenceSchedulerResponse]
$creadListPrec :: ReadPrec [CreateInferenceSchedulerResponse]
readPrec :: ReadPrec CreateInferenceSchedulerResponse
$creadPrec :: ReadPrec CreateInferenceSchedulerResponse
readList :: ReadS [CreateInferenceSchedulerResponse]
$creadList :: ReadS [CreateInferenceSchedulerResponse]
readsPrec :: Int -> ReadS CreateInferenceSchedulerResponse
$creadsPrec :: Int -> ReadS CreateInferenceSchedulerResponse
Prelude.Read, Int -> CreateInferenceSchedulerResponse -> ShowS
[CreateInferenceSchedulerResponse] -> ShowS
CreateInferenceSchedulerResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateInferenceSchedulerResponse] -> ShowS
$cshowList :: [CreateInferenceSchedulerResponse] -> ShowS
show :: CreateInferenceSchedulerResponse -> String
$cshow :: CreateInferenceSchedulerResponse -> String
showsPrec :: Int -> CreateInferenceSchedulerResponse -> ShowS
$cshowsPrec :: Int -> CreateInferenceSchedulerResponse -> ShowS
Prelude.Show, forall x.
Rep CreateInferenceSchedulerResponse x
-> CreateInferenceSchedulerResponse
forall x.
CreateInferenceSchedulerResponse
-> Rep CreateInferenceSchedulerResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep CreateInferenceSchedulerResponse x
-> CreateInferenceSchedulerResponse
$cfrom :: forall x.
CreateInferenceSchedulerResponse
-> Rep CreateInferenceSchedulerResponse x
Prelude.Generic)

-- |
-- Create a value of 'CreateInferenceSchedulerResponse' 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:
--
-- 'inferenceSchedulerArn', 'createInferenceSchedulerResponse_inferenceSchedulerArn' - The Amazon Resource Name (ARN) of the inference scheduler being created.
--
-- 'inferenceSchedulerName', 'createInferenceSchedulerResponse_inferenceSchedulerName' - The name of inference scheduler being created.
--
-- 'status', 'createInferenceSchedulerResponse_status' - Indicates the status of the @CreateInferenceScheduler@ operation.
--
-- 'httpStatus', 'createInferenceSchedulerResponse_httpStatus' - The response's http status code.
newCreateInferenceSchedulerResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  CreateInferenceSchedulerResponse
newCreateInferenceSchedulerResponse :: Int -> CreateInferenceSchedulerResponse
newCreateInferenceSchedulerResponse Int
pHttpStatus_ =
  CreateInferenceSchedulerResponse'
    { $sel:inferenceSchedulerArn:CreateInferenceSchedulerResponse' :: Maybe Text
inferenceSchedulerArn =
        forall a. Maybe a
Prelude.Nothing,
      $sel:inferenceSchedulerName:CreateInferenceSchedulerResponse' :: Maybe Text
inferenceSchedulerName = forall a. Maybe a
Prelude.Nothing,
      $sel:status:CreateInferenceSchedulerResponse' :: Maybe InferenceSchedulerStatus
status = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:CreateInferenceSchedulerResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The Amazon Resource Name (ARN) of the inference scheduler being created.
createInferenceSchedulerResponse_inferenceSchedulerArn :: Lens.Lens' CreateInferenceSchedulerResponse (Prelude.Maybe Prelude.Text)
createInferenceSchedulerResponse_inferenceSchedulerArn :: Lens' CreateInferenceSchedulerResponse (Maybe Text)
createInferenceSchedulerResponse_inferenceSchedulerArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateInferenceSchedulerResponse' {Maybe Text
inferenceSchedulerArn :: Maybe Text
$sel:inferenceSchedulerArn:CreateInferenceSchedulerResponse' :: CreateInferenceSchedulerResponse -> Maybe Text
inferenceSchedulerArn} -> Maybe Text
inferenceSchedulerArn) (\s :: CreateInferenceSchedulerResponse
s@CreateInferenceSchedulerResponse' {} Maybe Text
a -> CreateInferenceSchedulerResponse
s {$sel:inferenceSchedulerArn:CreateInferenceSchedulerResponse' :: Maybe Text
inferenceSchedulerArn = Maybe Text
a} :: CreateInferenceSchedulerResponse)

-- | The name of inference scheduler being created.
createInferenceSchedulerResponse_inferenceSchedulerName :: Lens.Lens' CreateInferenceSchedulerResponse (Prelude.Maybe Prelude.Text)
createInferenceSchedulerResponse_inferenceSchedulerName :: Lens' CreateInferenceSchedulerResponse (Maybe Text)
createInferenceSchedulerResponse_inferenceSchedulerName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateInferenceSchedulerResponse' {Maybe Text
inferenceSchedulerName :: Maybe Text
$sel:inferenceSchedulerName:CreateInferenceSchedulerResponse' :: CreateInferenceSchedulerResponse -> Maybe Text
inferenceSchedulerName} -> Maybe Text
inferenceSchedulerName) (\s :: CreateInferenceSchedulerResponse
s@CreateInferenceSchedulerResponse' {} Maybe Text
a -> CreateInferenceSchedulerResponse
s {$sel:inferenceSchedulerName:CreateInferenceSchedulerResponse' :: Maybe Text
inferenceSchedulerName = Maybe Text
a} :: CreateInferenceSchedulerResponse)

-- | Indicates the status of the @CreateInferenceScheduler@ operation.
createInferenceSchedulerResponse_status :: Lens.Lens' CreateInferenceSchedulerResponse (Prelude.Maybe InferenceSchedulerStatus)
createInferenceSchedulerResponse_status :: Lens'
  CreateInferenceSchedulerResponse (Maybe InferenceSchedulerStatus)
createInferenceSchedulerResponse_status = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateInferenceSchedulerResponse' {Maybe InferenceSchedulerStatus
status :: Maybe InferenceSchedulerStatus
$sel:status:CreateInferenceSchedulerResponse' :: CreateInferenceSchedulerResponse -> Maybe InferenceSchedulerStatus
status} -> Maybe InferenceSchedulerStatus
status) (\s :: CreateInferenceSchedulerResponse
s@CreateInferenceSchedulerResponse' {} Maybe InferenceSchedulerStatus
a -> CreateInferenceSchedulerResponse
s {$sel:status:CreateInferenceSchedulerResponse' :: Maybe InferenceSchedulerStatus
status = Maybe InferenceSchedulerStatus
a} :: CreateInferenceSchedulerResponse)

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

instance
  Prelude.NFData
    CreateInferenceSchedulerResponse
  where
  rnf :: CreateInferenceSchedulerResponse -> ()
rnf CreateInferenceSchedulerResponse' {Int
Maybe Text
Maybe InferenceSchedulerStatus
httpStatus :: Int
status :: Maybe InferenceSchedulerStatus
inferenceSchedulerName :: Maybe Text
inferenceSchedulerArn :: Maybe Text
$sel:httpStatus:CreateInferenceSchedulerResponse' :: CreateInferenceSchedulerResponse -> Int
$sel:status:CreateInferenceSchedulerResponse' :: CreateInferenceSchedulerResponse -> Maybe InferenceSchedulerStatus
$sel:inferenceSchedulerName:CreateInferenceSchedulerResponse' :: CreateInferenceSchedulerResponse -> Maybe Text
$sel:inferenceSchedulerArn:CreateInferenceSchedulerResponse' :: CreateInferenceSchedulerResponse -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
inferenceSchedulerArn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
inferenceSchedulerName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe InferenceSchedulerStatus
status
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus