{-# 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.IoTEvents.CreateDetectorModel
-- 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 detector model.
module Amazonka.IoTEvents.CreateDetectorModel
  ( -- * Creating a Request
    CreateDetectorModel (..),
    newCreateDetectorModel,

    -- * Request Lenses
    createDetectorModel_detectorModelDescription,
    createDetectorModel_evaluationMethod,
    createDetectorModel_key,
    createDetectorModel_tags,
    createDetectorModel_detectorModelName,
    createDetectorModel_detectorModelDefinition,
    createDetectorModel_roleArn,

    -- * Destructuring the Response
    CreateDetectorModelResponse (..),
    newCreateDetectorModelResponse,

    -- * Response Lenses
    createDetectorModelResponse_detectorModelConfiguration,
    createDetectorModelResponse_httpStatus,
  )
where

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

-- | /See:/ 'newCreateDetectorModel' smart constructor.
data CreateDetectorModel = CreateDetectorModel'
  { -- | A brief description of the detector model.
    CreateDetectorModel -> Maybe Text
detectorModelDescription :: Prelude.Maybe Prelude.Text,
    -- | Information about the order in which events are evaluated and how
    -- actions are executed.
    CreateDetectorModel -> Maybe EvaluationMethod
evaluationMethod :: Prelude.Maybe EvaluationMethod,
    -- | The input attribute key used to identify a device or system to create a
    -- detector (an instance of the detector model) and then to route each
    -- input received to the appropriate detector (instance). This parameter
    -- uses a JSON-path expression in the message payload of each input to
    -- specify the attribute-value pair that is used to identify the device
    -- associated with the input.
    CreateDetectorModel -> Maybe Text
key :: Prelude.Maybe Prelude.Text,
    -- | Metadata that can be used to manage the detector model.
    CreateDetectorModel -> Maybe [Tag]
tags :: Prelude.Maybe [Tag],
    -- | The name of the detector model.
    CreateDetectorModel -> Text
detectorModelName :: Prelude.Text,
    -- | Information that defines how the detectors operate.
    CreateDetectorModel -> DetectorModelDefinition
detectorModelDefinition :: DetectorModelDefinition,
    -- | The ARN of the role that grants permission to AWS IoT Events to perform
    -- its operations.
    CreateDetectorModel -> Text
roleArn :: Prelude.Text
  }
  deriving (CreateDetectorModel -> CreateDetectorModel -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateDetectorModel -> CreateDetectorModel -> Bool
$c/= :: CreateDetectorModel -> CreateDetectorModel -> Bool
== :: CreateDetectorModel -> CreateDetectorModel -> Bool
$c== :: CreateDetectorModel -> CreateDetectorModel -> Bool
Prelude.Eq, ReadPrec [CreateDetectorModel]
ReadPrec CreateDetectorModel
Int -> ReadS CreateDetectorModel
ReadS [CreateDetectorModel]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateDetectorModel]
$creadListPrec :: ReadPrec [CreateDetectorModel]
readPrec :: ReadPrec CreateDetectorModel
$creadPrec :: ReadPrec CreateDetectorModel
readList :: ReadS [CreateDetectorModel]
$creadList :: ReadS [CreateDetectorModel]
readsPrec :: Int -> ReadS CreateDetectorModel
$creadsPrec :: Int -> ReadS CreateDetectorModel
Prelude.Read, Int -> CreateDetectorModel -> ShowS
[CreateDetectorModel] -> ShowS
CreateDetectorModel -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateDetectorModel] -> ShowS
$cshowList :: [CreateDetectorModel] -> ShowS
show :: CreateDetectorModel -> String
$cshow :: CreateDetectorModel -> String
showsPrec :: Int -> CreateDetectorModel -> ShowS
$cshowsPrec :: Int -> CreateDetectorModel -> ShowS
Prelude.Show, forall x. Rep CreateDetectorModel x -> CreateDetectorModel
forall x. CreateDetectorModel -> Rep CreateDetectorModel x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateDetectorModel x -> CreateDetectorModel
$cfrom :: forall x. CreateDetectorModel -> Rep CreateDetectorModel x
Prelude.Generic)

-- |
-- Create a value of 'CreateDetectorModel' 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:
--
-- 'detectorModelDescription', 'createDetectorModel_detectorModelDescription' - A brief description of the detector model.
--
-- 'evaluationMethod', 'createDetectorModel_evaluationMethod' - Information about the order in which events are evaluated and how
-- actions are executed.
--
-- 'key', 'createDetectorModel_key' - The input attribute key used to identify a device or system to create a
-- detector (an instance of the detector model) and then to route each
-- input received to the appropriate detector (instance). This parameter
-- uses a JSON-path expression in the message payload of each input to
-- specify the attribute-value pair that is used to identify the device
-- associated with the input.
--
-- 'tags', 'createDetectorModel_tags' - Metadata that can be used to manage the detector model.
--
-- 'detectorModelName', 'createDetectorModel_detectorModelName' - The name of the detector model.
--
-- 'detectorModelDefinition', 'createDetectorModel_detectorModelDefinition' - Information that defines how the detectors operate.
--
-- 'roleArn', 'createDetectorModel_roleArn' - The ARN of the role that grants permission to AWS IoT Events to perform
-- its operations.
newCreateDetectorModel ::
  -- | 'detectorModelName'
  Prelude.Text ->
  -- | 'detectorModelDefinition'
  DetectorModelDefinition ->
  -- | 'roleArn'
  Prelude.Text ->
  CreateDetectorModel
newCreateDetectorModel :: Text -> DetectorModelDefinition -> Text -> CreateDetectorModel
newCreateDetectorModel
  Text
pDetectorModelName_
  DetectorModelDefinition
pDetectorModelDefinition_
  Text
pRoleArn_ =
    CreateDetectorModel'
      { $sel:detectorModelDescription:CreateDetectorModel' :: Maybe Text
detectorModelDescription =
          forall a. Maybe a
Prelude.Nothing,
        $sel:evaluationMethod:CreateDetectorModel' :: Maybe EvaluationMethod
evaluationMethod = forall a. Maybe a
Prelude.Nothing,
        $sel:key:CreateDetectorModel' :: Maybe Text
key = forall a. Maybe a
Prelude.Nothing,
        $sel:tags:CreateDetectorModel' :: Maybe [Tag]
tags = forall a. Maybe a
Prelude.Nothing,
        $sel:detectorModelName:CreateDetectorModel' :: Text
detectorModelName = Text
pDetectorModelName_,
        $sel:detectorModelDefinition:CreateDetectorModel' :: DetectorModelDefinition
detectorModelDefinition = DetectorModelDefinition
pDetectorModelDefinition_,
        $sel:roleArn:CreateDetectorModel' :: Text
roleArn = Text
pRoleArn_
      }

-- | A brief description of the detector model.
createDetectorModel_detectorModelDescription :: Lens.Lens' CreateDetectorModel (Prelude.Maybe Prelude.Text)
createDetectorModel_detectorModelDescription :: Lens' CreateDetectorModel (Maybe Text)
createDetectorModel_detectorModelDescription = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateDetectorModel' {Maybe Text
detectorModelDescription :: Maybe Text
$sel:detectorModelDescription:CreateDetectorModel' :: CreateDetectorModel -> Maybe Text
detectorModelDescription} -> Maybe Text
detectorModelDescription) (\s :: CreateDetectorModel
s@CreateDetectorModel' {} Maybe Text
a -> CreateDetectorModel
s {$sel:detectorModelDescription:CreateDetectorModel' :: Maybe Text
detectorModelDescription = Maybe Text
a} :: CreateDetectorModel)

-- | Information about the order in which events are evaluated and how
-- actions are executed.
createDetectorModel_evaluationMethod :: Lens.Lens' CreateDetectorModel (Prelude.Maybe EvaluationMethod)
createDetectorModel_evaluationMethod :: Lens' CreateDetectorModel (Maybe EvaluationMethod)
createDetectorModel_evaluationMethod = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateDetectorModel' {Maybe EvaluationMethod
evaluationMethod :: Maybe EvaluationMethod
$sel:evaluationMethod:CreateDetectorModel' :: CreateDetectorModel -> Maybe EvaluationMethod
evaluationMethod} -> Maybe EvaluationMethod
evaluationMethod) (\s :: CreateDetectorModel
s@CreateDetectorModel' {} Maybe EvaluationMethod
a -> CreateDetectorModel
s {$sel:evaluationMethod:CreateDetectorModel' :: Maybe EvaluationMethod
evaluationMethod = Maybe EvaluationMethod
a} :: CreateDetectorModel)

-- | The input attribute key used to identify a device or system to create a
-- detector (an instance of the detector model) and then to route each
-- input received to the appropriate detector (instance). This parameter
-- uses a JSON-path expression in the message payload of each input to
-- specify the attribute-value pair that is used to identify the device
-- associated with the input.
createDetectorModel_key :: Lens.Lens' CreateDetectorModel (Prelude.Maybe Prelude.Text)
createDetectorModel_key :: Lens' CreateDetectorModel (Maybe Text)
createDetectorModel_key = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateDetectorModel' {Maybe Text
key :: Maybe Text
$sel:key:CreateDetectorModel' :: CreateDetectorModel -> Maybe Text
key} -> Maybe Text
key) (\s :: CreateDetectorModel
s@CreateDetectorModel' {} Maybe Text
a -> CreateDetectorModel
s {$sel:key:CreateDetectorModel' :: Maybe Text
key = Maybe Text
a} :: CreateDetectorModel)

-- | Metadata that can be used to manage the detector model.
createDetectorModel_tags :: Lens.Lens' CreateDetectorModel (Prelude.Maybe [Tag])
createDetectorModel_tags :: Lens' CreateDetectorModel (Maybe [Tag])
createDetectorModel_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateDetectorModel' {Maybe [Tag]
tags :: Maybe [Tag]
$sel:tags:CreateDetectorModel' :: CreateDetectorModel -> Maybe [Tag]
tags} -> Maybe [Tag]
tags) (\s :: CreateDetectorModel
s@CreateDetectorModel' {} Maybe [Tag]
a -> CreateDetectorModel
s {$sel:tags:CreateDetectorModel' :: Maybe [Tag]
tags = Maybe [Tag]
a} :: CreateDetectorModel) 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 detector model.
createDetectorModel_detectorModelName :: Lens.Lens' CreateDetectorModel Prelude.Text
createDetectorModel_detectorModelName :: Lens' CreateDetectorModel Text
createDetectorModel_detectorModelName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateDetectorModel' {Text
detectorModelName :: Text
$sel:detectorModelName:CreateDetectorModel' :: CreateDetectorModel -> Text
detectorModelName} -> Text
detectorModelName) (\s :: CreateDetectorModel
s@CreateDetectorModel' {} Text
a -> CreateDetectorModel
s {$sel:detectorModelName:CreateDetectorModel' :: Text
detectorModelName = Text
a} :: CreateDetectorModel)

-- | Information that defines how the detectors operate.
createDetectorModel_detectorModelDefinition :: Lens.Lens' CreateDetectorModel DetectorModelDefinition
createDetectorModel_detectorModelDefinition :: Lens' CreateDetectorModel DetectorModelDefinition
createDetectorModel_detectorModelDefinition = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateDetectorModel' {DetectorModelDefinition
detectorModelDefinition :: DetectorModelDefinition
$sel:detectorModelDefinition:CreateDetectorModel' :: CreateDetectorModel -> DetectorModelDefinition
detectorModelDefinition} -> DetectorModelDefinition
detectorModelDefinition) (\s :: CreateDetectorModel
s@CreateDetectorModel' {} DetectorModelDefinition
a -> CreateDetectorModel
s {$sel:detectorModelDefinition:CreateDetectorModel' :: DetectorModelDefinition
detectorModelDefinition = DetectorModelDefinition
a} :: CreateDetectorModel)

-- | The ARN of the role that grants permission to AWS IoT Events to perform
-- its operations.
createDetectorModel_roleArn :: Lens.Lens' CreateDetectorModel Prelude.Text
createDetectorModel_roleArn :: Lens' CreateDetectorModel Text
createDetectorModel_roleArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateDetectorModel' {Text
roleArn :: Text
$sel:roleArn:CreateDetectorModel' :: CreateDetectorModel -> Text
roleArn} -> Text
roleArn) (\s :: CreateDetectorModel
s@CreateDetectorModel' {} Text
a -> CreateDetectorModel
s {$sel:roleArn:CreateDetectorModel' :: Text
roleArn = Text
a} :: CreateDetectorModel)

instance Core.AWSRequest CreateDetectorModel where
  type
    AWSResponse CreateDetectorModel =
      CreateDetectorModelResponse
  request :: (Service -> Service)
-> CreateDetectorModel -> Request CreateDetectorModel
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 CreateDetectorModel
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse CreateDetectorModel)))
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 DetectorModelConfiguration
-> Int -> CreateDetectorModelResponse
CreateDetectorModelResponse'
            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
"detectorModelConfiguration")
            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 CreateDetectorModel where
  hashWithSalt :: Int -> CreateDetectorModel -> Int
hashWithSalt Int
_salt CreateDetectorModel' {Maybe [Tag]
Maybe Text
Maybe EvaluationMethod
Text
DetectorModelDefinition
roleArn :: Text
detectorModelDefinition :: DetectorModelDefinition
detectorModelName :: Text
tags :: Maybe [Tag]
key :: Maybe Text
evaluationMethod :: Maybe EvaluationMethod
detectorModelDescription :: Maybe Text
$sel:roleArn:CreateDetectorModel' :: CreateDetectorModel -> Text
$sel:detectorModelDefinition:CreateDetectorModel' :: CreateDetectorModel -> DetectorModelDefinition
$sel:detectorModelName:CreateDetectorModel' :: CreateDetectorModel -> Text
$sel:tags:CreateDetectorModel' :: CreateDetectorModel -> Maybe [Tag]
$sel:key:CreateDetectorModel' :: CreateDetectorModel -> Maybe Text
$sel:evaluationMethod:CreateDetectorModel' :: CreateDetectorModel -> Maybe EvaluationMethod
$sel:detectorModelDescription:CreateDetectorModel' :: CreateDetectorModel -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
detectorModelDescription
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe EvaluationMethod
evaluationMethod
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
key
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Tag]
tags
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
detectorModelName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` DetectorModelDefinition
detectorModelDefinition
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
roleArn

instance Prelude.NFData CreateDetectorModel where
  rnf :: CreateDetectorModel -> ()
rnf CreateDetectorModel' {Maybe [Tag]
Maybe Text
Maybe EvaluationMethod
Text
DetectorModelDefinition
roleArn :: Text
detectorModelDefinition :: DetectorModelDefinition
detectorModelName :: Text
tags :: Maybe [Tag]
key :: Maybe Text
evaluationMethod :: Maybe EvaluationMethod
detectorModelDescription :: Maybe Text
$sel:roleArn:CreateDetectorModel' :: CreateDetectorModel -> Text
$sel:detectorModelDefinition:CreateDetectorModel' :: CreateDetectorModel -> DetectorModelDefinition
$sel:detectorModelName:CreateDetectorModel' :: CreateDetectorModel -> Text
$sel:tags:CreateDetectorModel' :: CreateDetectorModel -> Maybe [Tag]
$sel:key:CreateDetectorModel' :: CreateDetectorModel -> Maybe Text
$sel:evaluationMethod:CreateDetectorModel' :: CreateDetectorModel -> Maybe EvaluationMethod
$sel:detectorModelDescription:CreateDetectorModel' :: CreateDetectorModel -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
detectorModelDescription
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe EvaluationMethod
evaluationMethod
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
key
      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
detectorModelName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf DetectorModelDefinition
detectorModelDefinition
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
roleArn

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

instance Data.ToJSON CreateDetectorModel where
  toJSON :: CreateDetectorModel -> Value
toJSON CreateDetectorModel' {Maybe [Tag]
Maybe Text
Maybe EvaluationMethod
Text
DetectorModelDefinition
roleArn :: Text
detectorModelDefinition :: DetectorModelDefinition
detectorModelName :: Text
tags :: Maybe [Tag]
key :: Maybe Text
evaluationMethod :: Maybe EvaluationMethod
detectorModelDescription :: Maybe Text
$sel:roleArn:CreateDetectorModel' :: CreateDetectorModel -> Text
$sel:detectorModelDefinition:CreateDetectorModel' :: CreateDetectorModel -> DetectorModelDefinition
$sel:detectorModelName:CreateDetectorModel' :: CreateDetectorModel -> Text
$sel:tags:CreateDetectorModel' :: CreateDetectorModel -> Maybe [Tag]
$sel:key:CreateDetectorModel' :: CreateDetectorModel -> Maybe Text
$sel:evaluationMethod:CreateDetectorModel' :: CreateDetectorModel -> Maybe EvaluationMethod
$sel:detectorModelDescription:CreateDetectorModel' :: CreateDetectorModel -> Maybe Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"detectorModelDescription" 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
detectorModelDescription,
            (Key
"evaluationMethod" 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 EvaluationMethod
evaluationMethod,
            (Key
"key" 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
key,
            (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
"detectorModelName" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
detectorModelName),
            forall a. a -> Maybe a
Prelude.Just
              ( Key
"detectorModelDefinition"
                  forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= DetectorModelDefinition
detectorModelDefinition
              ),
            forall a. a -> Maybe a
Prelude.Just (Key
"roleArn" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
roleArn)
          ]
      )

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

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

-- | /See:/ 'newCreateDetectorModelResponse' smart constructor.
data CreateDetectorModelResponse = CreateDetectorModelResponse'
  { -- | Information about how the detector model is configured.
    CreateDetectorModelResponse -> Maybe DetectorModelConfiguration
detectorModelConfiguration :: Prelude.Maybe DetectorModelConfiguration,
    -- | The response's http status code.
    CreateDetectorModelResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (CreateDetectorModelResponse -> CreateDetectorModelResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateDetectorModelResponse -> CreateDetectorModelResponse -> Bool
$c/= :: CreateDetectorModelResponse -> CreateDetectorModelResponse -> Bool
== :: CreateDetectorModelResponse -> CreateDetectorModelResponse -> Bool
$c== :: CreateDetectorModelResponse -> CreateDetectorModelResponse -> Bool
Prelude.Eq, ReadPrec [CreateDetectorModelResponse]
ReadPrec CreateDetectorModelResponse
Int -> ReadS CreateDetectorModelResponse
ReadS [CreateDetectorModelResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateDetectorModelResponse]
$creadListPrec :: ReadPrec [CreateDetectorModelResponse]
readPrec :: ReadPrec CreateDetectorModelResponse
$creadPrec :: ReadPrec CreateDetectorModelResponse
readList :: ReadS [CreateDetectorModelResponse]
$creadList :: ReadS [CreateDetectorModelResponse]
readsPrec :: Int -> ReadS CreateDetectorModelResponse
$creadsPrec :: Int -> ReadS CreateDetectorModelResponse
Prelude.Read, Int -> CreateDetectorModelResponse -> ShowS
[CreateDetectorModelResponse] -> ShowS
CreateDetectorModelResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateDetectorModelResponse] -> ShowS
$cshowList :: [CreateDetectorModelResponse] -> ShowS
show :: CreateDetectorModelResponse -> String
$cshow :: CreateDetectorModelResponse -> String
showsPrec :: Int -> CreateDetectorModelResponse -> ShowS
$cshowsPrec :: Int -> CreateDetectorModelResponse -> ShowS
Prelude.Show, forall x.
Rep CreateDetectorModelResponse x -> CreateDetectorModelResponse
forall x.
CreateDetectorModelResponse -> Rep CreateDetectorModelResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep CreateDetectorModelResponse x -> CreateDetectorModelResponse
$cfrom :: forall x.
CreateDetectorModelResponse -> Rep CreateDetectorModelResponse x
Prelude.Generic)

-- |
-- Create a value of 'CreateDetectorModelResponse' 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:
--
-- 'detectorModelConfiguration', 'createDetectorModelResponse_detectorModelConfiguration' - Information about how the detector model is configured.
--
-- 'httpStatus', 'createDetectorModelResponse_httpStatus' - The response's http status code.
newCreateDetectorModelResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  CreateDetectorModelResponse
newCreateDetectorModelResponse :: Int -> CreateDetectorModelResponse
newCreateDetectorModelResponse Int
pHttpStatus_ =
  CreateDetectorModelResponse'
    { $sel:detectorModelConfiguration:CreateDetectorModelResponse' :: Maybe DetectorModelConfiguration
detectorModelConfiguration =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:CreateDetectorModelResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | Information about how the detector model is configured.
createDetectorModelResponse_detectorModelConfiguration :: Lens.Lens' CreateDetectorModelResponse (Prelude.Maybe DetectorModelConfiguration)
createDetectorModelResponse_detectorModelConfiguration :: Lens'
  CreateDetectorModelResponse (Maybe DetectorModelConfiguration)
createDetectorModelResponse_detectorModelConfiguration = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateDetectorModelResponse' {Maybe DetectorModelConfiguration
detectorModelConfiguration :: Maybe DetectorModelConfiguration
$sel:detectorModelConfiguration:CreateDetectorModelResponse' :: CreateDetectorModelResponse -> Maybe DetectorModelConfiguration
detectorModelConfiguration} -> Maybe DetectorModelConfiguration
detectorModelConfiguration) (\s :: CreateDetectorModelResponse
s@CreateDetectorModelResponse' {} Maybe DetectorModelConfiguration
a -> CreateDetectorModelResponse
s {$sel:detectorModelConfiguration:CreateDetectorModelResponse' :: Maybe DetectorModelConfiguration
detectorModelConfiguration = Maybe DetectorModelConfiguration
a} :: CreateDetectorModelResponse)

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

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