{-# 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.IoT.CreateAuthorizer
-- 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 an authorizer.
--
-- Requires permission to access the
-- <https://docs.aws.amazon.com/service-authorization/latest/reference/list_awsiot.html#awsiot-actions-as-permissions CreateAuthorizer>
-- action.
module Amazonka.IoT.CreateAuthorizer
  ( -- * Creating a Request
    CreateAuthorizer (..),
    newCreateAuthorizer,

    -- * Request Lenses
    createAuthorizer_enableCachingForHttp,
    createAuthorizer_signingDisabled,
    createAuthorizer_status,
    createAuthorizer_tags,
    createAuthorizer_tokenKeyName,
    createAuthorizer_tokenSigningPublicKeys,
    createAuthorizer_authorizerName,
    createAuthorizer_authorizerFunctionArn,

    -- * Destructuring the Response
    CreateAuthorizerResponse (..),
    newCreateAuthorizerResponse,

    -- * Response Lenses
    createAuthorizerResponse_authorizerArn,
    createAuthorizerResponse_authorizerName,
    createAuthorizerResponse_httpStatus,
  )
where

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

-- | /See:/ 'newCreateAuthorizer' smart constructor.
data CreateAuthorizer = CreateAuthorizer'
  { -- | When @true@, the result from the authorizer’s Lambda function is cached
    -- for clients that use persistent HTTP connections. The results are cached
    -- for the time specified by the Lambda function in
    -- @refreshAfterInSeconds@. This value does not affect authorization of
    -- clients that use MQTT connections.
    --
    -- The default value is @false@.
    CreateAuthorizer -> Maybe Bool
enableCachingForHttp :: Prelude.Maybe Prelude.Bool,
    -- | Specifies whether IoT validates the token signature in an authorization
    -- request.
    CreateAuthorizer -> Maybe Bool
signingDisabled :: Prelude.Maybe Prelude.Bool,
    -- | The status of the create authorizer request.
    CreateAuthorizer -> Maybe AuthorizerStatus
status :: Prelude.Maybe AuthorizerStatus,
    -- | Metadata which can be used to manage the custom authorizer.
    --
    -- For URI Request parameters use format: ...key1=value1&key2=value2...
    --
    -- For the CLI command-line parameter use format: &&tags
    -- \"key1=value1&key2=value2...\"
    --
    -- For the cli-input-json file use format: \"tags\":
    -- \"key1=value1&key2=value2...\"
    CreateAuthorizer -> Maybe [Tag]
tags :: Prelude.Maybe [Tag],
    -- | The name of the token key used to extract the token from the HTTP
    -- headers.
    CreateAuthorizer -> Maybe Text
tokenKeyName :: Prelude.Maybe Prelude.Text,
    -- | The public keys used to verify the digital signature returned by your
    -- custom authentication service.
    CreateAuthorizer -> Maybe (HashMap Text Text)
tokenSigningPublicKeys :: Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text),
    -- | The authorizer name.
    CreateAuthorizer -> Text
authorizerName :: Prelude.Text,
    -- | The ARN of the authorizer\'s Lambda function.
    CreateAuthorizer -> Text
authorizerFunctionArn :: Prelude.Text
  }
  deriving (CreateAuthorizer -> CreateAuthorizer -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateAuthorizer -> CreateAuthorizer -> Bool
$c/= :: CreateAuthorizer -> CreateAuthorizer -> Bool
== :: CreateAuthorizer -> CreateAuthorizer -> Bool
$c== :: CreateAuthorizer -> CreateAuthorizer -> Bool
Prelude.Eq, ReadPrec [CreateAuthorizer]
ReadPrec CreateAuthorizer
Int -> ReadS CreateAuthorizer
ReadS [CreateAuthorizer]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateAuthorizer]
$creadListPrec :: ReadPrec [CreateAuthorizer]
readPrec :: ReadPrec CreateAuthorizer
$creadPrec :: ReadPrec CreateAuthorizer
readList :: ReadS [CreateAuthorizer]
$creadList :: ReadS [CreateAuthorizer]
readsPrec :: Int -> ReadS CreateAuthorizer
$creadsPrec :: Int -> ReadS CreateAuthorizer
Prelude.Read, Int -> CreateAuthorizer -> ShowS
[CreateAuthorizer] -> ShowS
CreateAuthorizer -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateAuthorizer] -> ShowS
$cshowList :: [CreateAuthorizer] -> ShowS
show :: CreateAuthorizer -> String
$cshow :: CreateAuthorizer -> String
showsPrec :: Int -> CreateAuthorizer -> ShowS
$cshowsPrec :: Int -> CreateAuthorizer -> ShowS
Prelude.Show, forall x. Rep CreateAuthorizer x -> CreateAuthorizer
forall x. CreateAuthorizer -> Rep CreateAuthorizer x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateAuthorizer x -> CreateAuthorizer
$cfrom :: forall x. CreateAuthorizer -> Rep CreateAuthorizer x
Prelude.Generic)

-- |
-- Create a value of 'CreateAuthorizer' 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:
--
-- 'enableCachingForHttp', 'createAuthorizer_enableCachingForHttp' - When @true@, the result from the authorizer’s Lambda function is cached
-- for clients that use persistent HTTP connections. The results are cached
-- for the time specified by the Lambda function in
-- @refreshAfterInSeconds@. This value does not affect authorization of
-- clients that use MQTT connections.
--
-- The default value is @false@.
--
-- 'signingDisabled', 'createAuthorizer_signingDisabled' - Specifies whether IoT validates the token signature in an authorization
-- request.
--
-- 'status', 'createAuthorizer_status' - The status of the create authorizer request.
--
-- 'tags', 'createAuthorizer_tags' - Metadata which can be used to manage the custom authorizer.
--
-- For URI Request parameters use format: ...key1=value1&key2=value2...
--
-- For the CLI command-line parameter use format: &&tags
-- \"key1=value1&key2=value2...\"
--
-- For the cli-input-json file use format: \"tags\":
-- \"key1=value1&key2=value2...\"
--
-- 'tokenKeyName', 'createAuthorizer_tokenKeyName' - The name of the token key used to extract the token from the HTTP
-- headers.
--
-- 'tokenSigningPublicKeys', 'createAuthorizer_tokenSigningPublicKeys' - The public keys used to verify the digital signature returned by your
-- custom authentication service.
--
-- 'authorizerName', 'createAuthorizer_authorizerName' - The authorizer name.
--
-- 'authorizerFunctionArn', 'createAuthorizer_authorizerFunctionArn' - The ARN of the authorizer\'s Lambda function.
newCreateAuthorizer ::
  -- | 'authorizerName'
  Prelude.Text ->
  -- | 'authorizerFunctionArn'
  Prelude.Text ->
  CreateAuthorizer
newCreateAuthorizer :: Text -> Text -> CreateAuthorizer
newCreateAuthorizer
  Text
pAuthorizerName_
  Text
pAuthorizerFunctionArn_ =
    CreateAuthorizer'
      { $sel:enableCachingForHttp:CreateAuthorizer' :: Maybe Bool
enableCachingForHttp =
          forall a. Maybe a
Prelude.Nothing,
        $sel:signingDisabled:CreateAuthorizer' :: Maybe Bool
signingDisabled = forall a. Maybe a
Prelude.Nothing,
        $sel:status:CreateAuthorizer' :: Maybe AuthorizerStatus
status = forall a. Maybe a
Prelude.Nothing,
        $sel:tags:CreateAuthorizer' :: Maybe [Tag]
tags = forall a. Maybe a
Prelude.Nothing,
        $sel:tokenKeyName:CreateAuthorizer' :: Maybe Text
tokenKeyName = forall a. Maybe a
Prelude.Nothing,
        $sel:tokenSigningPublicKeys:CreateAuthorizer' :: Maybe (HashMap Text Text)
tokenSigningPublicKeys = forall a. Maybe a
Prelude.Nothing,
        $sel:authorizerName:CreateAuthorizer' :: Text
authorizerName = Text
pAuthorizerName_,
        $sel:authorizerFunctionArn:CreateAuthorizer' :: Text
authorizerFunctionArn = Text
pAuthorizerFunctionArn_
      }

-- | When @true@, the result from the authorizer’s Lambda function is cached
-- for clients that use persistent HTTP connections. The results are cached
-- for the time specified by the Lambda function in
-- @refreshAfterInSeconds@. This value does not affect authorization of
-- clients that use MQTT connections.
--
-- The default value is @false@.
createAuthorizer_enableCachingForHttp :: Lens.Lens' CreateAuthorizer (Prelude.Maybe Prelude.Bool)
createAuthorizer_enableCachingForHttp :: Lens' CreateAuthorizer (Maybe Bool)
createAuthorizer_enableCachingForHttp = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateAuthorizer' {Maybe Bool
enableCachingForHttp :: Maybe Bool
$sel:enableCachingForHttp:CreateAuthorizer' :: CreateAuthorizer -> Maybe Bool
enableCachingForHttp} -> Maybe Bool
enableCachingForHttp) (\s :: CreateAuthorizer
s@CreateAuthorizer' {} Maybe Bool
a -> CreateAuthorizer
s {$sel:enableCachingForHttp:CreateAuthorizer' :: Maybe Bool
enableCachingForHttp = Maybe Bool
a} :: CreateAuthorizer)

-- | Specifies whether IoT validates the token signature in an authorization
-- request.
createAuthorizer_signingDisabled :: Lens.Lens' CreateAuthorizer (Prelude.Maybe Prelude.Bool)
createAuthorizer_signingDisabled :: Lens' CreateAuthorizer (Maybe Bool)
createAuthorizer_signingDisabled = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateAuthorizer' {Maybe Bool
signingDisabled :: Maybe Bool
$sel:signingDisabled:CreateAuthorizer' :: CreateAuthorizer -> Maybe Bool
signingDisabled} -> Maybe Bool
signingDisabled) (\s :: CreateAuthorizer
s@CreateAuthorizer' {} Maybe Bool
a -> CreateAuthorizer
s {$sel:signingDisabled:CreateAuthorizer' :: Maybe Bool
signingDisabled = Maybe Bool
a} :: CreateAuthorizer)

-- | The status of the create authorizer request.
createAuthorizer_status :: Lens.Lens' CreateAuthorizer (Prelude.Maybe AuthorizerStatus)
createAuthorizer_status :: Lens' CreateAuthorizer (Maybe AuthorizerStatus)
createAuthorizer_status = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateAuthorizer' {Maybe AuthorizerStatus
status :: Maybe AuthorizerStatus
$sel:status:CreateAuthorizer' :: CreateAuthorizer -> Maybe AuthorizerStatus
status} -> Maybe AuthorizerStatus
status) (\s :: CreateAuthorizer
s@CreateAuthorizer' {} Maybe AuthorizerStatus
a -> CreateAuthorizer
s {$sel:status:CreateAuthorizer' :: Maybe AuthorizerStatus
status = Maybe AuthorizerStatus
a} :: CreateAuthorizer)

-- | Metadata which can be used to manage the custom authorizer.
--
-- For URI Request parameters use format: ...key1=value1&key2=value2...
--
-- For the CLI command-line parameter use format: &&tags
-- \"key1=value1&key2=value2...\"
--
-- For the cli-input-json file use format: \"tags\":
-- \"key1=value1&key2=value2...\"
createAuthorizer_tags :: Lens.Lens' CreateAuthorizer (Prelude.Maybe [Tag])
createAuthorizer_tags :: Lens' CreateAuthorizer (Maybe [Tag])
createAuthorizer_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateAuthorizer' {Maybe [Tag]
tags :: Maybe [Tag]
$sel:tags:CreateAuthorizer' :: CreateAuthorizer -> Maybe [Tag]
tags} -> Maybe [Tag]
tags) (\s :: CreateAuthorizer
s@CreateAuthorizer' {} Maybe [Tag]
a -> CreateAuthorizer
s {$sel:tags:CreateAuthorizer' :: Maybe [Tag]
tags = Maybe [Tag]
a} :: CreateAuthorizer) 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 token key used to extract the token from the HTTP
-- headers.
createAuthorizer_tokenKeyName :: Lens.Lens' CreateAuthorizer (Prelude.Maybe Prelude.Text)
createAuthorizer_tokenKeyName :: Lens' CreateAuthorizer (Maybe Text)
createAuthorizer_tokenKeyName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateAuthorizer' {Maybe Text
tokenKeyName :: Maybe Text
$sel:tokenKeyName:CreateAuthorizer' :: CreateAuthorizer -> Maybe Text
tokenKeyName} -> Maybe Text
tokenKeyName) (\s :: CreateAuthorizer
s@CreateAuthorizer' {} Maybe Text
a -> CreateAuthorizer
s {$sel:tokenKeyName:CreateAuthorizer' :: Maybe Text
tokenKeyName = Maybe Text
a} :: CreateAuthorizer)

-- | The public keys used to verify the digital signature returned by your
-- custom authentication service.
createAuthorizer_tokenSigningPublicKeys :: Lens.Lens' CreateAuthorizer (Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text))
createAuthorizer_tokenSigningPublicKeys :: Lens' CreateAuthorizer (Maybe (HashMap Text Text))
createAuthorizer_tokenSigningPublicKeys = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateAuthorizer' {Maybe (HashMap Text Text)
tokenSigningPublicKeys :: Maybe (HashMap Text Text)
$sel:tokenSigningPublicKeys:CreateAuthorizer' :: CreateAuthorizer -> Maybe (HashMap Text Text)
tokenSigningPublicKeys} -> Maybe (HashMap Text Text)
tokenSigningPublicKeys) (\s :: CreateAuthorizer
s@CreateAuthorizer' {} Maybe (HashMap Text Text)
a -> CreateAuthorizer
s {$sel:tokenSigningPublicKeys:CreateAuthorizer' :: Maybe (HashMap Text Text)
tokenSigningPublicKeys = Maybe (HashMap Text Text)
a} :: CreateAuthorizer) 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 authorizer name.
createAuthorizer_authorizerName :: Lens.Lens' CreateAuthorizer Prelude.Text
createAuthorizer_authorizerName :: Lens' CreateAuthorizer Text
createAuthorizer_authorizerName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateAuthorizer' {Text
authorizerName :: Text
$sel:authorizerName:CreateAuthorizer' :: CreateAuthorizer -> Text
authorizerName} -> Text
authorizerName) (\s :: CreateAuthorizer
s@CreateAuthorizer' {} Text
a -> CreateAuthorizer
s {$sel:authorizerName:CreateAuthorizer' :: Text
authorizerName = Text
a} :: CreateAuthorizer)

-- | The ARN of the authorizer\'s Lambda function.
createAuthorizer_authorizerFunctionArn :: Lens.Lens' CreateAuthorizer Prelude.Text
createAuthorizer_authorizerFunctionArn :: Lens' CreateAuthorizer Text
createAuthorizer_authorizerFunctionArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateAuthorizer' {Text
authorizerFunctionArn :: Text
$sel:authorizerFunctionArn:CreateAuthorizer' :: CreateAuthorizer -> Text
authorizerFunctionArn} -> Text
authorizerFunctionArn) (\s :: CreateAuthorizer
s@CreateAuthorizer' {} Text
a -> CreateAuthorizer
s {$sel:authorizerFunctionArn:CreateAuthorizer' :: Text
authorizerFunctionArn = Text
a} :: CreateAuthorizer)

instance Core.AWSRequest CreateAuthorizer where
  type
    AWSResponse CreateAuthorizer =
      CreateAuthorizerResponse
  request :: (Service -> Service)
-> CreateAuthorizer -> Request CreateAuthorizer
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 CreateAuthorizer
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse CreateAuthorizer)))
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 -> Int -> CreateAuthorizerResponse
CreateAuthorizerResponse'
            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
"authorizerArn")
            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
"authorizerName")
            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 CreateAuthorizer where
  hashWithSalt :: Int -> CreateAuthorizer -> Int
hashWithSalt Int
_salt CreateAuthorizer' {Maybe Bool
Maybe [Tag]
Maybe Text
Maybe (HashMap Text Text)
Maybe AuthorizerStatus
Text
authorizerFunctionArn :: Text
authorizerName :: Text
tokenSigningPublicKeys :: Maybe (HashMap Text Text)
tokenKeyName :: Maybe Text
tags :: Maybe [Tag]
status :: Maybe AuthorizerStatus
signingDisabled :: Maybe Bool
enableCachingForHttp :: Maybe Bool
$sel:authorizerFunctionArn:CreateAuthorizer' :: CreateAuthorizer -> Text
$sel:authorizerName:CreateAuthorizer' :: CreateAuthorizer -> Text
$sel:tokenSigningPublicKeys:CreateAuthorizer' :: CreateAuthorizer -> Maybe (HashMap Text Text)
$sel:tokenKeyName:CreateAuthorizer' :: CreateAuthorizer -> Maybe Text
$sel:tags:CreateAuthorizer' :: CreateAuthorizer -> Maybe [Tag]
$sel:status:CreateAuthorizer' :: CreateAuthorizer -> Maybe AuthorizerStatus
$sel:signingDisabled:CreateAuthorizer' :: CreateAuthorizer -> Maybe Bool
$sel:enableCachingForHttp:CreateAuthorizer' :: CreateAuthorizer -> Maybe Bool
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
enableCachingForHttp
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
signingDisabled
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe AuthorizerStatus
status
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Tag]
tags
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
tokenKeyName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (HashMap Text Text)
tokenSigningPublicKeys
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
authorizerName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
authorizerFunctionArn

instance Prelude.NFData CreateAuthorizer where
  rnf :: CreateAuthorizer -> ()
rnf CreateAuthorizer' {Maybe Bool
Maybe [Tag]
Maybe Text
Maybe (HashMap Text Text)
Maybe AuthorizerStatus
Text
authorizerFunctionArn :: Text
authorizerName :: Text
tokenSigningPublicKeys :: Maybe (HashMap Text Text)
tokenKeyName :: Maybe Text
tags :: Maybe [Tag]
status :: Maybe AuthorizerStatus
signingDisabled :: Maybe Bool
enableCachingForHttp :: Maybe Bool
$sel:authorizerFunctionArn:CreateAuthorizer' :: CreateAuthorizer -> Text
$sel:authorizerName:CreateAuthorizer' :: CreateAuthorizer -> Text
$sel:tokenSigningPublicKeys:CreateAuthorizer' :: CreateAuthorizer -> Maybe (HashMap Text Text)
$sel:tokenKeyName:CreateAuthorizer' :: CreateAuthorizer -> Maybe Text
$sel:tags:CreateAuthorizer' :: CreateAuthorizer -> Maybe [Tag]
$sel:status:CreateAuthorizer' :: CreateAuthorizer -> Maybe AuthorizerStatus
$sel:signingDisabled:CreateAuthorizer' :: CreateAuthorizer -> Maybe Bool
$sel:enableCachingForHttp:CreateAuthorizer' :: CreateAuthorizer -> Maybe Bool
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Bool
enableCachingForHttp
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Bool
signingDisabled
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe AuthorizerStatus
status
      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 Maybe Text
tokenKeyName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe (HashMap Text Text)
tokenSigningPublicKeys
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
authorizerName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
authorizerFunctionArn

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

instance Data.ToJSON CreateAuthorizer where
  toJSON :: CreateAuthorizer -> Value
toJSON CreateAuthorizer' {Maybe Bool
Maybe [Tag]
Maybe Text
Maybe (HashMap Text Text)
Maybe AuthorizerStatus
Text
authorizerFunctionArn :: Text
authorizerName :: Text
tokenSigningPublicKeys :: Maybe (HashMap Text Text)
tokenKeyName :: Maybe Text
tags :: Maybe [Tag]
status :: Maybe AuthorizerStatus
signingDisabled :: Maybe Bool
enableCachingForHttp :: Maybe Bool
$sel:authorizerFunctionArn:CreateAuthorizer' :: CreateAuthorizer -> Text
$sel:authorizerName:CreateAuthorizer' :: CreateAuthorizer -> Text
$sel:tokenSigningPublicKeys:CreateAuthorizer' :: CreateAuthorizer -> Maybe (HashMap Text Text)
$sel:tokenKeyName:CreateAuthorizer' :: CreateAuthorizer -> Maybe Text
$sel:tags:CreateAuthorizer' :: CreateAuthorizer -> Maybe [Tag]
$sel:status:CreateAuthorizer' :: CreateAuthorizer -> Maybe AuthorizerStatus
$sel:signingDisabled:CreateAuthorizer' :: CreateAuthorizer -> Maybe Bool
$sel:enableCachingForHttp:CreateAuthorizer' :: CreateAuthorizer -> Maybe Bool
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"enableCachingForHttp" 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 Bool
enableCachingForHttp,
            (Key
"signingDisabled" 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 Bool
signingDisabled,
            (Key
"status" 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 AuthorizerStatus
status,
            (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,
            (Key
"tokenKeyName" 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
tokenKeyName,
            (Key
"tokenSigningPublicKeys" 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 (HashMap Text Text)
tokenSigningPublicKeys,
            forall a. a -> Maybe a
Prelude.Just
              ( Key
"authorizerFunctionArn"
                  forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
authorizerFunctionArn
              )
          ]
      )

instance Data.ToPath CreateAuthorizer where
  toPath :: CreateAuthorizer -> ByteString
toPath CreateAuthorizer' {Maybe Bool
Maybe [Tag]
Maybe Text
Maybe (HashMap Text Text)
Maybe AuthorizerStatus
Text
authorizerFunctionArn :: Text
authorizerName :: Text
tokenSigningPublicKeys :: Maybe (HashMap Text Text)
tokenKeyName :: Maybe Text
tags :: Maybe [Tag]
status :: Maybe AuthorizerStatus
signingDisabled :: Maybe Bool
enableCachingForHttp :: Maybe Bool
$sel:authorizerFunctionArn:CreateAuthorizer' :: CreateAuthorizer -> Text
$sel:authorizerName:CreateAuthorizer' :: CreateAuthorizer -> Text
$sel:tokenSigningPublicKeys:CreateAuthorizer' :: CreateAuthorizer -> Maybe (HashMap Text Text)
$sel:tokenKeyName:CreateAuthorizer' :: CreateAuthorizer -> Maybe Text
$sel:tags:CreateAuthorizer' :: CreateAuthorizer -> Maybe [Tag]
$sel:status:CreateAuthorizer' :: CreateAuthorizer -> Maybe AuthorizerStatus
$sel:signingDisabled:CreateAuthorizer' :: CreateAuthorizer -> Maybe Bool
$sel:enableCachingForHttp:CreateAuthorizer' :: CreateAuthorizer -> Maybe Bool
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ByteString
"/authorizer/", forall a. ToByteString a => a -> ByteString
Data.toBS Text
authorizerName]

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

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

-- |
-- Create a value of 'CreateAuthorizerResponse' 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:
--
-- 'authorizerArn', 'createAuthorizerResponse_authorizerArn' - The authorizer ARN.
--
-- 'authorizerName', 'createAuthorizerResponse_authorizerName' - The authorizer\'s name.
--
-- 'httpStatus', 'createAuthorizerResponse_httpStatus' - The response's http status code.
newCreateAuthorizerResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  CreateAuthorizerResponse
newCreateAuthorizerResponse :: Int -> CreateAuthorizerResponse
newCreateAuthorizerResponse Int
pHttpStatus_ =
  CreateAuthorizerResponse'
    { $sel:authorizerArn:CreateAuthorizerResponse' :: Maybe Text
authorizerArn =
        forall a. Maybe a
Prelude.Nothing,
      $sel:authorizerName:CreateAuthorizerResponse' :: Maybe Text
authorizerName = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:CreateAuthorizerResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The authorizer ARN.
createAuthorizerResponse_authorizerArn :: Lens.Lens' CreateAuthorizerResponse (Prelude.Maybe Prelude.Text)
createAuthorizerResponse_authorizerArn :: Lens' CreateAuthorizerResponse (Maybe Text)
createAuthorizerResponse_authorizerArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateAuthorizerResponse' {Maybe Text
authorizerArn :: Maybe Text
$sel:authorizerArn:CreateAuthorizerResponse' :: CreateAuthorizerResponse -> Maybe Text
authorizerArn} -> Maybe Text
authorizerArn) (\s :: CreateAuthorizerResponse
s@CreateAuthorizerResponse' {} Maybe Text
a -> CreateAuthorizerResponse
s {$sel:authorizerArn:CreateAuthorizerResponse' :: Maybe Text
authorizerArn = Maybe Text
a} :: CreateAuthorizerResponse)

-- | The authorizer\'s name.
createAuthorizerResponse_authorizerName :: Lens.Lens' CreateAuthorizerResponse (Prelude.Maybe Prelude.Text)
createAuthorizerResponse_authorizerName :: Lens' CreateAuthorizerResponse (Maybe Text)
createAuthorizerResponse_authorizerName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateAuthorizerResponse' {Maybe Text
authorizerName :: Maybe Text
$sel:authorizerName:CreateAuthorizerResponse' :: CreateAuthorizerResponse -> Maybe Text
authorizerName} -> Maybe Text
authorizerName) (\s :: CreateAuthorizerResponse
s@CreateAuthorizerResponse' {} Maybe Text
a -> CreateAuthorizerResponse
s {$sel:authorizerName:CreateAuthorizerResponse' :: Maybe Text
authorizerName = Maybe Text
a} :: CreateAuthorizerResponse)

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

instance Prelude.NFData CreateAuthorizerResponse where
  rnf :: CreateAuthorizerResponse -> ()
rnf CreateAuthorizerResponse' {Int
Maybe Text
httpStatus :: Int
authorizerName :: Maybe Text
authorizerArn :: Maybe Text
$sel:httpStatus:CreateAuthorizerResponse' :: CreateAuthorizerResponse -> Int
$sel:authorizerName:CreateAuthorizerResponse' :: CreateAuthorizerResponse -> Maybe Text
$sel:authorizerArn:CreateAuthorizerResponse' :: CreateAuthorizerResponse -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
authorizerArn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
authorizerName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus