{-# 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.FraudDetector.PutEventType
-- 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 or updates an event type. An event is a business activity that
-- is evaluated for fraud risk. With Amazon Fraud Detector, you generate
-- fraud predictions for events. An event type defines the structure for an
-- event sent to Amazon Fraud Detector. This includes the variables sent as
-- part of the event, the entity performing the event (such as a customer),
-- and the labels that classify the event. Example event types include
-- online payment transactions, account registrations, and authentications.
module Amazonka.FraudDetector.PutEventType
  ( -- * Creating a Request
    PutEventType (..),
    newPutEventType,

    -- * Request Lenses
    putEventType_description,
    putEventType_eventIngestion,
    putEventType_labels,
    putEventType_tags,
    putEventType_name,
    putEventType_eventVariables,
    putEventType_entityTypes,

    -- * Destructuring the Response
    PutEventTypeResponse (..),
    newPutEventTypeResponse,

    -- * Response Lenses
    putEventTypeResponse_httpStatus,
  )
where

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

-- | /See:/ 'newPutEventType' smart constructor.
data PutEventType = PutEventType'
  { -- | The description of the event type.
    PutEventType -> Maybe Text
description :: Prelude.Maybe Prelude.Text,
    -- | Specifies if ingenstion is enabled or disabled.
    PutEventType -> Maybe EventIngestion
eventIngestion :: Prelude.Maybe EventIngestion,
    -- | The event type labels.
    PutEventType -> Maybe [Text]
labels :: Prelude.Maybe [Prelude.Text],
    -- | A collection of key and value pairs.
    PutEventType -> Maybe [Tag]
tags :: Prelude.Maybe [Tag],
    -- | The name.
    PutEventType -> Text
name :: Prelude.Text,
    -- | The event type variables.
    PutEventType -> NonEmpty Text
eventVariables :: Prelude.NonEmpty Prelude.Text,
    -- | The entity type for the event type. Example entity types: customer,
    -- merchant, account.
    PutEventType -> NonEmpty Text
entityTypes :: Prelude.NonEmpty Prelude.Text
  }
  deriving (PutEventType -> PutEventType -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PutEventType -> PutEventType -> Bool
$c/= :: PutEventType -> PutEventType -> Bool
== :: PutEventType -> PutEventType -> Bool
$c== :: PutEventType -> PutEventType -> Bool
Prelude.Eq, ReadPrec [PutEventType]
ReadPrec PutEventType
Int -> ReadS PutEventType
ReadS [PutEventType]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [PutEventType]
$creadListPrec :: ReadPrec [PutEventType]
readPrec :: ReadPrec PutEventType
$creadPrec :: ReadPrec PutEventType
readList :: ReadS [PutEventType]
$creadList :: ReadS [PutEventType]
readsPrec :: Int -> ReadS PutEventType
$creadsPrec :: Int -> ReadS PutEventType
Prelude.Read, Int -> PutEventType -> ShowS
[PutEventType] -> ShowS
PutEventType -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PutEventType] -> ShowS
$cshowList :: [PutEventType] -> ShowS
show :: PutEventType -> String
$cshow :: PutEventType -> String
showsPrec :: Int -> PutEventType -> ShowS
$cshowsPrec :: Int -> PutEventType -> ShowS
Prelude.Show, forall x. Rep PutEventType x -> PutEventType
forall x. PutEventType -> Rep PutEventType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep PutEventType x -> PutEventType
$cfrom :: forall x. PutEventType -> Rep PutEventType x
Prelude.Generic)

-- |
-- Create a value of 'PutEventType' 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:
--
-- 'description', 'putEventType_description' - The description of the event type.
--
-- 'eventIngestion', 'putEventType_eventIngestion' - Specifies if ingenstion is enabled or disabled.
--
-- 'labels', 'putEventType_labels' - The event type labels.
--
-- 'tags', 'putEventType_tags' - A collection of key and value pairs.
--
-- 'name', 'putEventType_name' - The name.
--
-- 'eventVariables', 'putEventType_eventVariables' - The event type variables.
--
-- 'entityTypes', 'putEventType_entityTypes' - The entity type for the event type. Example entity types: customer,
-- merchant, account.
newPutEventType ::
  -- | 'name'
  Prelude.Text ->
  -- | 'eventVariables'
  Prelude.NonEmpty Prelude.Text ->
  -- | 'entityTypes'
  Prelude.NonEmpty Prelude.Text ->
  PutEventType
newPutEventType :: Text -> NonEmpty Text -> NonEmpty Text -> PutEventType
newPutEventType Text
pName_ NonEmpty Text
pEventVariables_ NonEmpty Text
pEntityTypes_ =
  PutEventType'
    { $sel:description:PutEventType' :: Maybe Text
description = forall a. Maybe a
Prelude.Nothing,
      $sel:eventIngestion:PutEventType' :: Maybe EventIngestion
eventIngestion = forall a. Maybe a
Prelude.Nothing,
      $sel:labels:PutEventType' :: Maybe [Text]
labels = forall a. Maybe a
Prelude.Nothing,
      $sel:tags:PutEventType' :: Maybe [Tag]
tags = forall a. Maybe a
Prelude.Nothing,
      $sel:name:PutEventType' :: Text
name = Text
pName_,
      $sel:eventVariables:PutEventType' :: NonEmpty Text
eventVariables =
        forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced forall t b. AReview t b -> b -> t
Lens.# NonEmpty Text
pEventVariables_,
      $sel:entityTypes:PutEventType' :: NonEmpty Text
entityTypes = forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced forall t b. AReview t b -> b -> t
Lens.# NonEmpty Text
pEntityTypes_
    }

-- | The description of the event type.
putEventType_description :: Lens.Lens' PutEventType (Prelude.Maybe Prelude.Text)
putEventType_description :: Lens' PutEventType (Maybe Text)
putEventType_description = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PutEventType' {Maybe Text
description :: Maybe Text
$sel:description:PutEventType' :: PutEventType -> Maybe Text
description} -> Maybe Text
description) (\s :: PutEventType
s@PutEventType' {} Maybe Text
a -> PutEventType
s {$sel:description:PutEventType' :: Maybe Text
description = Maybe Text
a} :: PutEventType)

-- | Specifies if ingenstion is enabled or disabled.
putEventType_eventIngestion :: Lens.Lens' PutEventType (Prelude.Maybe EventIngestion)
putEventType_eventIngestion :: Lens' PutEventType (Maybe EventIngestion)
putEventType_eventIngestion = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PutEventType' {Maybe EventIngestion
eventIngestion :: Maybe EventIngestion
$sel:eventIngestion:PutEventType' :: PutEventType -> Maybe EventIngestion
eventIngestion} -> Maybe EventIngestion
eventIngestion) (\s :: PutEventType
s@PutEventType' {} Maybe EventIngestion
a -> PutEventType
s {$sel:eventIngestion:PutEventType' :: Maybe EventIngestion
eventIngestion = Maybe EventIngestion
a} :: PutEventType)

-- | The event type labels.
putEventType_labels :: Lens.Lens' PutEventType (Prelude.Maybe [Prelude.Text])
putEventType_labels :: Lens' PutEventType (Maybe [Text])
putEventType_labels = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PutEventType' {Maybe [Text]
labels :: Maybe [Text]
$sel:labels:PutEventType' :: PutEventType -> Maybe [Text]
labels} -> Maybe [Text]
labels) (\s :: PutEventType
s@PutEventType' {} Maybe [Text]
a -> PutEventType
s {$sel:labels:PutEventType' :: Maybe [Text]
labels = Maybe [Text]
a} :: PutEventType) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | A collection of key and value pairs.
putEventType_tags :: Lens.Lens' PutEventType (Prelude.Maybe [Tag])
putEventType_tags :: Lens' PutEventType (Maybe [Tag])
putEventType_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PutEventType' {Maybe [Tag]
tags :: Maybe [Tag]
$sel:tags:PutEventType' :: PutEventType -> Maybe [Tag]
tags} -> Maybe [Tag]
tags) (\s :: PutEventType
s@PutEventType' {} Maybe [Tag]
a -> PutEventType
s {$sel:tags:PutEventType' :: Maybe [Tag]
tags = Maybe [Tag]
a} :: PutEventType) 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.
putEventType_name :: Lens.Lens' PutEventType Prelude.Text
putEventType_name :: Lens' PutEventType Text
putEventType_name = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PutEventType' {Text
name :: Text
$sel:name:PutEventType' :: PutEventType -> Text
name} -> Text
name) (\s :: PutEventType
s@PutEventType' {} Text
a -> PutEventType
s {$sel:name:PutEventType' :: Text
name = Text
a} :: PutEventType)

-- | The event type variables.
putEventType_eventVariables :: Lens.Lens' PutEventType (Prelude.NonEmpty Prelude.Text)
putEventType_eventVariables :: Lens' PutEventType (NonEmpty Text)
putEventType_eventVariables = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PutEventType' {NonEmpty Text
eventVariables :: NonEmpty Text
$sel:eventVariables:PutEventType' :: PutEventType -> NonEmpty Text
eventVariables} -> NonEmpty Text
eventVariables) (\s :: PutEventType
s@PutEventType' {} NonEmpty Text
a -> PutEventType
s {$sel:eventVariables:PutEventType' :: NonEmpty Text
eventVariables = NonEmpty Text
a} :: PutEventType) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The entity type for the event type. Example entity types: customer,
-- merchant, account.
putEventType_entityTypes :: Lens.Lens' PutEventType (Prelude.NonEmpty Prelude.Text)
putEventType_entityTypes :: Lens' PutEventType (NonEmpty Text)
putEventType_entityTypes = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PutEventType' {NonEmpty Text
entityTypes :: NonEmpty Text
$sel:entityTypes:PutEventType' :: PutEventType -> NonEmpty Text
entityTypes} -> NonEmpty Text
entityTypes) (\s :: PutEventType
s@PutEventType' {} NonEmpty Text
a -> PutEventType
s {$sel:entityTypes:PutEventType' :: NonEmpty Text
entityTypes = NonEmpty Text
a} :: PutEventType) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

instance Core.AWSRequest PutEventType where
  type AWSResponse PutEventType = PutEventTypeResponse
  request :: (Service -> Service) -> PutEventType -> Request PutEventType
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 PutEventType
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse PutEventType)))
response =
    forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> () -> Either String (AWSResponse a))
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveEmpty
      ( \Int
s ResponseHeaders
h ()
x ->
          Int -> PutEventTypeResponse
PutEventTypeResponse'
            forall (f :: * -> *) a b. Functor 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 PutEventType where
  hashWithSalt :: Int -> PutEventType -> Int
hashWithSalt Int
_salt PutEventType' {Maybe [Text]
Maybe [Tag]
Maybe Text
Maybe EventIngestion
NonEmpty Text
Text
entityTypes :: NonEmpty Text
eventVariables :: NonEmpty Text
name :: Text
tags :: Maybe [Tag]
labels :: Maybe [Text]
eventIngestion :: Maybe EventIngestion
description :: Maybe Text
$sel:entityTypes:PutEventType' :: PutEventType -> NonEmpty Text
$sel:eventVariables:PutEventType' :: PutEventType -> NonEmpty Text
$sel:name:PutEventType' :: PutEventType -> Text
$sel:tags:PutEventType' :: PutEventType -> Maybe [Tag]
$sel:labels:PutEventType' :: PutEventType -> Maybe [Text]
$sel:eventIngestion:PutEventType' :: PutEventType -> Maybe EventIngestion
$sel:description:PutEventType' :: PutEventType -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
description
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe EventIngestion
eventIngestion
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Text]
labels
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Tag]
tags
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
name
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` NonEmpty Text
eventVariables
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` NonEmpty Text
entityTypes

instance Prelude.NFData PutEventType where
  rnf :: PutEventType -> ()
rnf PutEventType' {Maybe [Text]
Maybe [Tag]
Maybe Text
Maybe EventIngestion
NonEmpty Text
Text
entityTypes :: NonEmpty Text
eventVariables :: NonEmpty Text
name :: Text
tags :: Maybe [Tag]
labels :: Maybe [Text]
eventIngestion :: Maybe EventIngestion
description :: Maybe Text
$sel:entityTypes:PutEventType' :: PutEventType -> NonEmpty Text
$sel:eventVariables:PutEventType' :: PutEventType -> NonEmpty Text
$sel:name:PutEventType' :: PutEventType -> Text
$sel:tags:PutEventType' :: PutEventType -> Maybe [Tag]
$sel:labels:PutEventType' :: PutEventType -> Maybe [Text]
$sel:eventIngestion:PutEventType' :: PutEventType -> Maybe EventIngestion
$sel:description:PutEventType' :: PutEventType -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
description
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe EventIngestion
eventIngestion
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Text]
labels
      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
name
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf NonEmpty Text
eventVariables
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf NonEmpty Text
entityTypes

instance Data.ToHeaders PutEventType where
  toHeaders :: PutEventType -> 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
"AWSHawksNestServiceFacade.PutEventType" ::
                          Prelude.ByteString
                      ),
            HeaderName
"Content-Type"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"application/x-amz-json-1.1" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Data.ToJSON PutEventType where
  toJSON :: PutEventType -> Value
toJSON PutEventType' {Maybe [Text]
Maybe [Tag]
Maybe Text
Maybe EventIngestion
NonEmpty Text
Text
entityTypes :: NonEmpty Text
eventVariables :: NonEmpty Text
name :: Text
tags :: Maybe [Tag]
labels :: Maybe [Text]
eventIngestion :: Maybe EventIngestion
description :: Maybe Text
$sel:entityTypes:PutEventType' :: PutEventType -> NonEmpty Text
$sel:eventVariables:PutEventType' :: PutEventType -> NonEmpty Text
$sel:name:PutEventType' :: PutEventType -> Text
$sel:tags:PutEventType' :: PutEventType -> Maybe [Tag]
$sel:labels:PutEventType' :: PutEventType -> Maybe [Text]
$sel:eventIngestion:PutEventType' :: PutEventType -> Maybe EventIngestion
$sel:description:PutEventType' :: PutEventType -> Maybe Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"description" 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
description,
            (Key
"eventIngestion" 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 EventIngestion
eventIngestion,
            (Key
"labels" 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]
labels,
            (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
"name" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
name),
            forall a. a -> Maybe a
Prelude.Just
              (Key
"eventVariables" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= NonEmpty Text
eventVariables),
            forall a. a -> Maybe a
Prelude.Just (Key
"entityTypes" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= NonEmpty Text
entityTypes)
          ]
      )

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

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

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

-- |
-- Create a value of 'PutEventTypeResponse' 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:
--
-- 'httpStatus', 'putEventTypeResponse_httpStatus' - The response's http status code.
newPutEventTypeResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  PutEventTypeResponse
newPutEventTypeResponse :: Int -> PutEventTypeResponse
newPutEventTypeResponse Int
pHttpStatus_ =
  PutEventTypeResponse' {$sel:httpStatus:PutEventTypeResponse' :: Int
httpStatus = Int
pHttpStatus_}

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

instance Prelude.NFData PutEventTypeResponse where
  rnf :: PutEventTypeResponse -> ()
rnf PutEventTypeResponse' {Int
httpStatus :: Int
$sel:httpStatus:PutEventTypeResponse' :: PutEventTypeResponse -> Int
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus