{-# 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.Route53Resolver.CreateResolverRule
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- For DNS queries that originate in your VPCs, specifies which Resolver
-- endpoint the queries pass through, one domain name that you want to
-- forward to your network, and the IP addresses of the DNS resolvers in
-- your network.
module Amazonka.Route53Resolver.CreateResolverRule
  ( -- * Creating a Request
    CreateResolverRule (..),
    newCreateResolverRule,

    -- * Request Lenses
    createResolverRule_name,
    createResolverRule_resolverEndpointId,
    createResolverRule_tags,
    createResolverRule_targetIps,
    createResolverRule_creatorRequestId,
    createResolverRule_ruleType,
    createResolverRule_domainName,

    -- * Destructuring the Response
    CreateResolverRuleResponse (..),
    newCreateResolverRuleResponse,

    -- * Response Lenses
    createResolverRuleResponse_resolverRule,
    createResolverRuleResponse_httpStatus,
  )
where

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

-- | /See:/ 'newCreateResolverRule' smart constructor.
data CreateResolverRule = CreateResolverRule'
  { -- | A friendly name that lets you easily find a rule in the Resolver
    -- dashboard in the Route 53 console.
    CreateResolverRule -> Maybe Text
name :: Prelude.Maybe Prelude.Text,
    -- | The ID of the outbound Resolver endpoint that you want to use to route
    -- DNS queries to the IP addresses that you specify in @TargetIps@.
    CreateResolverRule -> Maybe Text
resolverEndpointId :: Prelude.Maybe Prelude.Text,
    -- | A list of the tag keys and values that you want to associate with the
    -- endpoint.
    CreateResolverRule -> Maybe [Tag]
tags :: Prelude.Maybe [Tag],
    -- | The IPs that you want Resolver to forward DNS queries to. You can
    -- specify only IPv4 addresses. Separate IP addresses with a space.
    --
    -- @TargetIps@ is available only when the value of @Rule type@ is
    -- @FORWARD@.
    CreateResolverRule -> Maybe (NonEmpty TargetAddress)
targetIps :: Prelude.Maybe (Prelude.NonEmpty TargetAddress),
    -- | A unique string that identifies the request and that allows failed
    -- requests to be retried without the risk of running the operation twice.
    -- @CreatorRequestId@ can be any unique string, for example, a date\/time
    -- stamp.
    CreateResolverRule -> Text
creatorRequestId :: Prelude.Text,
    -- | When you want to forward DNS queries for specified domain name to
    -- resolvers on your network, specify @FORWARD@.
    --
    -- When you have a forwarding rule to forward DNS queries for a domain to
    -- your network and you want Resolver to process queries for a subdomain of
    -- that domain, specify @SYSTEM@.
    --
    -- For example, to forward DNS queries for example.com to resolvers on your
    -- network, you create a rule and specify @FORWARD@ for @RuleType@. To then
    -- have Resolver process queries for apex.example.com, you create a rule
    -- and specify @SYSTEM@ for @RuleType@.
    --
    -- Currently, only Resolver can create rules that have a value of
    -- @RECURSIVE@ for @RuleType@.
    CreateResolverRule -> RuleTypeOption
ruleType :: RuleTypeOption,
    -- | DNS queries for this domain name are forwarded to the IP addresses that
    -- you specify in @TargetIps@. If a query matches multiple Resolver rules
    -- (example.com and www.example.com), outbound DNS queries are routed using
    -- the Resolver rule that contains the most specific domain name
    -- (www.example.com).
    CreateResolverRule -> Text
domainName :: Prelude.Text
  }
  deriving (CreateResolverRule -> CreateResolverRule -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateResolverRule -> CreateResolverRule -> Bool
$c/= :: CreateResolverRule -> CreateResolverRule -> Bool
== :: CreateResolverRule -> CreateResolverRule -> Bool
$c== :: CreateResolverRule -> CreateResolverRule -> Bool
Prelude.Eq, ReadPrec [CreateResolverRule]
ReadPrec CreateResolverRule
Int -> ReadS CreateResolverRule
ReadS [CreateResolverRule]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateResolverRule]
$creadListPrec :: ReadPrec [CreateResolverRule]
readPrec :: ReadPrec CreateResolverRule
$creadPrec :: ReadPrec CreateResolverRule
readList :: ReadS [CreateResolverRule]
$creadList :: ReadS [CreateResolverRule]
readsPrec :: Int -> ReadS CreateResolverRule
$creadsPrec :: Int -> ReadS CreateResolverRule
Prelude.Read, Int -> CreateResolverRule -> ShowS
[CreateResolverRule] -> ShowS
CreateResolverRule -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateResolverRule] -> ShowS
$cshowList :: [CreateResolverRule] -> ShowS
show :: CreateResolverRule -> String
$cshow :: CreateResolverRule -> String
showsPrec :: Int -> CreateResolverRule -> ShowS
$cshowsPrec :: Int -> CreateResolverRule -> ShowS
Prelude.Show, forall x. Rep CreateResolverRule x -> CreateResolverRule
forall x. CreateResolverRule -> Rep CreateResolverRule x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateResolverRule x -> CreateResolverRule
$cfrom :: forall x. CreateResolverRule -> Rep CreateResolverRule x
Prelude.Generic)

-- |
-- Create a value of 'CreateResolverRule' 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:
--
-- 'name', 'createResolverRule_name' - A friendly name that lets you easily find a rule in the Resolver
-- dashboard in the Route 53 console.
--
-- 'resolverEndpointId', 'createResolverRule_resolverEndpointId' - The ID of the outbound Resolver endpoint that you want to use to route
-- DNS queries to the IP addresses that you specify in @TargetIps@.
--
-- 'tags', 'createResolverRule_tags' - A list of the tag keys and values that you want to associate with the
-- endpoint.
--
-- 'targetIps', 'createResolverRule_targetIps' - The IPs that you want Resolver to forward DNS queries to. You can
-- specify only IPv4 addresses. Separate IP addresses with a space.
--
-- @TargetIps@ is available only when the value of @Rule type@ is
-- @FORWARD@.
--
-- 'creatorRequestId', 'createResolverRule_creatorRequestId' - A unique string that identifies the request and that allows failed
-- requests to be retried without the risk of running the operation twice.
-- @CreatorRequestId@ can be any unique string, for example, a date\/time
-- stamp.
--
-- 'ruleType', 'createResolverRule_ruleType' - When you want to forward DNS queries for specified domain name to
-- resolvers on your network, specify @FORWARD@.
--
-- When you have a forwarding rule to forward DNS queries for a domain to
-- your network and you want Resolver to process queries for a subdomain of
-- that domain, specify @SYSTEM@.
--
-- For example, to forward DNS queries for example.com to resolvers on your
-- network, you create a rule and specify @FORWARD@ for @RuleType@. To then
-- have Resolver process queries for apex.example.com, you create a rule
-- and specify @SYSTEM@ for @RuleType@.
--
-- Currently, only Resolver can create rules that have a value of
-- @RECURSIVE@ for @RuleType@.
--
-- 'domainName', 'createResolverRule_domainName' - DNS queries for this domain name are forwarded to the IP addresses that
-- you specify in @TargetIps@. If a query matches multiple Resolver rules
-- (example.com and www.example.com), outbound DNS queries are routed using
-- the Resolver rule that contains the most specific domain name
-- (www.example.com).
newCreateResolverRule ::
  -- | 'creatorRequestId'
  Prelude.Text ->
  -- | 'ruleType'
  RuleTypeOption ->
  -- | 'domainName'
  Prelude.Text ->
  CreateResolverRule
newCreateResolverRule :: Text -> RuleTypeOption -> Text -> CreateResolverRule
newCreateResolverRule
  Text
pCreatorRequestId_
  RuleTypeOption
pRuleType_
  Text
pDomainName_ =
    CreateResolverRule'
      { $sel:name:CreateResolverRule' :: Maybe Text
name = forall a. Maybe a
Prelude.Nothing,
        $sel:resolverEndpointId:CreateResolverRule' :: Maybe Text
resolverEndpointId = forall a. Maybe a
Prelude.Nothing,
        $sel:tags:CreateResolverRule' :: Maybe [Tag]
tags = forall a. Maybe a
Prelude.Nothing,
        $sel:targetIps:CreateResolverRule' :: Maybe (NonEmpty TargetAddress)
targetIps = forall a. Maybe a
Prelude.Nothing,
        $sel:creatorRequestId:CreateResolverRule' :: Text
creatorRequestId = Text
pCreatorRequestId_,
        $sel:ruleType:CreateResolverRule' :: RuleTypeOption
ruleType = RuleTypeOption
pRuleType_,
        $sel:domainName:CreateResolverRule' :: Text
domainName = Text
pDomainName_
      }

-- | A friendly name that lets you easily find a rule in the Resolver
-- dashboard in the Route 53 console.
createResolverRule_name :: Lens.Lens' CreateResolverRule (Prelude.Maybe Prelude.Text)
createResolverRule_name :: Lens' CreateResolverRule (Maybe Text)
createResolverRule_name = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateResolverRule' {Maybe Text
name :: Maybe Text
$sel:name:CreateResolverRule' :: CreateResolverRule -> Maybe Text
name} -> Maybe Text
name) (\s :: CreateResolverRule
s@CreateResolverRule' {} Maybe Text
a -> CreateResolverRule
s {$sel:name:CreateResolverRule' :: Maybe Text
name = Maybe Text
a} :: CreateResolverRule)

-- | The ID of the outbound Resolver endpoint that you want to use to route
-- DNS queries to the IP addresses that you specify in @TargetIps@.
createResolverRule_resolverEndpointId :: Lens.Lens' CreateResolverRule (Prelude.Maybe Prelude.Text)
createResolverRule_resolverEndpointId :: Lens' CreateResolverRule (Maybe Text)
createResolverRule_resolverEndpointId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateResolverRule' {Maybe Text
resolverEndpointId :: Maybe Text
$sel:resolverEndpointId:CreateResolverRule' :: CreateResolverRule -> Maybe Text
resolverEndpointId} -> Maybe Text
resolverEndpointId) (\s :: CreateResolverRule
s@CreateResolverRule' {} Maybe Text
a -> CreateResolverRule
s {$sel:resolverEndpointId:CreateResolverRule' :: Maybe Text
resolverEndpointId = Maybe Text
a} :: CreateResolverRule)

-- | A list of the tag keys and values that you want to associate with the
-- endpoint.
createResolverRule_tags :: Lens.Lens' CreateResolverRule (Prelude.Maybe [Tag])
createResolverRule_tags :: Lens' CreateResolverRule (Maybe [Tag])
createResolverRule_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateResolverRule' {Maybe [Tag]
tags :: Maybe [Tag]
$sel:tags:CreateResolverRule' :: CreateResolverRule -> Maybe [Tag]
tags} -> Maybe [Tag]
tags) (\s :: CreateResolverRule
s@CreateResolverRule' {} Maybe [Tag]
a -> CreateResolverRule
s {$sel:tags:CreateResolverRule' :: Maybe [Tag]
tags = Maybe [Tag]
a} :: CreateResolverRule) 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 IPs that you want Resolver to forward DNS queries to. You can
-- specify only IPv4 addresses. Separate IP addresses with a space.
--
-- @TargetIps@ is available only when the value of @Rule type@ is
-- @FORWARD@.
createResolverRule_targetIps :: Lens.Lens' CreateResolverRule (Prelude.Maybe (Prelude.NonEmpty TargetAddress))
createResolverRule_targetIps :: Lens' CreateResolverRule (Maybe (NonEmpty TargetAddress))
createResolverRule_targetIps = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateResolverRule' {Maybe (NonEmpty TargetAddress)
targetIps :: Maybe (NonEmpty TargetAddress)
$sel:targetIps:CreateResolverRule' :: CreateResolverRule -> Maybe (NonEmpty TargetAddress)
targetIps} -> Maybe (NonEmpty TargetAddress)
targetIps) (\s :: CreateResolverRule
s@CreateResolverRule' {} Maybe (NonEmpty TargetAddress)
a -> CreateResolverRule
s {$sel:targetIps:CreateResolverRule' :: Maybe (NonEmpty TargetAddress)
targetIps = Maybe (NonEmpty TargetAddress)
a} :: CreateResolverRule) 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 unique string that identifies the request and that allows failed
-- requests to be retried without the risk of running the operation twice.
-- @CreatorRequestId@ can be any unique string, for example, a date\/time
-- stamp.
createResolverRule_creatorRequestId :: Lens.Lens' CreateResolverRule Prelude.Text
createResolverRule_creatorRequestId :: Lens' CreateResolverRule Text
createResolverRule_creatorRequestId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateResolverRule' {Text
creatorRequestId :: Text
$sel:creatorRequestId:CreateResolverRule' :: CreateResolverRule -> Text
creatorRequestId} -> Text
creatorRequestId) (\s :: CreateResolverRule
s@CreateResolverRule' {} Text
a -> CreateResolverRule
s {$sel:creatorRequestId:CreateResolverRule' :: Text
creatorRequestId = Text
a} :: CreateResolverRule)

-- | When you want to forward DNS queries for specified domain name to
-- resolvers on your network, specify @FORWARD@.
--
-- When you have a forwarding rule to forward DNS queries for a domain to
-- your network and you want Resolver to process queries for a subdomain of
-- that domain, specify @SYSTEM@.
--
-- For example, to forward DNS queries for example.com to resolvers on your
-- network, you create a rule and specify @FORWARD@ for @RuleType@. To then
-- have Resolver process queries for apex.example.com, you create a rule
-- and specify @SYSTEM@ for @RuleType@.
--
-- Currently, only Resolver can create rules that have a value of
-- @RECURSIVE@ for @RuleType@.
createResolverRule_ruleType :: Lens.Lens' CreateResolverRule RuleTypeOption
createResolverRule_ruleType :: Lens' CreateResolverRule RuleTypeOption
createResolverRule_ruleType = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateResolverRule' {RuleTypeOption
ruleType :: RuleTypeOption
$sel:ruleType:CreateResolverRule' :: CreateResolverRule -> RuleTypeOption
ruleType} -> RuleTypeOption
ruleType) (\s :: CreateResolverRule
s@CreateResolverRule' {} RuleTypeOption
a -> CreateResolverRule
s {$sel:ruleType:CreateResolverRule' :: RuleTypeOption
ruleType = RuleTypeOption
a} :: CreateResolverRule)

-- | DNS queries for this domain name are forwarded to the IP addresses that
-- you specify in @TargetIps@. If a query matches multiple Resolver rules
-- (example.com and www.example.com), outbound DNS queries are routed using
-- the Resolver rule that contains the most specific domain name
-- (www.example.com).
createResolverRule_domainName :: Lens.Lens' CreateResolverRule Prelude.Text
createResolverRule_domainName :: Lens' CreateResolverRule Text
createResolverRule_domainName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateResolverRule' {Text
domainName :: Text
$sel:domainName:CreateResolverRule' :: CreateResolverRule -> Text
domainName} -> Text
domainName) (\s :: CreateResolverRule
s@CreateResolverRule' {} Text
a -> CreateResolverRule
s {$sel:domainName:CreateResolverRule' :: Text
domainName = Text
a} :: CreateResolverRule)

instance Core.AWSRequest CreateResolverRule where
  type
    AWSResponse CreateResolverRule =
      CreateResolverRuleResponse
  request :: (Service -> Service)
-> CreateResolverRule -> Request CreateResolverRule
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 CreateResolverRule
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse CreateResolverRule)))
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 ResolverRule -> Int -> CreateResolverRuleResponse
CreateResolverRuleResponse'
            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
"ResolverRule")
            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 CreateResolverRule where
  hashWithSalt :: Int -> CreateResolverRule -> Int
hashWithSalt Int
_salt CreateResolverRule' {Maybe [Tag]
Maybe (NonEmpty TargetAddress)
Maybe Text
Text
RuleTypeOption
domainName :: Text
ruleType :: RuleTypeOption
creatorRequestId :: Text
targetIps :: Maybe (NonEmpty TargetAddress)
tags :: Maybe [Tag]
resolverEndpointId :: Maybe Text
name :: Maybe Text
$sel:domainName:CreateResolverRule' :: CreateResolverRule -> Text
$sel:ruleType:CreateResolverRule' :: CreateResolverRule -> RuleTypeOption
$sel:creatorRequestId:CreateResolverRule' :: CreateResolverRule -> Text
$sel:targetIps:CreateResolverRule' :: CreateResolverRule -> Maybe (NonEmpty TargetAddress)
$sel:tags:CreateResolverRule' :: CreateResolverRule -> Maybe [Tag]
$sel:resolverEndpointId:CreateResolverRule' :: CreateResolverRule -> Maybe Text
$sel:name:CreateResolverRule' :: CreateResolverRule -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
name
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
resolverEndpointId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Tag]
tags
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (NonEmpty TargetAddress)
targetIps
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
creatorRequestId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` RuleTypeOption
ruleType
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
domainName

instance Prelude.NFData CreateResolverRule where
  rnf :: CreateResolverRule -> ()
rnf CreateResolverRule' {Maybe [Tag]
Maybe (NonEmpty TargetAddress)
Maybe Text
Text
RuleTypeOption
domainName :: Text
ruleType :: RuleTypeOption
creatorRequestId :: Text
targetIps :: Maybe (NonEmpty TargetAddress)
tags :: Maybe [Tag]
resolverEndpointId :: Maybe Text
name :: Maybe Text
$sel:domainName:CreateResolverRule' :: CreateResolverRule -> Text
$sel:ruleType:CreateResolverRule' :: CreateResolverRule -> RuleTypeOption
$sel:creatorRequestId:CreateResolverRule' :: CreateResolverRule -> Text
$sel:targetIps:CreateResolverRule' :: CreateResolverRule -> Maybe (NonEmpty TargetAddress)
$sel:tags:CreateResolverRule' :: CreateResolverRule -> Maybe [Tag]
$sel:resolverEndpointId:CreateResolverRule' :: CreateResolverRule -> Maybe Text
$sel:name:CreateResolverRule' :: CreateResolverRule -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
name
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
resolverEndpointId
      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 (NonEmpty TargetAddress)
targetIps
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
creatorRequestId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf RuleTypeOption
ruleType
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
domainName

instance Data.ToHeaders CreateResolverRule where
  toHeaders :: CreateResolverRule -> 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
"Route53Resolver.CreateResolverRule" ::
                          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 CreateResolverRule where
  toJSON :: CreateResolverRule -> Value
toJSON CreateResolverRule' {Maybe [Tag]
Maybe (NonEmpty TargetAddress)
Maybe Text
Text
RuleTypeOption
domainName :: Text
ruleType :: RuleTypeOption
creatorRequestId :: Text
targetIps :: Maybe (NonEmpty TargetAddress)
tags :: Maybe [Tag]
resolverEndpointId :: Maybe Text
name :: Maybe Text
$sel:domainName:CreateResolverRule' :: CreateResolverRule -> Text
$sel:ruleType:CreateResolverRule' :: CreateResolverRule -> RuleTypeOption
$sel:creatorRequestId:CreateResolverRule' :: CreateResolverRule -> Text
$sel:targetIps:CreateResolverRule' :: CreateResolverRule -> Maybe (NonEmpty TargetAddress)
$sel:tags:CreateResolverRule' :: CreateResolverRule -> Maybe [Tag]
$sel:resolverEndpointId:CreateResolverRule' :: CreateResolverRule -> Maybe Text
$sel:name:CreateResolverRule' :: CreateResolverRule -> Maybe Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"Name" 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
name,
            (Key
"ResolverEndpointId" 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
resolverEndpointId,
            (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
"TargetIps" 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 (NonEmpty TargetAddress)
targetIps,
            forall a. a -> Maybe a
Prelude.Just
              (Key
"CreatorRequestId" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
creatorRequestId),
            forall a. a -> Maybe a
Prelude.Just (Key
"RuleType" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= RuleTypeOption
ruleType),
            forall a. a -> Maybe a
Prelude.Just (Key
"DomainName" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
domainName)
          ]
      )

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

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

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

-- |
-- Create a value of 'CreateResolverRuleResponse' 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:
--
-- 'resolverRule', 'createResolverRuleResponse_resolverRule' - Information about the @CreateResolverRule@ request, including the status
-- of the request.
--
-- 'httpStatus', 'createResolverRuleResponse_httpStatus' - The response's http status code.
newCreateResolverRuleResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  CreateResolverRuleResponse
newCreateResolverRuleResponse :: Int -> CreateResolverRuleResponse
newCreateResolverRuleResponse Int
pHttpStatus_ =
  CreateResolverRuleResponse'
    { $sel:resolverRule:CreateResolverRuleResponse' :: Maybe ResolverRule
resolverRule =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:CreateResolverRuleResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | Information about the @CreateResolverRule@ request, including the status
-- of the request.
createResolverRuleResponse_resolverRule :: Lens.Lens' CreateResolverRuleResponse (Prelude.Maybe ResolverRule)
createResolverRuleResponse_resolverRule :: Lens' CreateResolverRuleResponse (Maybe ResolverRule)
createResolverRuleResponse_resolverRule = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateResolverRuleResponse' {Maybe ResolverRule
resolverRule :: Maybe ResolverRule
$sel:resolverRule:CreateResolverRuleResponse' :: CreateResolverRuleResponse -> Maybe ResolverRule
resolverRule} -> Maybe ResolverRule
resolverRule) (\s :: CreateResolverRuleResponse
s@CreateResolverRuleResponse' {} Maybe ResolverRule
a -> CreateResolverRuleResponse
s {$sel:resolverRule:CreateResolverRuleResponse' :: Maybe ResolverRule
resolverRule = Maybe ResolverRule
a} :: CreateResolverRuleResponse)

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

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