{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
{-# OPTIONS_GHC -fno-warn-unused-matches #-}

-- Derived from AWS service descriptions, licensed under Apache 2.0.

-- |
-- Module      : Amazonka.NetworkManager.Types.RouteAnalysis
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
module Amazonka.NetworkManager.Types.RouteAnalysis where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import Amazonka.NetworkManager.Types.RouteAnalysisEndpointOptions
import Amazonka.NetworkManager.Types.RouteAnalysisPath
import Amazonka.NetworkManager.Types.RouteAnalysisStatus
import qualified Amazonka.Prelude as Prelude

-- | Describes a route analysis.
--
-- /See:/ 'newRouteAnalysis' smart constructor.
data RouteAnalysis = RouteAnalysis'
  { -- | The destination.
    RouteAnalysis -> Maybe RouteAnalysisEndpointOptions
destination :: Prelude.Maybe RouteAnalysisEndpointOptions,
    -- | The forward path.
    RouteAnalysis -> Maybe RouteAnalysisPath
forwardPath :: Prelude.Maybe RouteAnalysisPath,
    -- | The ID of the global network.
    RouteAnalysis -> Maybe Text
globalNetworkId :: Prelude.Maybe Prelude.Text,
    -- | Indicates whether to analyze the return path. The return path is not
    -- analyzed if the forward path analysis does not succeed.
    RouteAnalysis -> Maybe Bool
includeReturnPath :: Prelude.Maybe Prelude.Bool,
    -- | The ID of the AWS account that created the route analysis.
    RouteAnalysis -> Maybe Text
ownerAccountId :: Prelude.Maybe Prelude.Text,
    -- | The return path.
    RouteAnalysis -> Maybe RouteAnalysisPath
returnPath :: Prelude.Maybe RouteAnalysisPath,
    -- | The ID of the route analysis.
    RouteAnalysis -> Maybe Text
routeAnalysisId :: Prelude.Maybe Prelude.Text,
    -- | The source.
    RouteAnalysis -> Maybe RouteAnalysisEndpointOptions
source :: Prelude.Maybe RouteAnalysisEndpointOptions,
    -- | The time that the analysis started.
    RouteAnalysis -> Maybe POSIX
startTimestamp :: Prelude.Maybe Data.POSIX,
    -- | The status of the route analysis.
    RouteAnalysis -> Maybe RouteAnalysisStatus
status :: Prelude.Maybe RouteAnalysisStatus,
    -- | Indicates whether to include the location of middlebox appliances in the
    -- route analysis.
    RouteAnalysis -> Maybe Bool
useMiddleboxes :: Prelude.Maybe Prelude.Bool
  }
  deriving (RouteAnalysis -> RouteAnalysis -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RouteAnalysis -> RouteAnalysis -> Bool
$c/= :: RouteAnalysis -> RouteAnalysis -> Bool
== :: RouteAnalysis -> RouteAnalysis -> Bool
$c== :: RouteAnalysis -> RouteAnalysis -> Bool
Prelude.Eq, ReadPrec [RouteAnalysis]
ReadPrec RouteAnalysis
Int -> ReadS RouteAnalysis
ReadS [RouteAnalysis]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [RouteAnalysis]
$creadListPrec :: ReadPrec [RouteAnalysis]
readPrec :: ReadPrec RouteAnalysis
$creadPrec :: ReadPrec RouteAnalysis
readList :: ReadS [RouteAnalysis]
$creadList :: ReadS [RouteAnalysis]
readsPrec :: Int -> ReadS RouteAnalysis
$creadsPrec :: Int -> ReadS RouteAnalysis
Prelude.Read, Int -> RouteAnalysis -> ShowS
[RouteAnalysis] -> ShowS
RouteAnalysis -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RouteAnalysis] -> ShowS
$cshowList :: [RouteAnalysis] -> ShowS
show :: RouteAnalysis -> String
$cshow :: RouteAnalysis -> String
showsPrec :: Int -> RouteAnalysis -> ShowS
$cshowsPrec :: Int -> RouteAnalysis -> ShowS
Prelude.Show, forall x. Rep RouteAnalysis x -> RouteAnalysis
forall x. RouteAnalysis -> Rep RouteAnalysis x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep RouteAnalysis x -> RouteAnalysis
$cfrom :: forall x. RouteAnalysis -> Rep RouteAnalysis x
Prelude.Generic)

-- |
-- Create a value of 'RouteAnalysis' 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:
--
-- 'destination', 'routeAnalysis_destination' - The destination.
--
-- 'forwardPath', 'routeAnalysis_forwardPath' - The forward path.
--
-- 'globalNetworkId', 'routeAnalysis_globalNetworkId' - The ID of the global network.
--
-- 'includeReturnPath', 'routeAnalysis_includeReturnPath' - Indicates whether to analyze the return path. The return path is not
-- analyzed if the forward path analysis does not succeed.
--
-- 'ownerAccountId', 'routeAnalysis_ownerAccountId' - The ID of the AWS account that created the route analysis.
--
-- 'returnPath', 'routeAnalysis_returnPath' - The return path.
--
-- 'routeAnalysisId', 'routeAnalysis_routeAnalysisId' - The ID of the route analysis.
--
-- 'source', 'routeAnalysis_source' - The source.
--
-- 'startTimestamp', 'routeAnalysis_startTimestamp' - The time that the analysis started.
--
-- 'status', 'routeAnalysis_status' - The status of the route analysis.
--
-- 'useMiddleboxes', 'routeAnalysis_useMiddleboxes' - Indicates whether to include the location of middlebox appliances in the
-- route analysis.
newRouteAnalysis ::
  RouteAnalysis
newRouteAnalysis :: RouteAnalysis
newRouteAnalysis =
  RouteAnalysis'
    { $sel:destination:RouteAnalysis' :: Maybe RouteAnalysisEndpointOptions
destination = forall a. Maybe a
Prelude.Nothing,
      $sel:forwardPath:RouteAnalysis' :: Maybe RouteAnalysisPath
forwardPath = forall a. Maybe a
Prelude.Nothing,
      $sel:globalNetworkId:RouteAnalysis' :: Maybe Text
globalNetworkId = forall a. Maybe a
Prelude.Nothing,
      $sel:includeReturnPath:RouteAnalysis' :: Maybe Bool
includeReturnPath = forall a. Maybe a
Prelude.Nothing,
      $sel:ownerAccountId:RouteAnalysis' :: Maybe Text
ownerAccountId = forall a. Maybe a
Prelude.Nothing,
      $sel:returnPath:RouteAnalysis' :: Maybe RouteAnalysisPath
returnPath = forall a. Maybe a
Prelude.Nothing,
      $sel:routeAnalysisId:RouteAnalysis' :: Maybe Text
routeAnalysisId = forall a. Maybe a
Prelude.Nothing,
      $sel:source:RouteAnalysis' :: Maybe RouteAnalysisEndpointOptions
source = forall a. Maybe a
Prelude.Nothing,
      $sel:startTimestamp:RouteAnalysis' :: Maybe POSIX
startTimestamp = forall a. Maybe a
Prelude.Nothing,
      $sel:status:RouteAnalysis' :: Maybe RouteAnalysisStatus
status = forall a. Maybe a
Prelude.Nothing,
      $sel:useMiddleboxes:RouteAnalysis' :: Maybe Bool
useMiddleboxes = forall a. Maybe a
Prelude.Nothing
    }

-- | The destination.
routeAnalysis_destination :: Lens.Lens' RouteAnalysis (Prelude.Maybe RouteAnalysisEndpointOptions)
routeAnalysis_destination :: Lens' RouteAnalysis (Maybe RouteAnalysisEndpointOptions)
routeAnalysis_destination = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RouteAnalysis' {Maybe RouteAnalysisEndpointOptions
destination :: Maybe RouteAnalysisEndpointOptions
$sel:destination:RouteAnalysis' :: RouteAnalysis -> Maybe RouteAnalysisEndpointOptions
destination} -> Maybe RouteAnalysisEndpointOptions
destination) (\s :: RouteAnalysis
s@RouteAnalysis' {} Maybe RouteAnalysisEndpointOptions
a -> RouteAnalysis
s {$sel:destination:RouteAnalysis' :: Maybe RouteAnalysisEndpointOptions
destination = Maybe RouteAnalysisEndpointOptions
a} :: RouteAnalysis)

-- | The forward path.
routeAnalysis_forwardPath :: Lens.Lens' RouteAnalysis (Prelude.Maybe RouteAnalysisPath)
routeAnalysis_forwardPath :: Lens' RouteAnalysis (Maybe RouteAnalysisPath)
routeAnalysis_forwardPath = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RouteAnalysis' {Maybe RouteAnalysisPath
forwardPath :: Maybe RouteAnalysisPath
$sel:forwardPath:RouteAnalysis' :: RouteAnalysis -> Maybe RouteAnalysisPath
forwardPath} -> Maybe RouteAnalysisPath
forwardPath) (\s :: RouteAnalysis
s@RouteAnalysis' {} Maybe RouteAnalysisPath
a -> RouteAnalysis
s {$sel:forwardPath:RouteAnalysis' :: Maybe RouteAnalysisPath
forwardPath = Maybe RouteAnalysisPath
a} :: RouteAnalysis)

-- | The ID of the global network.
routeAnalysis_globalNetworkId :: Lens.Lens' RouteAnalysis (Prelude.Maybe Prelude.Text)
routeAnalysis_globalNetworkId :: Lens' RouteAnalysis (Maybe Text)
routeAnalysis_globalNetworkId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RouteAnalysis' {Maybe Text
globalNetworkId :: Maybe Text
$sel:globalNetworkId:RouteAnalysis' :: RouteAnalysis -> Maybe Text
globalNetworkId} -> Maybe Text
globalNetworkId) (\s :: RouteAnalysis
s@RouteAnalysis' {} Maybe Text
a -> RouteAnalysis
s {$sel:globalNetworkId:RouteAnalysis' :: Maybe Text
globalNetworkId = Maybe Text
a} :: RouteAnalysis)

-- | Indicates whether to analyze the return path. The return path is not
-- analyzed if the forward path analysis does not succeed.
routeAnalysis_includeReturnPath :: Lens.Lens' RouteAnalysis (Prelude.Maybe Prelude.Bool)
routeAnalysis_includeReturnPath :: Lens' RouteAnalysis (Maybe Bool)
routeAnalysis_includeReturnPath = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RouteAnalysis' {Maybe Bool
includeReturnPath :: Maybe Bool
$sel:includeReturnPath:RouteAnalysis' :: RouteAnalysis -> Maybe Bool
includeReturnPath} -> Maybe Bool
includeReturnPath) (\s :: RouteAnalysis
s@RouteAnalysis' {} Maybe Bool
a -> RouteAnalysis
s {$sel:includeReturnPath:RouteAnalysis' :: Maybe Bool
includeReturnPath = Maybe Bool
a} :: RouteAnalysis)

-- | The ID of the AWS account that created the route analysis.
routeAnalysis_ownerAccountId :: Lens.Lens' RouteAnalysis (Prelude.Maybe Prelude.Text)
routeAnalysis_ownerAccountId :: Lens' RouteAnalysis (Maybe Text)
routeAnalysis_ownerAccountId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RouteAnalysis' {Maybe Text
ownerAccountId :: Maybe Text
$sel:ownerAccountId:RouteAnalysis' :: RouteAnalysis -> Maybe Text
ownerAccountId} -> Maybe Text
ownerAccountId) (\s :: RouteAnalysis
s@RouteAnalysis' {} Maybe Text
a -> RouteAnalysis
s {$sel:ownerAccountId:RouteAnalysis' :: Maybe Text
ownerAccountId = Maybe Text
a} :: RouteAnalysis)

-- | The return path.
routeAnalysis_returnPath :: Lens.Lens' RouteAnalysis (Prelude.Maybe RouteAnalysisPath)
routeAnalysis_returnPath :: Lens' RouteAnalysis (Maybe RouteAnalysisPath)
routeAnalysis_returnPath = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RouteAnalysis' {Maybe RouteAnalysisPath
returnPath :: Maybe RouteAnalysisPath
$sel:returnPath:RouteAnalysis' :: RouteAnalysis -> Maybe RouteAnalysisPath
returnPath} -> Maybe RouteAnalysisPath
returnPath) (\s :: RouteAnalysis
s@RouteAnalysis' {} Maybe RouteAnalysisPath
a -> RouteAnalysis
s {$sel:returnPath:RouteAnalysis' :: Maybe RouteAnalysisPath
returnPath = Maybe RouteAnalysisPath
a} :: RouteAnalysis)

-- | The ID of the route analysis.
routeAnalysis_routeAnalysisId :: Lens.Lens' RouteAnalysis (Prelude.Maybe Prelude.Text)
routeAnalysis_routeAnalysisId :: Lens' RouteAnalysis (Maybe Text)
routeAnalysis_routeAnalysisId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RouteAnalysis' {Maybe Text
routeAnalysisId :: Maybe Text
$sel:routeAnalysisId:RouteAnalysis' :: RouteAnalysis -> Maybe Text
routeAnalysisId} -> Maybe Text
routeAnalysisId) (\s :: RouteAnalysis
s@RouteAnalysis' {} Maybe Text
a -> RouteAnalysis
s {$sel:routeAnalysisId:RouteAnalysis' :: Maybe Text
routeAnalysisId = Maybe Text
a} :: RouteAnalysis)

-- | The source.
routeAnalysis_source :: Lens.Lens' RouteAnalysis (Prelude.Maybe RouteAnalysisEndpointOptions)
routeAnalysis_source :: Lens' RouteAnalysis (Maybe RouteAnalysisEndpointOptions)
routeAnalysis_source = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RouteAnalysis' {Maybe RouteAnalysisEndpointOptions
source :: Maybe RouteAnalysisEndpointOptions
$sel:source:RouteAnalysis' :: RouteAnalysis -> Maybe RouteAnalysisEndpointOptions
source} -> Maybe RouteAnalysisEndpointOptions
source) (\s :: RouteAnalysis
s@RouteAnalysis' {} Maybe RouteAnalysisEndpointOptions
a -> RouteAnalysis
s {$sel:source:RouteAnalysis' :: Maybe RouteAnalysisEndpointOptions
source = Maybe RouteAnalysisEndpointOptions
a} :: RouteAnalysis)

-- | The time that the analysis started.
routeAnalysis_startTimestamp :: Lens.Lens' RouteAnalysis (Prelude.Maybe Prelude.UTCTime)
routeAnalysis_startTimestamp :: Lens' RouteAnalysis (Maybe UTCTime)
routeAnalysis_startTimestamp = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RouteAnalysis' {Maybe POSIX
startTimestamp :: Maybe POSIX
$sel:startTimestamp:RouteAnalysis' :: RouteAnalysis -> Maybe POSIX
startTimestamp} -> Maybe POSIX
startTimestamp) (\s :: RouteAnalysis
s@RouteAnalysis' {} Maybe POSIX
a -> RouteAnalysis
s {$sel:startTimestamp:RouteAnalysis' :: Maybe POSIX
startTimestamp = Maybe POSIX
a} :: RouteAnalysis) 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 (a :: Format). Iso' (Time a) UTCTime
Data._Time

-- | The status of the route analysis.
routeAnalysis_status :: Lens.Lens' RouteAnalysis (Prelude.Maybe RouteAnalysisStatus)
routeAnalysis_status :: Lens' RouteAnalysis (Maybe RouteAnalysisStatus)
routeAnalysis_status = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RouteAnalysis' {Maybe RouteAnalysisStatus
status :: Maybe RouteAnalysisStatus
$sel:status:RouteAnalysis' :: RouteAnalysis -> Maybe RouteAnalysisStatus
status} -> Maybe RouteAnalysisStatus
status) (\s :: RouteAnalysis
s@RouteAnalysis' {} Maybe RouteAnalysisStatus
a -> RouteAnalysis
s {$sel:status:RouteAnalysis' :: Maybe RouteAnalysisStatus
status = Maybe RouteAnalysisStatus
a} :: RouteAnalysis)

-- | Indicates whether to include the location of middlebox appliances in the
-- route analysis.
routeAnalysis_useMiddleboxes :: Lens.Lens' RouteAnalysis (Prelude.Maybe Prelude.Bool)
routeAnalysis_useMiddleboxes :: Lens' RouteAnalysis (Maybe Bool)
routeAnalysis_useMiddleboxes = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RouteAnalysis' {Maybe Bool
useMiddleboxes :: Maybe Bool
$sel:useMiddleboxes:RouteAnalysis' :: RouteAnalysis -> Maybe Bool
useMiddleboxes} -> Maybe Bool
useMiddleboxes) (\s :: RouteAnalysis
s@RouteAnalysis' {} Maybe Bool
a -> RouteAnalysis
s {$sel:useMiddleboxes:RouteAnalysis' :: Maybe Bool
useMiddleboxes = Maybe Bool
a} :: RouteAnalysis)

instance Data.FromJSON RouteAnalysis where
  parseJSON :: Value -> Parser RouteAnalysis
parseJSON =
    forall a. String -> (Object -> Parser a) -> Value -> Parser a
Data.withObject
      String
"RouteAnalysis"
      ( \Object
x ->
          Maybe RouteAnalysisEndpointOptions
-> Maybe RouteAnalysisPath
-> Maybe Text
-> Maybe Bool
-> Maybe Text
-> Maybe RouteAnalysisPath
-> Maybe Text
-> Maybe RouteAnalysisEndpointOptions
-> Maybe POSIX
-> Maybe RouteAnalysisStatus
-> Maybe Bool
-> RouteAnalysis
RouteAnalysis'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"Destination")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"ForwardPath")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"GlobalNetworkId")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"IncludeReturnPath")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"OwnerAccountId")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"ReturnPath")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"RouteAnalysisId")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"Source")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"StartTimestamp")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"Status")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"UseMiddleboxes")
      )

instance Prelude.Hashable RouteAnalysis where
  hashWithSalt :: Int -> RouteAnalysis -> Int
hashWithSalt Int
_salt RouteAnalysis' {Maybe Bool
Maybe Text
Maybe POSIX
Maybe RouteAnalysisEndpointOptions
Maybe RouteAnalysisPath
Maybe RouteAnalysisStatus
useMiddleboxes :: Maybe Bool
status :: Maybe RouteAnalysisStatus
startTimestamp :: Maybe POSIX
source :: Maybe RouteAnalysisEndpointOptions
routeAnalysisId :: Maybe Text
returnPath :: Maybe RouteAnalysisPath
ownerAccountId :: Maybe Text
includeReturnPath :: Maybe Bool
globalNetworkId :: Maybe Text
forwardPath :: Maybe RouteAnalysisPath
destination :: Maybe RouteAnalysisEndpointOptions
$sel:useMiddleboxes:RouteAnalysis' :: RouteAnalysis -> Maybe Bool
$sel:status:RouteAnalysis' :: RouteAnalysis -> Maybe RouteAnalysisStatus
$sel:startTimestamp:RouteAnalysis' :: RouteAnalysis -> Maybe POSIX
$sel:source:RouteAnalysis' :: RouteAnalysis -> Maybe RouteAnalysisEndpointOptions
$sel:routeAnalysisId:RouteAnalysis' :: RouteAnalysis -> Maybe Text
$sel:returnPath:RouteAnalysis' :: RouteAnalysis -> Maybe RouteAnalysisPath
$sel:ownerAccountId:RouteAnalysis' :: RouteAnalysis -> Maybe Text
$sel:includeReturnPath:RouteAnalysis' :: RouteAnalysis -> Maybe Bool
$sel:globalNetworkId:RouteAnalysis' :: RouteAnalysis -> Maybe Text
$sel:forwardPath:RouteAnalysis' :: RouteAnalysis -> Maybe RouteAnalysisPath
$sel:destination:RouteAnalysis' :: RouteAnalysis -> Maybe RouteAnalysisEndpointOptions
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe RouteAnalysisEndpointOptions
destination
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe RouteAnalysisPath
forwardPath
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
globalNetworkId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
includeReturnPath
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
ownerAccountId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe RouteAnalysisPath
returnPath
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
routeAnalysisId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe RouteAnalysisEndpointOptions
source
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe POSIX
startTimestamp
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe RouteAnalysisStatus
status
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
useMiddleboxes

instance Prelude.NFData RouteAnalysis where
  rnf :: RouteAnalysis -> ()
rnf RouteAnalysis' {Maybe Bool
Maybe Text
Maybe POSIX
Maybe RouteAnalysisEndpointOptions
Maybe RouteAnalysisPath
Maybe RouteAnalysisStatus
useMiddleboxes :: Maybe Bool
status :: Maybe RouteAnalysisStatus
startTimestamp :: Maybe POSIX
source :: Maybe RouteAnalysisEndpointOptions
routeAnalysisId :: Maybe Text
returnPath :: Maybe RouteAnalysisPath
ownerAccountId :: Maybe Text
includeReturnPath :: Maybe Bool
globalNetworkId :: Maybe Text
forwardPath :: Maybe RouteAnalysisPath
destination :: Maybe RouteAnalysisEndpointOptions
$sel:useMiddleboxes:RouteAnalysis' :: RouteAnalysis -> Maybe Bool
$sel:status:RouteAnalysis' :: RouteAnalysis -> Maybe RouteAnalysisStatus
$sel:startTimestamp:RouteAnalysis' :: RouteAnalysis -> Maybe POSIX
$sel:source:RouteAnalysis' :: RouteAnalysis -> Maybe RouteAnalysisEndpointOptions
$sel:routeAnalysisId:RouteAnalysis' :: RouteAnalysis -> Maybe Text
$sel:returnPath:RouteAnalysis' :: RouteAnalysis -> Maybe RouteAnalysisPath
$sel:ownerAccountId:RouteAnalysis' :: RouteAnalysis -> Maybe Text
$sel:includeReturnPath:RouteAnalysis' :: RouteAnalysis -> Maybe Bool
$sel:globalNetworkId:RouteAnalysis' :: RouteAnalysis -> Maybe Text
$sel:forwardPath:RouteAnalysis' :: RouteAnalysis -> Maybe RouteAnalysisPath
$sel:destination:RouteAnalysis' :: RouteAnalysis -> Maybe RouteAnalysisEndpointOptions
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe RouteAnalysisEndpointOptions
destination
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe RouteAnalysisPath
forwardPath
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
globalNetworkId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Bool
includeReturnPath
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
ownerAccountId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe RouteAnalysisPath
returnPath
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
routeAnalysisId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe RouteAnalysisEndpointOptions
source
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe POSIX
startTimestamp
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe RouteAnalysisStatus
status
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Bool
useMiddleboxes