{-# 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.EC2.StartNetworkInsightsAccessScopeAnalysis
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Starts analyzing the specified Network Access Scope.
module Amazonka.EC2.StartNetworkInsightsAccessScopeAnalysis
  ( -- * Creating a Request
    StartNetworkInsightsAccessScopeAnalysis (..),
    newStartNetworkInsightsAccessScopeAnalysis,

    -- * Request Lenses
    startNetworkInsightsAccessScopeAnalysis_dryRun,
    startNetworkInsightsAccessScopeAnalysis_tagSpecifications,
    startNetworkInsightsAccessScopeAnalysis_networkInsightsAccessScopeId,
    startNetworkInsightsAccessScopeAnalysis_clientToken,

    -- * Destructuring the Response
    StartNetworkInsightsAccessScopeAnalysisResponse (..),
    newStartNetworkInsightsAccessScopeAnalysisResponse,

    -- * Response Lenses
    startNetworkInsightsAccessScopeAnalysisResponse_networkInsightsAccessScopeAnalysis,
    startNetworkInsightsAccessScopeAnalysisResponse_httpStatus,
  )
where

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

-- | /See:/ 'newStartNetworkInsightsAccessScopeAnalysis' smart constructor.
data StartNetworkInsightsAccessScopeAnalysis = StartNetworkInsightsAccessScopeAnalysis'
  { -- | Checks whether you have the required permissions for the action, without
    -- actually making the request, and provides an error response. If you have
    -- the required permissions, the error response is @DryRunOperation@.
    -- Otherwise, it is @UnauthorizedOperation@.
    StartNetworkInsightsAccessScopeAnalysis -> Maybe Bool
dryRun :: Prelude.Maybe Prelude.Bool,
    -- | The tags to apply.
    StartNetworkInsightsAccessScopeAnalysis -> Maybe [TagSpecification]
tagSpecifications :: Prelude.Maybe [TagSpecification],
    -- | The ID of the Network Access Scope.
    StartNetworkInsightsAccessScopeAnalysis -> Text
networkInsightsAccessScopeId :: Prelude.Text,
    -- | Unique, case-sensitive identifier that you provide to ensure the
    -- idempotency of the request. For more information, see
    -- <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/Run_Instance_Idempotency.html How to ensure idempotency>.
    StartNetworkInsightsAccessScopeAnalysis -> Text
clientToken :: Prelude.Text
  }
  deriving (StartNetworkInsightsAccessScopeAnalysis
-> StartNetworkInsightsAccessScopeAnalysis -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StartNetworkInsightsAccessScopeAnalysis
-> StartNetworkInsightsAccessScopeAnalysis -> Bool
$c/= :: StartNetworkInsightsAccessScopeAnalysis
-> StartNetworkInsightsAccessScopeAnalysis -> Bool
== :: StartNetworkInsightsAccessScopeAnalysis
-> StartNetworkInsightsAccessScopeAnalysis -> Bool
$c== :: StartNetworkInsightsAccessScopeAnalysis
-> StartNetworkInsightsAccessScopeAnalysis -> Bool
Prelude.Eq, ReadPrec [StartNetworkInsightsAccessScopeAnalysis]
ReadPrec StartNetworkInsightsAccessScopeAnalysis
Int -> ReadS StartNetworkInsightsAccessScopeAnalysis
ReadS [StartNetworkInsightsAccessScopeAnalysis]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [StartNetworkInsightsAccessScopeAnalysis]
$creadListPrec :: ReadPrec [StartNetworkInsightsAccessScopeAnalysis]
readPrec :: ReadPrec StartNetworkInsightsAccessScopeAnalysis
$creadPrec :: ReadPrec StartNetworkInsightsAccessScopeAnalysis
readList :: ReadS [StartNetworkInsightsAccessScopeAnalysis]
$creadList :: ReadS [StartNetworkInsightsAccessScopeAnalysis]
readsPrec :: Int -> ReadS StartNetworkInsightsAccessScopeAnalysis
$creadsPrec :: Int -> ReadS StartNetworkInsightsAccessScopeAnalysis
Prelude.Read, Int -> StartNetworkInsightsAccessScopeAnalysis -> ShowS
[StartNetworkInsightsAccessScopeAnalysis] -> ShowS
StartNetworkInsightsAccessScopeAnalysis -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StartNetworkInsightsAccessScopeAnalysis] -> ShowS
$cshowList :: [StartNetworkInsightsAccessScopeAnalysis] -> ShowS
show :: StartNetworkInsightsAccessScopeAnalysis -> String
$cshow :: StartNetworkInsightsAccessScopeAnalysis -> String
showsPrec :: Int -> StartNetworkInsightsAccessScopeAnalysis -> ShowS
$cshowsPrec :: Int -> StartNetworkInsightsAccessScopeAnalysis -> ShowS
Prelude.Show, forall x.
Rep StartNetworkInsightsAccessScopeAnalysis x
-> StartNetworkInsightsAccessScopeAnalysis
forall x.
StartNetworkInsightsAccessScopeAnalysis
-> Rep StartNetworkInsightsAccessScopeAnalysis x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep StartNetworkInsightsAccessScopeAnalysis x
-> StartNetworkInsightsAccessScopeAnalysis
$cfrom :: forall x.
StartNetworkInsightsAccessScopeAnalysis
-> Rep StartNetworkInsightsAccessScopeAnalysis x
Prelude.Generic)

-- |
-- Create a value of 'StartNetworkInsightsAccessScopeAnalysis' 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:
--
-- 'dryRun', 'startNetworkInsightsAccessScopeAnalysis_dryRun' - Checks whether you have the required permissions for the action, without
-- actually making the request, and provides an error response. If you have
-- the required permissions, the error response is @DryRunOperation@.
-- Otherwise, it is @UnauthorizedOperation@.
--
-- 'tagSpecifications', 'startNetworkInsightsAccessScopeAnalysis_tagSpecifications' - The tags to apply.
--
-- 'networkInsightsAccessScopeId', 'startNetworkInsightsAccessScopeAnalysis_networkInsightsAccessScopeId' - The ID of the Network Access Scope.
--
-- 'clientToken', 'startNetworkInsightsAccessScopeAnalysis_clientToken' - Unique, case-sensitive identifier that you provide to ensure the
-- idempotency of the request. For more information, see
-- <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/Run_Instance_Idempotency.html How to ensure idempotency>.
newStartNetworkInsightsAccessScopeAnalysis ::
  -- | 'networkInsightsAccessScopeId'
  Prelude.Text ->
  -- | 'clientToken'
  Prelude.Text ->
  StartNetworkInsightsAccessScopeAnalysis
newStartNetworkInsightsAccessScopeAnalysis :: Text -> Text -> StartNetworkInsightsAccessScopeAnalysis
newStartNetworkInsightsAccessScopeAnalysis
  Text
pNetworkInsightsAccessScopeId_
  Text
pClientToken_ =
    StartNetworkInsightsAccessScopeAnalysis'
      { $sel:dryRun:StartNetworkInsightsAccessScopeAnalysis' :: Maybe Bool
dryRun =
          forall a. Maybe a
Prelude.Nothing,
        $sel:tagSpecifications:StartNetworkInsightsAccessScopeAnalysis' :: Maybe [TagSpecification]
tagSpecifications =
          forall a. Maybe a
Prelude.Nothing,
        $sel:networkInsightsAccessScopeId:StartNetworkInsightsAccessScopeAnalysis' :: Text
networkInsightsAccessScopeId =
          Text
pNetworkInsightsAccessScopeId_,
        $sel:clientToken:StartNetworkInsightsAccessScopeAnalysis' :: Text
clientToken = Text
pClientToken_
      }

-- | Checks whether you have the required permissions for the action, without
-- actually making the request, and provides an error response. If you have
-- the required permissions, the error response is @DryRunOperation@.
-- Otherwise, it is @UnauthorizedOperation@.
startNetworkInsightsAccessScopeAnalysis_dryRun :: Lens.Lens' StartNetworkInsightsAccessScopeAnalysis (Prelude.Maybe Prelude.Bool)
startNetworkInsightsAccessScopeAnalysis_dryRun :: Lens' StartNetworkInsightsAccessScopeAnalysis (Maybe Bool)
startNetworkInsightsAccessScopeAnalysis_dryRun = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartNetworkInsightsAccessScopeAnalysis' {Maybe Bool
dryRun :: Maybe Bool
$sel:dryRun:StartNetworkInsightsAccessScopeAnalysis' :: StartNetworkInsightsAccessScopeAnalysis -> Maybe Bool
dryRun} -> Maybe Bool
dryRun) (\s :: StartNetworkInsightsAccessScopeAnalysis
s@StartNetworkInsightsAccessScopeAnalysis' {} Maybe Bool
a -> StartNetworkInsightsAccessScopeAnalysis
s {$sel:dryRun:StartNetworkInsightsAccessScopeAnalysis' :: Maybe Bool
dryRun = Maybe Bool
a} :: StartNetworkInsightsAccessScopeAnalysis)

-- | The tags to apply.
startNetworkInsightsAccessScopeAnalysis_tagSpecifications :: Lens.Lens' StartNetworkInsightsAccessScopeAnalysis (Prelude.Maybe [TagSpecification])
startNetworkInsightsAccessScopeAnalysis_tagSpecifications :: Lens'
  StartNetworkInsightsAccessScopeAnalysis (Maybe [TagSpecification])
startNetworkInsightsAccessScopeAnalysis_tagSpecifications = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartNetworkInsightsAccessScopeAnalysis' {Maybe [TagSpecification]
tagSpecifications :: Maybe [TagSpecification]
$sel:tagSpecifications:StartNetworkInsightsAccessScopeAnalysis' :: StartNetworkInsightsAccessScopeAnalysis -> Maybe [TagSpecification]
tagSpecifications} -> Maybe [TagSpecification]
tagSpecifications) (\s :: StartNetworkInsightsAccessScopeAnalysis
s@StartNetworkInsightsAccessScopeAnalysis' {} Maybe [TagSpecification]
a -> StartNetworkInsightsAccessScopeAnalysis
s {$sel:tagSpecifications:StartNetworkInsightsAccessScopeAnalysis' :: Maybe [TagSpecification]
tagSpecifications = Maybe [TagSpecification]
a} :: StartNetworkInsightsAccessScopeAnalysis) 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 ID of the Network Access Scope.
startNetworkInsightsAccessScopeAnalysis_networkInsightsAccessScopeId :: Lens.Lens' StartNetworkInsightsAccessScopeAnalysis Prelude.Text
startNetworkInsightsAccessScopeAnalysis_networkInsightsAccessScopeId :: Lens' StartNetworkInsightsAccessScopeAnalysis Text
startNetworkInsightsAccessScopeAnalysis_networkInsightsAccessScopeId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartNetworkInsightsAccessScopeAnalysis' {Text
networkInsightsAccessScopeId :: Text
$sel:networkInsightsAccessScopeId:StartNetworkInsightsAccessScopeAnalysis' :: StartNetworkInsightsAccessScopeAnalysis -> Text
networkInsightsAccessScopeId} -> Text
networkInsightsAccessScopeId) (\s :: StartNetworkInsightsAccessScopeAnalysis
s@StartNetworkInsightsAccessScopeAnalysis' {} Text
a -> StartNetworkInsightsAccessScopeAnalysis
s {$sel:networkInsightsAccessScopeId:StartNetworkInsightsAccessScopeAnalysis' :: Text
networkInsightsAccessScopeId = Text
a} :: StartNetworkInsightsAccessScopeAnalysis)

-- | Unique, case-sensitive identifier that you provide to ensure the
-- idempotency of the request. For more information, see
-- <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/Run_Instance_Idempotency.html How to ensure idempotency>.
startNetworkInsightsAccessScopeAnalysis_clientToken :: Lens.Lens' StartNetworkInsightsAccessScopeAnalysis Prelude.Text
startNetworkInsightsAccessScopeAnalysis_clientToken :: Lens' StartNetworkInsightsAccessScopeAnalysis Text
startNetworkInsightsAccessScopeAnalysis_clientToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartNetworkInsightsAccessScopeAnalysis' {Text
clientToken :: Text
$sel:clientToken:StartNetworkInsightsAccessScopeAnalysis' :: StartNetworkInsightsAccessScopeAnalysis -> Text
clientToken} -> Text
clientToken) (\s :: StartNetworkInsightsAccessScopeAnalysis
s@StartNetworkInsightsAccessScopeAnalysis' {} Text
a -> StartNetworkInsightsAccessScopeAnalysis
s {$sel:clientToken:StartNetworkInsightsAccessScopeAnalysis' :: Text
clientToken = Text
a} :: StartNetworkInsightsAccessScopeAnalysis)

instance
  Core.AWSRequest
    StartNetworkInsightsAccessScopeAnalysis
  where
  type
    AWSResponse
      StartNetworkInsightsAccessScopeAnalysis =
      StartNetworkInsightsAccessScopeAnalysisResponse
  request :: (Service -> Service)
-> StartNetworkInsightsAccessScopeAnalysis
-> Request StartNetworkInsightsAccessScopeAnalysis
request Service -> Service
overrides =
    forall a. ToRequest a => Service -> a -> Request a
Request.postQuery (Service -> Service
overrides Service
defaultService)
  response :: forall (m :: * -> *).
MonadResource m =>
(ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy StartNetworkInsightsAccessScopeAnalysis
-> ClientResponse ClientBody
-> m (Either
        Error
        (ClientResponse
           (AWSResponse StartNetworkInsightsAccessScopeAnalysis)))
response =
    forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> [Node] -> Either String (AWSResponse a))
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveXML
      ( \Int
s ResponseHeaders
h [Node]
x ->
          Maybe NetworkInsightsAccessScopeAnalysis
-> Int -> StartNetworkInsightsAccessScopeAnalysisResponse
StartNetworkInsightsAccessScopeAnalysisResponse'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"networkInsightsAccessScopeAnalysis")
            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
    StartNetworkInsightsAccessScopeAnalysis
  where
  hashWithSalt :: Int -> StartNetworkInsightsAccessScopeAnalysis -> Int
hashWithSalt
    Int
_salt
    StartNetworkInsightsAccessScopeAnalysis' {Maybe Bool
Maybe [TagSpecification]
Text
clientToken :: Text
networkInsightsAccessScopeId :: Text
tagSpecifications :: Maybe [TagSpecification]
dryRun :: Maybe Bool
$sel:clientToken:StartNetworkInsightsAccessScopeAnalysis' :: StartNetworkInsightsAccessScopeAnalysis -> Text
$sel:networkInsightsAccessScopeId:StartNetworkInsightsAccessScopeAnalysis' :: StartNetworkInsightsAccessScopeAnalysis -> Text
$sel:tagSpecifications:StartNetworkInsightsAccessScopeAnalysis' :: StartNetworkInsightsAccessScopeAnalysis -> Maybe [TagSpecification]
$sel:dryRun:StartNetworkInsightsAccessScopeAnalysis' :: StartNetworkInsightsAccessScopeAnalysis -> Maybe Bool
..} =
      Int
_salt
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
dryRun
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [TagSpecification]
tagSpecifications
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
networkInsightsAccessScopeId
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
clientToken

instance
  Prelude.NFData
    StartNetworkInsightsAccessScopeAnalysis
  where
  rnf :: StartNetworkInsightsAccessScopeAnalysis -> ()
rnf StartNetworkInsightsAccessScopeAnalysis' {Maybe Bool
Maybe [TagSpecification]
Text
clientToken :: Text
networkInsightsAccessScopeId :: Text
tagSpecifications :: Maybe [TagSpecification]
dryRun :: Maybe Bool
$sel:clientToken:StartNetworkInsightsAccessScopeAnalysis' :: StartNetworkInsightsAccessScopeAnalysis -> Text
$sel:networkInsightsAccessScopeId:StartNetworkInsightsAccessScopeAnalysis' :: StartNetworkInsightsAccessScopeAnalysis -> Text
$sel:tagSpecifications:StartNetworkInsightsAccessScopeAnalysis' :: StartNetworkInsightsAccessScopeAnalysis -> Maybe [TagSpecification]
$sel:dryRun:StartNetworkInsightsAccessScopeAnalysis' :: StartNetworkInsightsAccessScopeAnalysis -> Maybe Bool
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Bool
dryRun
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [TagSpecification]
tagSpecifications
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
networkInsightsAccessScopeId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
clientToken

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

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

instance
  Data.ToQuery
    StartNetworkInsightsAccessScopeAnalysis
  where
  toQuery :: StartNetworkInsightsAccessScopeAnalysis -> QueryString
toQuery StartNetworkInsightsAccessScopeAnalysis' {Maybe Bool
Maybe [TagSpecification]
Text
clientToken :: Text
networkInsightsAccessScopeId :: Text
tagSpecifications :: Maybe [TagSpecification]
dryRun :: Maybe Bool
$sel:clientToken:StartNetworkInsightsAccessScopeAnalysis' :: StartNetworkInsightsAccessScopeAnalysis -> Text
$sel:networkInsightsAccessScopeId:StartNetworkInsightsAccessScopeAnalysis' :: StartNetworkInsightsAccessScopeAnalysis -> Text
$sel:tagSpecifications:StartNetworkInsightsAccessScopeAnalysis' :: StartNetworkInsightsAccessScopeAnalysis -> Maybe [TagSpecification]
$sel:dryRun:StartNetworkInsightsAccessScopeAnalysis' :: StartNetworkInsightsAccessScopeAnalysis -> Maybe Bool
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"Action"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: ( ByteString
"StartNetworkInsightsAccessScopeAnalysis" ::
                      Prelude.ByteString
                  ),
        ByteString
"Version"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: (ByteString
"2016-11-15" :: Prelude.ByteString),
        ByteString
"DryRun" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Bool
dryRun,
        forall a. ToQuery a => a -> QueryString
Data.toQuery
          ( forall a.
(IsList a, ToQuery (Item a)) =>
ByteString -> a -> QueryString
Data.toQueryList ByteString
"TagSpecification"
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe [TagSpecification]
tagSpecifications
          ),
        ByteString
"NetworkInsightsAccessScopeId"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Text
networkInsightsAccessScopeId,
        ByteString
"ClientToken" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Text
clientToken
      ]

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

-- |
-- Create a value of 'StartNetworkInsightsAccessScopeAnalysisResponse' 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:
--
-- 'networkInsightsAccessScopeAnalysis', 'startNetworkInsightsAccessScopeAnalysisResponse_networkInsightsAccessScopeAnalysis' - The Network Access Scope analysis.
--
-- 'httpStatus', 'startNetworkInsightsAccessScopeAnalysisResponse_httpStatus' - The response's http status code.
newStartNetworkInsightsAccessScopeAnalysisResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  StartNetworkInsightsAccessScopeAnalysisResponse
newStartNetworkInsightsAccessScopeAnalysisResponse :: Int -> StartNetworkInsightsAccessScopeAnalysisResponse
newStartNetworkInsightsAccessScopeAnalysisResponse
  Int
pHttpStatus_ =
    StartNetworkInsightsAccessScopeAnalysisResponse'
      { $sel:networkInsightsAccessScopeAnalysis:StartNetworkInsightsAccessScopeAnalysisResponse' :: Maybe NetworkInsightsAccessScopeAnalysis
networkInsightsAccessScopeAnalysis =
          forall a. Maybe a
Prelude.Nothing,
        $sel:httpStatus:StartNetworkInsightsAccessScopeAnalysisResponse' :: Int
httpStatus = Int
pHttpStatus_
      }

-- | The Network Access Scope analysis.
startNetworkInsightsAccessScopeAnalysisResponse_networkInsightsAccessScopeAnalysis :: Lens.Lens' StartNetworkInsightsAccessScopeAnalysisResponse (Prelude.Maybe NetworkInsightsAccessScopeAnalysis)
startNetworkInsightsAccessScopeAnalysisResponse_networkInsightsAccessScopeAnalysis :: Lens'
  StartNetworkInsightsAccessScopeAnalysisResponse
  (Maybe NetworkInsightsAccessScopeAnalysis)
startNetworkInsightsAccessScopeAnalysisResponse_networkInsightsAccessScopeAnalysis = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartNetworkInsightsAccessScopeAnalysisResponse' {Maybe NetworkInsightsAccessScopeAnalysis
networkInsightsAccessScopeAnalysis :: Maybe NetworkInsightsAccessScopeAnalysis
$sel:networkInsightsAccessScopeAnalysis:StartNetworkInsightsAccessScopeAnalysisResponse' :: StartNetworkInsightsAccessScopeAnalysisResponse
-> Maybe NetworkInsightsAccessScopeAnalysis
networkInsightsAccessScopeAnalysis} -> Maybe NetworkInsightsAccessScopeAnalysis
networkInsightsAccessScopeAnalysis) (\s :: StartNetworkInsightsAccessScopeAnalysisResponse
s@StartNetworkInsightsAccessScopeAnalysisResponse' {} Maybe NetworkInsightsAccessScopeAnalysis
a -> StartNetworkInsightsAccessScopeAnalysisResponse
s {$sel:networkInsightsAccessScopeAnalysis:StartNetworkInsightsAccessScopeAnalysisResponse' :: Maybe NetworkInsightsAccessScopeAnalysis
networkInsightsAccessScopeAnalysis = Maybe NetworkInsightsAccessScopeAnalysis
a} :: StartNetworkInsightsAccessScopeAnalysisResponse)

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

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